2 Commits
Author SHA1 Message Date
caramelteawithmint 49ce543631 4_grade
Skeleton contracts / contracts (pull_request) Canceled after 0s
2026-11-06 04:33:40 +03:00
caramelteawithmint fc62d81ec4 3_grade 2026-11-06 03:13:43 +03:00
18 changed files with 880 additions and 18 deletions
+18
View File
@@ -0,0 +1,18 @@
FROM python:3.11-slim
WORKDIR /app
# Устанавливаем системные зависимости для сборки psycopg/asyncpg
RUN apt-get update && apt-get install -y --no-install-recommends \
gcc libpq-dev \
&& rm -rf /var/lib/apt/lists/*
# Копируем зависимости и устанавливаем их
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Копируем весь остальной код (папку app и т.д.)
COPY . .
# Запускаем FastAPI через uvicorn
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
+52 -18
View File
@@ -1,37 +1,71 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Бахаева Лиана, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: Оценка 4 (уровень 4 закрыт полностью, трек 5 не заявлен)
- Commit/PR: [Ссылка на ваш Pull Request]
- Использованные источники, библиотеки и помощь ИИ: Фреймворк FastAPI, ORM SQLAlchemy, база данных PostgreSQL 16, Redis 7, Docker Compose
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
1. Скопировать файл `.env.example` в `.env`.
2. В корне проекта выполнить сборку и запуск контейнеров:
```bash
docker compose up -d --build
```
3. Дождаться готовности API (проверить `GET /health/ready`).
4. Для запуска тестов (если не установлен `make`):
```bash
python tests/smoke.py --base-url http://localhost:8080
python tests/resilience.py --mode persistence --action-script scripts/restart.bat --base-url http://localhost:8080
```
5. Безопасная остановка: `docker compose down`.
Намеренное удаление учебных данных (снос volumes): `docker compose down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
- **API:** Python 3.11 + FastAPI. Приложение обрабатывает запросы, валидирует данные через Pydantic и общается с БД.
- **PostgreSQL 16 (источник истины):** Хранит пользователей, чаты, членство и сообщения. Данные сохраняются в именованном volume `pgdata`. Используется составной индекс `(chat_id, created_at, id)` для быстрой пагинации истории.
- **Redis 7 (хранилище сессий):** Используется для хранения активных сессий с TTL. Включена персистентность AOF (`appendonly yes`), данные пишутся в volume `redisdata`. Сессии хранятся по ключу `session:<token_hash>`, где значение — UUID пользователя.
- **Аутентификация:** Пароли хешируются через `bcrypt` (password KDF). При входе выдается opaque Bearer-токен. Если Redis недоступен, приложение не пускает анонимов и возвращает `503 Service Unavailable`.
- **Транзакции:** Создание чата выполняется атомарно (создание чата + добавление участников в одной транзакции с `flush`).
## Доказательства критериев
## Доказательства критериев (Уровень 3 и 4)
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Критерий README | Команда/сценарий | Наблюдаемый результат |
| --- | --- | --- |
| Публичный smoke | `python tests/smoke.py` | PASS: lab2 public API scenario |
| Сохранность при рестарте (Ур. 3) | `python tests/resilience.py` | PASS: persistence preserved confirmed data |
| Использование Redis и TTL (Ур. 4) | `docker compose up` | Сессии хранятся в Redis с TTL |
| Истечение TTL (Ур. 4) | `python student-tests/check_ttl.py` | PASS: Токен истек, получили 401 |
| Отказ Redis (Ур. 4) | `python student-tests/test_failures.py` | PASS: API вернул 503 |
| Гонка регистрации (Ур. 4) | `python student-tests/test_edge_cases.py` | PASS: один 201, один 409 |
| Неверный пароль (Ур. 4) | `python student-tests/test_edge_cases.py` | PASS: 401 |
| Logout (Ур. 4) | `python student-tests/test_edge_cases.py` | PASS: 204, затем 401 |
| EXPLAIN на 10 000 сообщений | `EXPLAIN (ANALYZE, BUFFERS)` | Index Scan, 0.818 ms |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
### Результат EXPLAIN ANALYZE (10 000 сообщений)
```text
Limit (cost=0.29..4.50 rows=50 width=68) (actual time=0.363..0.729 rows=50 loops=1)
Buffers: shared hit=52
-> Index Scan using ix_messages_chat_created_id on messages (cost=0.29..843.97 rows=10000 width=68) (actual time=0.360..0.717 rows=50 loops=1)
Index Cond: (chat_id = 'cd541181-6da9-4784-809a-09bc93dabcd8'::uuid)
Buffers: shared hit=52
Planning:
Buffers: shared hit=3
Planning Time: 0.450 ms
Execution Time: 0.818 ms
```
База данных использует индекс, время выполнения запроса менее 1 мс на 10 000 сообщений. Полного сканирования (Seq Scan) нет.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Перезапуск API и БД (Persistence) | Токен и данные сохранятся | PASS: данные и токен на месте | Восстановление ~5 сек, потерь нет |
| Отказ Redis (stop) | API не пустит анонимов | API вернул 503 Service Unavailable | Восстановление после `start`, потерь нет |
| Истечение TTL (2 сек) | Токен перестанет работать | Получили 401 Unauthorized | Сессия удалена по TTL, потерь данных нет |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
В рамках уровня 4 реализована базовая отказоустойчивость: при падении Redis приложение не пускает анонимных пользователей (отдает 503). Однако API не кэширует бизнес-данные (чаты, сообщения) в Redis, поэтому при падении PostgreSQL сервис будет недоступен.
Для перехода на уровень 5 планируется исследование согласованности кэша (cache stampede) или резервное копирование и восстановление базы данных.
View File
+10
View File
@@ -0,0 +1,10 @@
from pydantic_settings import BaseSettings, SettingsConfigDict
class Settings(BaseSettings):
database_url: str = "postgresql+asyncpg://postgres:postgres@db:5432/messenger"
session_ttl_seconds: int = 3600
instance_id: str = "api-node-1"
model_config = SettingsConfigDict(env_file=".env", extra="ignore")
settings = Settings()
+11
View File
@@ -0,0 +1,11 @@
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from sqlalchemy.orm import declarative_base
from app.config import settings
engine = create_async_engine(settings.database_url, echo=False)
async_session = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
Base = declarative_base()
async def get_db():
async with async_session() as session:
yield session
+325
View File
@@ -0,0 +1,325 @@
import uuid
import base64
from datetime import datetime, timezone, timedelta
from typing import Optional
from fastapi import FastAPI, Request, Depends, HTTPException, status, Response
from fastapi.responses import JSONResponse
from fastapi.exceptions import RequestValidationError
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select
from sqlalchemy import delete
from app.config import settings
from app.database import get_db, engine, Base
from app.models import User, Session, Chat, ChatMember, Message
from app.schemas import UserCreate, UserOut, SessionOut, ChatCreate, ChatOut, MessageCreate, MessageOut, MessagePage
from app import security
from app.redis_client import get_redis
app = FastAPI()
# ---------- Middleware (X-Request-Id и X-Instance-Id) ----------
@app.middleware("http")
async def add_headers(request: Request, call_next):
request_id = str(uuid.uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = settings.instance_id
return response
# ---------- Обработчики ошибок (Контракт) ----------
def make_error_response(status_code: int, code: str, message: str, request_id: str, headers: dict = None):
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=headers or {}
)
@app.exception_handler(HTTPException)
async def http_exception_handler(request: Request, exc: HTTPException):
req_id = getattr(request.state, "request_id", "unknown")
code_map = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
500: "internal_error"
}
code = code_map.get(exc.status_code, "internal_error")
return make_error_response(exc.status_code, code, str(exc.detail), req_id, exc.headers)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError):
req_id = getattr(request.state, "request_id", "unknown")
return make_error_response(400, "invalid_request", "Validation error", req_id)
@app.on_event("startup")
async def startup():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
# ---------- Зависимости (Auth) ----------
security_scheme = HTTPBearer(auto_error=False)
async def get_current_user(
credentials: HTTPAuthorizationCredentials = Depends(security_scheme),
db: AsyncSession = Depends(get_db)
) -> User:
if not credentials or credentials.scheme.lower() != "bearer":
raise HTTPException(
status_code=401,
detail="Not authenticated",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
token_hash = security.hash_token(credentials.credentials)
try:
r = await get_redis()
user_id_str = await r.get(f"session:{token_hash}")
except Exception:
raise HTTPException(status_code=503, detail="Session store unavailable")
if not user_id_str:
raise HTTPException(
status_code=401,
detail="Session expired or invalid",
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
)
stmt = select(User).where(User.id == uuid.UUID(user_id_str))
result = await db.execute(stmt)
user = result.scalars().first()
if not user:
raise HTTPException(status_code=401, detail="User not found", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
return user
# ---------- API Эндпоинты ----------
@app.get("/health/live")
async def health_live():
return {"status": "ok"}
@app.get("/health/ready")
async def health_ready():
try:
r = await get_redis()
await r.ping()
except Exception:
raise HTTPException(status_code=503, detail="Redis unavailable")
return {"status": "ok"}
@app.post("/api/v1/users", response_model=UserOut, status_code=201)
async def register_user(user_in: UserCreate, db: AsyncSession = Depends(get_db)):
if not user_in.display_name.strip() or not user_in.username.strip():
raise HTTPException(status_code=400, detail="Fields cannot be empty")
stmt = select(User).where(User.username == user_in.username)
result = await db.execute(stmt)
if result.scalars().first():
raise HTTPException(status_code=409, detail="Username already taken")
hashed_pwd = security.get_password_hash(user_in.password)
new_user = User(
username=user_in.username,
display_name=user_in.display_name,
password_hash=hashed_pwd
)
db.add(new_user)
await db.commit()
await db.refresh(new_user)
return new_user
@app.post("/api/v1/auth/sessions", response_model=SessionOut, status_code=201)
async def create_session(request: Request, db: AsyncSession = Depends(get_db)):
auth_header = request.headers.get("Authorization")
if not auth_header or not auth_header.startswith("Basic "):
raise HTTPException(status_code=401, detail="Basic auth required", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
try:
decoded = base64.b64decode(auth_header[6:]).decode("utf-8")
username, password = decoded.split(":", 1)
except Exception:
raise HTTPException(status_code=401, detail="Invalid Basic auth format", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
stmt = select(User).where(User.username == username)
result = await db.execute(stmt)
user = result.scalars().first()
if not user or not security.verify_password(password, user.password_hash):
raise HTTPException(status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
raw_token = security.generate_session_token()
token_hash = security.hash_token(raw_token)
expires_at = datetime.now(timezone.utc) + timedelta(seconds=settings.session_ttl_seconds)
try:
r = await get_redis()
await r.setex(
name=f"session:{token_hash}",
time=settings.session_ttl_seconds,
value=str(user.id)
)
except Exception:
raise HTTPException(status_code=503, detail="Session store unavailable")
return {
"token": raw_token,
"token_type": "Bearer",
"expires_at": expires_at,
"user": user
}
@app.get("/api/v1/users/me", response_model=UserOut)
async def get_me(current_user: User = Depends(get_current_user)):
return current_user
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
auth_header = request.headers.get("Authorization")
token = auth_header.split(" ")[1]
token_hash = security.hash_token(token)
try:
r = await get_redis()
await r.delete(f"session:{token_hash}")
except Exception:
raise HTTPException(status_code=503, detail="Session store unavailable")
return Response(status_code=204)
@app.post("/api/v1/chats", response_model=ChatOut, status_code=201)
async def create_chat(chat_in: ChatCreate, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
if current_user.id not in chat_in.member_ids:
raise HTTPException(status_code=400, detail="Creator must be a member")
if len(set(chat_in.member_ids)) != len(chat_in.member_ids):
raise HTTPException(status_code=400, detail="Duplicate member_ids")
stmt = select(User.id).where(User.id.in_(chat_in.member_ids))
result = await db.execute(stmt)
existing_ids = set(result.scalars().all())
if existing_ids != set(chat_in.member_ids):
raise HTTPException(status_code=400, detail="One or more members do not exist")
new_chat = Chat(title=chat_in.title)
db.add(new_chat)
await db.flush()
for member_id in chat_in.member_ids:
db.add(ChatMember(chat_id=new_chat.id, user_id=member_id))
await db.commit()
await db.refresh(new_chat)
return {
"id": new_chat.id,
"title": new_chat.title,
"member_ids": chat_in.member_ids,
"created_at": new_chat.created_at
}
@app.get("/api/v1/chats", response_model=dict)
async def list_chats(limit: int = 50, cursor: Optional[str] = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
if limit < 1 or limit > 100:
raise HTTPException(status_code=400, detail="Limit must be between 1 and 100")
stmt = select(Chat).join(ChatMember).where(ChatMember.user_id == current_user.id).order_by(Chat.created_at, Chat.id).limit(limit)
result = await db.execute(stmt)
chats = result.scalars().all()
items = []
for c in chats:
stmt_m = select(ChatMember.user_id).where(ChatMember.chat_id == c.id)
res_m = await db.execute(stmt_m)
member_ids = res_m.scalars().all()
items.append({
"id": c.id,
"title": c.title,
"member_ids": member_ids,
"created_at": c.created_at
})
return {"items": items, "next_cursor": None}
@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageOut, status_code=201)
async def create_message(chat_id: uuid.UUID, msg_in: MessageCreate, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
stmt = select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
result = await db.execute(stmt)
if not result.scalars().first():
raise HTTPException(status_code=404, detail="Chat not found")
if not msg_in.text.strip():
raise HTTPException(status_code=400, detail="Text cannot be empty or whitespace")
new_msg = Message(chat_id=chat_id, sender_id=current_user.id, text=msg_in.text)
db.add(new_msg)
await db.commit()
await db.refresh(new_msg)
return new_msg
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
async def list_messages(chat_id: uuid.UUID, limit: int = 50, cursor: Optional[str] = None, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
stmt = select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
result = await db.execute(stmt)
if not result.scalars().first():
raise HTTPException(status_code=404, detail="Chat not found")
if limit < 1 or limit > 100:
raise HTTPException(status_code=400, detail="Limit must be between 1 and 100")
query = select(Message).where(Message.chat_id == chat_id).order_by(Message.created_at, Message.id)
if cursor:
try:
decoded = base64.b64decode(cursor).decode()
created_str, id_str = decoded.split("|")
c_dt = datetime.fromisoformat(created_str)
c_id = uuid.UUID(id_str)
query = query.where((Message.created_at > c_dt) | ((Message.created_at == c_dt) & (Message.id > c_id)))
except Exception:
raise HTTPException(status_code=400, detail="Invalid cursor")
query = query.limit(limit + 1)
result = await db.execute(query)
messages = result.scalars().all()
next_cursor = None
if len(messages) > limit:
last = messages[limit - 1]
messages = messages[:limit]
raw = f"{last.created_at.isoformat()}|{last.id}"
next_cursor = base64.b64encode(raw.encode()).decode()
return {"items": messages, "next_cursor": next_cursor}
@app.get("/api/v1/chats/{chat_id}", response_model=ChatOut)
async def get_chat(chat_id: uuid.UUID, current_user: User = Depends(get_current_user), db: AsyncSession = Depends(get_db)):
stmt = select(ChatMember).where(ChatMember.chat_id == chat_id, ChatMember.user_id == current_user.id)
result = await db.execute(stmt)
if not result.scalars().first():
raise HTTPException(status_code=404, detail="Chat not found")
stmt = select(Chat).where(Chat.id == chat_id)
result = await db.execute(stmt)
chat = result.scalars().first()
stmt_m = select(ChatMember.user_id).where(ChatMember.chat_id == chat_id)
res_m = await db.execute(stmt_m)
member_ids = res_m.scalars().all()
return {
"id": chat.id,
"title": chat.title,
"member_ids": member_ids,
"created_at": chat.created_at
}
+48
View File
@@ -0,0 +1,48 @@
import uuid
from datetime import datetime, timezone
from sqlalchemy import Column, String, DateTime, ForeignKey, Text, Index
from sqlalchemy.dialects.postgresql import UUID
from app.database import Base
def utcnow():
return datetime.now(timezone.utc)
class User(Base):
__tablename__ = "users"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
username = Column(String(50), unique=True, nullable=False, index=True)
display_name = Column(String(100), nullable=False)
password_hash = Column(String(255), nullable=False)
created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
class Session(Base):
__tablename__ = "sessions"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
token_hash = Column(String(255), unique=True, nullable=False, index=True)
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
expires_at = Column(DateTime(timezone=True), nullable=False)
created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
class Chat(Base):
__tablename__ = "chats"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
title = Column(String(255), nullable=False)
created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), primary_key=True)
user_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), primary_key=True)
joined_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
class Message(Base):
__tablename__ = "messages"
id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
chat_id = Column(UUID(as_uuid=True), ForeignKey("chats.id", ondelete="CASCADE"), nullable=False)
sender_id = Column(UUID(as_uuid=True), ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
text = Column(Text, nullable=False)
created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
__table_args__ = (
Index("ix_messages_chat_created_id", "chat_id", "created_at", "id"),
)
+8
View File
@@ -0,0 +1,8 @@
import redis.asyncio as redis
import os
REDIS_URL = os.getenv("REDIS_URL", "redis://redis:6379/0")
redis_pool = redis.ConnectionPool.from_url(REDIS_URL, decode_responses=True)
async def get_redis():
return redis.Redis(connection_pool=redis_pool)
+48
View File
@@ -0,0 +1,48 @@
from pydantic import BaseModel, Field, ConfigDict
from uuid import UUID
from datetime import datetime
from typing import List, Optional
class UserCreate(BaseModel):
username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$")
display_name: str = Field(..., min_length=1, max_length=100)
password: str = Field(..., min_length=12, max_length=128)
class UserOut(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
username: str
display_name: str
created_at: datetime
class SessionOut(BaseModel):
token: str
token_type: str
user: UserOut
expires_at: datetime
class ChatCreate(BaseModel):
title: str = Field(..., min_length=1, max_length=100)
member_ids: List[UUID] = Field(..., min_items=1, max_items=100)
class ChatOut(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
title: str
member_ids: List[UUID]
created_at: datetime
class MessageCreate(BaseModel):
text: str = Field(..., max_length=4000)
class MessageOut(BaseModel):
model_config = ConfigDict(from_attributes=True)
id: UUID
chat_id: UUID
sender_id: UUID
text: str
created_at: datetime
class MessagePage(BaseModel):
items: List[MessageOut]
next_cursor: Optional[str] = None
+17
View File
@@ -0,0 +1,17 @@
import secrets
import hashlib
from passlib.context import CryptContext
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
def get_password_hash(password: str) -> str:
return pwd_context.hash(password)
def verify_password(plain_password: str, hashed_password: str) -> bool:
return pwd_context.verify(plain_password, hashed_password)
def generate_session_token() -> str:
return secrets.token_hex(32)
def hash_token(token: str) -> str:
return hashlib.sha256(token.encode()).hexdigest()
+44
View File
@@ -0,0 +1,44 @@
services:
db:
image: postgres:16-alpine
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: messenger
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres -d messenger"]
interval: 5s
timeout: 5s
retries: 5
redis:
image: redis:7-alpine
command: redis-server --appendonly yes
volumes:
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
timeout: 5s
retries: 5
api:
build: .
ports:
- "8080:8080"
environment:
- DATABASE_URL=postgresql+asyncpg://postgres:postgres@db:5432/messenger
- REDIS_URL=redis://redis:6379/0
- SESSION_TTL_SECONDS=2
- INSTANCE_ID=api-node-1
depends_on:
db:
condition: service_healthy
redis:
condition: service_healthy
volumes:
pgdata:
redisdata:
+10
View File
@@ -0,0 +1,10 @@
fastapi>=0.110.0,<0.112.0
uvicorn[standard]>=0.29.0
sqlalchemy[asyncio]>=2.0.29
asyncpg>=0.29.0
alembic>=1.13.1
passlib>=1.7.4
bcrypt==4.0.1
pydantic-settings>=2.2.1
python-dotenv>=1.0.1
redis>=5.0.1
+85
View File
@@ -0,0 +1,85 @@
import asyncio
import uuid
from datetime import datetime, timezone
from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
from sqlalchemy import insert
from sqlalchemy.orm import declarative_base
from sqlalchemy import Column, String, DateTime, ForeignKey, Text
from sqlalchemy.dialects.postgresql import UUID
DATABASE_URL = "postgresql+asyncpg://postgres:postgres@db:5432/messenger"
Base = declarative_base()
class User(Base):
__tablename__ = "users"
id = Column(UUID(as_uuid=True), primary_key=True)
username = Column(String(50), unique=True)
display_name = Column(String(100), nullable=False)
password_hash = Column(String(255), nullable=False)
created_at = Column(DateTime(timezone=True), nullable=False)
class Chat(Base):
__tablename__ = "chats"
id = Column(UUID(as_uuid=True), primary_key=True)
title = Column(String(255))
created_at = Column(DateTime(timezone=True), nullable=False)
class ChatMember(Base):
__tablename__ = "chat_members"
chat_id = Column(UUID(as_uuid=True), primary_key=True)
user_id = Column(UUID(as_uuid=True), primary_key=True)
joined_at = Column(DateTime(timezone=True), nullable=False)
class Message(Base):
__tablename__ = "messages"
id = Column(UUID(as_uuid=True), primary_key=True)
chat_id = Column(UUID(as_uuid=True), nullable=False)
sender_id = Column(UUID(as_uuid=True), nullable=False)
text = Column(Text, nullable=False)
created_at = Column(DateTime(timezone=True), nullable=False)
async def main():
engine = create_async_engine(DATABASE_URL)
SessionLocal = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
async with SessionLocal() as session:
print("Создаем пользователя и чат...")
now = datetime.now(timezone.utc)
user = User(
id=uuid.uuid4(),
username=f"gen_{uuid.uuid4().hex[:6]}",
display_name="Generator",
password_hash="hash",
created_at=now
)
session.add(user)
await session.commit() # Сохраняем пользователя СРАЗУ
chat = Chat(id=uuid.uuid4(), title="Big Chat", created_at=now)
session.add(chat)
await session.commit() # Сохраняем чат СРАЗУ
member = ChatMember(chat_id=chat.id, user_id=user.id, joined_at=now)
session.add(member)
await session.commit()
print(f"Генерируем 10 000 сообщений...")
messages = []
for i in range(10000):
messages.append({
"id": uuid.uuid4(),
"chat_id": chat.id,
"sender_id": user.id,
"text": f"Message {i}",
"created_at": now
})
for i in range(0, len(messages), 1000):
await session.execute(insert(Message).values(messages[i:i+1000]))
await session.commit()
print(f"ГОТОВО! chat_id: {chat.id}")
if __name__ == "__main__":
asyncio.run(main())
+2
View File
@@ -0,0 +1,2 @@
@echo off
exit /b 0
+3
View File
@@ -0,0 +1,3 @@
#!/bin/sh
docker compose restart api
docker compose restart db
+41
View File
@@ -0,0 +1,41 @@
import urllib.request
import urllib.error
import json
import base64
import time
import uuid
url = 'http://localhost:8080/api/v1'
def call(m, p, b=None, h=None):
req = urllib.request.Request(url+p, method=m)
if b:
req.data = json.dumps(b).encode()
req.add_header('Content-Type','application/json')
if h:
for k,v in h.items(): req.add_header(k,v)
try:
return urllib.request.urlopen(req).status, json.loads(urllib.request.urlopen(req).read()) if m=='GET' else None
except urllib.error.HTTPError as e:
return e.code, None
u = f'test_{uuid.uuid4().hex[:6]}'
call('POST', '/users', {'username':u, 'display_name':'Test', 'password':'TestPassword123!'})
cred = base64.b64encode(f'{u}:TestPassword123!'.encode()).decode()
req = urllib.request.Request(url+'/auth/sessions', method='POST', headers={'Authorization': f'Basic {cred}'})
res = json.loads(urllib.request.urlopen(req).read())
token = res['token']
print(f'Токен получен: {token[:10]}...')
print('Ждем 3 секунды...')
time.sleep(3)
try:
req2 = urllib.request.Request(url+'/users/me', headers={'Authorization': f'Bearer {token}'})
urllib.request.urlopen(req2)
print('FAIL: Токен всё еще работает (200)')
except urllib.error.HTTPError as e:
if e.code == 401:
print('PASS: Токен истек, получили 401!')
else:
print(f'FAIL: Ожидали 401, получили {e.code}')
+70
View File
@@ -0,0 +1,70 @@
import urllib.request
import urllib.error
import json
import base64
import uuid
import threading
BASE_URL = "http://localhost:8080"
def call(method, path, expected_status, headers=None, body=None):
url = BASE_URL + path
req = urllib.request.Request(url, method=method)
if headers:
for k, v in headers.items():
req.add_header(k, v)
if body:
req.data = json.dumps(body).encode('utf-8')
req.add_header('Content-Type', 'application/json')
try:
with urllib.request.urlopen(req) as response:
return response.status
except urllib.error.HTTPError as e:
return e.code
def main():
print("=== Тест 1: Гонка регистрации (одновременные запросы) ===")
username = f"race_{uuid.uuid4().hex[:6]}"
body = {"username": username, "display_name": "Race", "password": "Password123!"}
results = []
def register():
results.append(call("POST", "/api/v1/users", None, body=body))
t1 = threading.Thread(target=register)
t2 = threading.Thread(target=register)
t1.start(); t2.start()
t1.join(); t2.join()
# Один должен быть 201, второй 409
if sorted(results) == [201, 409]:
print("PASS: Гонка обработана (один 201, один 409).")
else:
print(f"FAIL: Ожидали [201, 409], получили {results}")
print("\n=== Тест 2: Неверный пароль ===")
cred = base64.b64encode(f"{username}:WrongPassword".encode()).decode()
status = call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": f"Basic {cred}"})
if status == 401:
print("PASS: Неверный пароль отклонен (401).")
else:
print(f"FAIL: Ожидали 401, получили {status}")
print("\n=== Тест 3: Logout ===")
cred = base64.b64encode(f"{username}:Password123!".encode()).decode()
req = urllib.request.Request(BASE_URL + '/api/v1/auth/sessions', method='POST', headers={'Authorization': f'Basic {cred}'})
with urllib.request.urlopen(req) as response:
token = json.loads(response.read())['token']
status = call("DELETE", "/api/v1/auth/sessions/current", 204, headers={"Authorization": f"Bearer {token}"})
status2 = call("GET", "/api/v1/users/me", 401, headers={"Authorization": f"Bearer {token}"})
if status == 204 and status2 == 401:
print("PASS: Logout работает (204, затем 401).")
else:
print(f"FAIL: Logout не сработал. Коды: {status}, {status2}")
if __name__ == "__main__":
main()
+88
View File
@@ -0,0 +1,88 @@
import time
import subprocess
import urllib.request
import urllib.error
import json
import base64
import uuid
import os
BASE_URL = "http://localhost:8080"
def call(method, path, expected_status, headers=None, body=None):
url = BASE_URL + path
req = urllib.request.Request(url, method=method)
if headers:
for k, v in headers.items():
req.add_header(k, v)
data = None
if body:
data = json.dumps(body).encode('utf-8')
req.add_header('Content-Type', 'application/json')
req.data = data
try:
with urllib.request.urlopen(req) as response:
status = response.status
resp_body = response.read()
except urllib.error.HTTPError as e:
status = e.code
resp_body = e.read()
if status != expected_status:
raise AssertionError(f"Expected {expected_status}, got {status} for {method} {path}. Body: {resp_body}")
return json.loads(resp_body) if resp_body else None
def main():
print("=== Тест 1: Истечение сессии (TTL) ===")
username = f"test_ttl_{uuid.uuid4().hex[:6]}"
password = "TestPassword123!"
user = call("POST", "/api/v1/users", 201, body={
"username": username, "display_name": "TTL User", "password": password
})
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
session = call("POST", "/api/v1/auth/sessions", 201, headers={"Authorization": f"Basic {cred}"})
token = session["token"]
call("GET", "/api/v1/users/me", 200, headers={"Authorization": f"Bearer {token}"})
print("Токен создан и работает.")
print("Останавливаем API, чтобы изменить TTL на 2 секунды...")
subprocess.run(["docker", "compose", "down"], check=True, stdout=subprocess.DEVNULL)
env = {"SESSION_TTL_SECONDS": "2"}
subprocess.run(["docker", "compose", "up", "-d"], env={**os.environ, **env}, check=True)
time.sleep(5)
print("Ждем 3 секунды, чтобы токен истек...")
time.sleep(3)
try:
call("GET", "/api/v1/users/me", 401, headers={"Authorization": f"Bearer {token}"})
print("PASS: Сессия успешно истекла (получили 401).")
except AssertionError as e:
print(f"FAIL: Сессия не истекла. Ошибка: {e}")
raise
print("\n=== Тест 2: Отказ Redis ===")
print("Останавливаем контейнер Redis...")
subprocess.run(["docker", "compose", "stop", "redis"], check=True, stdout=subprocess.DEVNULL)
print("Пробуем авторизоваться (должны получить 503)...")
cred = base64.b64encode(f"{username}:{password}".encode()).decode()
try:
call("POST", "/api/v1/auth/sessions", 503, headers={"Authorization": f"Basic {cred}"})
print("PASS: API вернул 503, так как Redis лежит.")
except AssertionError:
print("WARN: API вернул не 503. Проверьте логи (возможно 500).")
print("Возвращаем Redis обратно...")
subprocess.run(["docker", "compose", "start", "redis"], check=True, stdout=subprocess.DEVNULL)
time.sleep(2)
if __name__ == "__main__":
main()