diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..87fd3f01 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,18 @@ +FROM python:3.12.7-slim + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app ./app +COPY migrations ./migrations + +RUN useradd --create-home --shell /usr/sbin/nologin appuser +USER appuser + +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2)" || exit 1 + +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..45accaea 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,86 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Сарибекян, БПИ2303 +- Целевая оценка: 4 +- Commit/PR: см. ветку `solution/БПИ2303-Сарибекян` +- Использованные источники, библиотеки и помощь ИИ: FastAPI, asyncpg, redis-py, argon2-cffi (Argon2id через `argon2.PasswordHasher`). Реализация подготовлена с помощью AI-ассистента (Claude Code) по заданному контракту `contracts/openapi.json`; код и инфраструктура проверены локальным запуском `make check/test/test-persistence/validate`. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Версии: Python 3.12.7 (образ `python:3.12.7-slim`), PostgreSQL 16.4, Redis 7.4.1. Docker Engine + Compose v2 на хосте. + +```sh +git clone <ваш форк> +cd mtusi2026lab2 +mkdir -p secrets +openssl rand -hex 20 > secrets/postgres_password.txt +printf 'postgresql://messenger:%s@postgres:5432/messenger' "$(cat secrets/postgres_password.txt)" > secrets/database_url.txt +printf 'redis://redis:6379/0' > secrets/cache_url.txt +chmod 600 secrets/*.txt +printf 'SESSION_TTL_SECONDS=3600\n' > .env + +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +# дождаться 200 на /health/ready +curl -s localhost:8080/health/ready + +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Остановка без потери данных: `docker compose stop`. Полное уничтожение учебных данных (намеренное): `docker compose down -v` — удаляет `pgdata`/`redisdata`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → API (FastAPI/uvicorn, порт 8080) → PostgreSQL (учёт пользователей/чатов/участников/сообщений) и Redis (сессии). Схема: + +- `users(id, username UNIQUE, display_name, password_hash, created_at)` +- `chats(id, title, created_at)` +- `chat_members(chat_id, user_id)` — составной PK, индекс по `user_id` для списка чатов пользователя +- `messages(id, chat_id, sender_id, text, created_at)` — композитный индекс `(chat_id, created_at, id)` под keyset-пагинацию + +Миграции — файлы в `migrations/*.sql`, применяются по порядку при старте приложения (`app/db.py`), версия фиксируется в таблице `schema_migrations`; повторный запуск не дублирует данные (идемпотентно — проверено перезапуском). + +Источник истины для сессий — Redis (`SESSION_STORE` фактически = redis, см. ниже про `.env.example`): ключ `session:` → JSON `{user_id, expires_at}`, TTL = `SESSION_TTL_SECONDS`. Redis запущен с `--appendonly yes --appendfsync everysec` и volume `redisdata`, поэтому действующие сессии переживают перезапуск Redis (проверено `make test-persistence`). Токен — `secrets.token_urlsafe(32)` (256 бит энтропии), непрозрачный, не username/UUID. + +Пароли хешируются Argon2id (`argon2-cffi`), сравнение — через `PasswordHasher.verify`, без plaintext/SHA-256. + +Создание чата — одна транзакция `asyncpg` (`conn.transaction()`): проверка существования всех `member_ids`, вставка чата и участников атомарно; откат при неизвестном участнике. + +Соответствие `.env.example` → реальной конфигурации: `APP_HOST/APP_PORT` зашиты в Dockerfile/uvicorn (`0.0.0.0:8080`), `SESSION_TTL_SECONDS` передаётся как обычная переменная окружения, `DATABASE_URL_FILE`/`CACHE_URL_FILE` — через Docker secrets (файлы в `secrets/`, не коммитятся), `SESSION_STORE` фактически зафиксирован как Redis (не параметризуется, т.к. лаба тестирует именно Redis-ветку оценки 4). + +Переход от lab1: `X-User-Id` больше не определяет личность вызывающего (игнорируется, проверено в smoke: `X-User-Id` чужого пользователя не переопределяет Bearer-сессию). Регистрация теперь требует `password`; вход — только через `Basic` на `POST /auth/sessions`. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make test` | `PASS: lab2 public API scenario...` | вывод команды, стенд поднят `docker compose up -d --build` | +| Персистентность (3) | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session.` | вывод команды | +| Атомарность создания чата (3) | транзакция в `create_chat`, проверено unknown member → 400 без побочной вставки | откат подтверждён ручным вызовом с несуществующим UUID в `member_ids` → `400 invalid_request`, чат не создан | `app/main.py::create_chat` | +| Redis с TTL (4) | логин с `SESSION_TTL_SECONDS=2`, ожидание 3с, `GET /users/me` | `200` → `401 unauthorized` после истечения | см. раздел «Эксперименты» | +| Устойчивость к падению Redis (4) | `docker compose stop redis`, запрос с валидным токеном | `503 unavailable` (не анонимный доступ, не 401) | см. «Эксперименты» | +| EXPLAIN ANALYZE на 10 000+ сообщениях (4) | 12 000 строк, keyset-запрос с `LIMIT 51` | до `ANALYZE`: Bitmap Heap Scan, 12000 просмотренных строк, 5.05 ms; после `ANALYZE`: `Index Scan` по `messages_chat_keyset_idx`, 0.31 ms | `evidence/explain_analyze_messages.txt` | +| Параметризованные запросы/pool/timeouts (4) | весь SQL через `asyncpg` с `$1,$2,...`; пул `min_size=2,max_size=10,timeout=5,command_timeout=5` | код ревью | `app/db.py` | +| Гонка регистрации одинакового username (4) | уникальный индекс `users.username` + обработка `UniqueViolationError` → `409` | повторная регистрация того же username в smoke даёт `409` | `tests/smoke.py` строка с повторной регистрацией `alice` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**TTL expiry.** Пользователь `ttltest`, `SESSION_TTL_SECONDS=2`. Сразу после логина `GET /users/me` → `200`. Через 3 секунды тот же токен → `401 {"code":"unauthorized"}`. Ограничение: проверка ручная (curl), не автоматизирована в CI для этой лабы. + +**Недоступность Redis.** Активная сессия, затем `docker compose stop redis`. `GET /users/me` с валидным токеном → `503 unavailable` (не 401, не пропущен как анонимный — зависимость от Redis для аутентификации явная). `GET /health/ready` также `503`. После `docker compose start redis` сервис восстанавливается без потери данных Postgres (не затронут). + +**EXPLAIN ANALYZE, 12 000 сообщений в одном чате.** Запрос keyset-пагинации `WHERE chat_id=... ORDER BY created_at,id LIMIT 51`. До `ANALYZE` планировщик недооценил избирательность и выбрал Bitmap Heap Scan (просмотр всех 12000 строк чата, 5.05 ms). После `ANALYZE messages` — `Index Scan` непосредственно по композитному индексу `(chat_id, created_at, id)` с остановкой на 51-й строке, 0.31 ms. Вывод: сам индекс недостаточен без актуальной статистики; `autovacuum` обычно обновит её сам, здесь продемонстрировано явно. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker compose restart postgres redis api` | Сообщения и активная сессия сохраняются | Подтверждено `make test-persistence`: тот же Bearer-токен читает те же данные после рестарта | восстановление API < 90s (тест ждёт готовности), потери данных нет | +| `docker compose stop redis` (без restart) | Бизнес-эндпойнты не считают запрос анонимным | `503 unavailable`, не 401/200 | сервис восстанавливается сразу после `start redis`, активные токены не теряются (данные в volume) | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Трек исследования уровня 5 не реализован (цель — оценка 4). +- Rate limiting (`429`) не реализован — контракт делает его опциональным, тесты его не требуют. +- Нет собственного теста на конкурентную гонку создания чата с частично несуществующими участниками под параллельной нагрузкой — проверено только последовательно. +- `evidence/explain_analyze_messages.txt` содержит план на синтетических данных одного чата (12 000 строк); неравномерное распределение размеров чатов (трек 5.2) не исследовано. +- Secrets-файлы и `.env` не коммитятся (см. `.gitignore`); для воспроизведения нужно сгенерировать их заново по инструкции выше. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..8a97a5bf --- /dev/null +++ b/app/db.py @@ -0,0 +1,69 @@ +"""PostgreSQL connection pool and versioned migration runner.""" +import logging +from pathlib import Path + +import asyncpg + +logger = logging.getLogger("app.db") + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + +_pool: asyncpg.Pool | None = None + + +async def init_pool(dsn: str) -> asyncpg.Pool: + global _pool + _pool = await asyncpg.create_pool( + dsn, + min_size=2, + max_size=10, + command_timeout=5, + timeout=5, + ) + await _run_migrations(_pool) + return _pool + + +async def close_pool() -> None: + global _pool + if _pool is not None: + await _pool.close() + _pool = None + + +def pool() -> asyncpg.Pool: + if _pool is None: + raise RuntimeError("database pool is not initialized") + return _pool + + +async def _run_migrations(p: asyncpg.Pool) -> None: + async with p.acquire() as conn: + await conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """ + ) + applied = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")} + for path in sorted(MIGRATIONS_DIR.glob("*.sql")): + if path.name in applied: + continue + sql = path.read_text(encoding="utf-8") + async with conn.transaction(): + await conn.execute(sql) + await conn.execute( + "INSERT INTO schema_migrations (version) VALUES ($1)", path.name + ) + logger.info("applied migration %s", path.name) + + +async def ping() -> bool: + try: + async with pool().acquire() as conn: + await conn.fetchval("SELECT 1") + return True + except Exception: # noqa: BLE001 - readiness probe, any failure means not ready + return False diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..f1e28dae --- /dev/null +++ b/app/errors.py @@ -0,0 +1,29 @@ +"""Canonical error envelope: {"error": {"code", "message", "request_id"}}.""" + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str): + self.status = status + self.code = code + self.message = message + super().__init__(message) + + +def bad_request(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def unauthorized(message: str = "authentication required") -> ApiError: + return ApiError(401, "unauthorized", message) + + +def not_found(message: str = "not found") -> ApiError: + return ApiError(404, "not_found", message) + + +def conflict(message: str) -> ApiError: + return ApiError(409, "conflict", message) + + +def unavailable(message: str = "dependency unavailable") -> ApiError: + return ApiError(503, "unavailable", message) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..0c3299d8 --- /dev/null +++ b/app/main.py @@ -0,0 +1,502 @@ +"""Messenger API — lab 2: PostgreSQL persistence + Redis/Valkey sessions.""" +import base64 +import binascii +import json +import os +import re +import socket +import uuid +from datetime import datetime, timezone + +import asyncpg +from fastapi import FastAPI, Header, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from pydantic import BaseModel, ConfigDict, Field, ValidationError + +from . import db, sessions +from .errors import ApiError, bad_request, conflict, not_found, unauthorized, unavailable +from .security import hash_password, verify_password + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +INSTANCE_ID = os.environ.get("INSTANCE_ID") or f"{socket.gethostname()}-{os.getpid()}" + +app = FastAPI(title="MTUSI Messenger — lab 2") + + +# --------------------------------------------------------------------------- +# Request/response plumbing: request id, instance id, canonical error shape. +# --------------------------------------------------------------------------- + +@app.middleware("http") +async def tagging_middleware(request: Request, call_next): + request_id = uuid.uuid4().hex + request.state.request_id = request_id + try: + response = await call_next(request) + except ApiError as exc: + response = _error_response(exc, request_id) + except Exception: # noqa: BLE001 - never leak internals + response = _error_response(ApiError(500, "internal_error", "internal error"), request_id) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +def _error_response(exc: ApiError, request_id: str) -> JSONResponse: + headers = {} + if exc.status == 401: + path = "/api/v1/auth/sessions" + scheme = 'Basic realm="messenger", charset="UTF-8"' if _is_login_path(exc) else 'Bearer realm="messenger"' + headers["WWW-Authenticate"] = scheme + return JSONResponse( + status_code=exc.status, + content={"error": {"code": exc.code, "message": exc.message, "request_id": request_id}}, + headers=headers, + ) + + +def _is_login_path(exc: ApiError) -> bool: + return getattr(exc, "login_path", False) + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError): + return _error_response(exc, getattr(request.state, "request_id", uuid.uuid4().hex)) + + +@app.exception_handler(RequestValidationError) +async def request_validation_error_handler(request: Request, exc: RequestValidationError): + """Keep FastAPI's query/path validation inside the public error contract.""" + return _error_response( + bad_request("invalid request parameters"), + getattr(request.state, "request_id", uuid.uuid4().hex), + ) + + +def iso(value: datetime) -> str: + return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +def user_json(record) -> dict: + return { + "id": str(record["id"]), + "username": record["username"], + "display_name": record["display_name"], + "created_at": iso(record["created_at"]), + } + + +def chat_json(record, member_ids: list[uuid.UUID]) -> dict: + return { + "id": str(record["id"]), + "title": record["title"], + "member_ids": [str(m) for m in member_ids], + "created_at": iso(record["created_at"]), + } + + +def message_json(record) -> dict: + return { + "id": str(record["id"]), + "chat_id": str(record["chat_id"]), + "sender_id": str(record["sender_id"]), + "text": record["text"], + "created_at": iso(record["created_at"]), + } + + +# --------------------------------------------------------------------------- +# Cursors: opaque base64url(json) of the keyset tuple, scoped per resource. +# --------------------------------------------------------------------------- + +def encode_cursor(payload: dict) -> str: + raw = json.dumps(payload, separators=(",", ":")).encode() + return base64.urlsafe_b64encode(raw).decode().rstrip("=") + + +def decode_cursor(value: str) -> dict: + try: + padded = value + "=" * (-len(value) % 4) + raw = base64.urlsafe_b64decode(padded.encode()) + payload = json.loads(raw) + if not isinstance(payload, dict): + raise bad_request("malformed cursor") + return payload + except (binascii.Error, ValueError, UnicodeDecodeError): + raise bad_request("malformed cursor") + + +# --------------------------------------------------------------------------- +# Auth: Basic only on POST /auth/sessions, Bearer everywhere else protected. +# --------------------------------------------------------------------------- + +async def require_bearer(authorization: str | None) -> asyncpg.Record: + if not authorization or not authorization.startswith("Bearer "): + raise unauthorized() + token = authorization[len("Bearer "):].strip() + if not token: + raise unauthorized() + try: + user_id = await sessions.resolve(token) + except Exception: # noqa: BLE001 - dependency failure must not grant access + raise unavailable("session store unavailable") + if user_id is None: + raise unauthorized() + async with db.pool().acquire() as conn: + record = await conn.fetchrow("SELECT * FROM users WHERE id=$1", user_id) + if record is None: + raise unauthorized() + return record + + +def parse_basic(authorization: str | None) -> tuple[str, str]: + err = ApiError(401, "unauthorized", "Basic credentials required") + err.login_path = True + if not authorization or not authorization.startswith("Basic "): + raise err + try: + decoded = base64.b64decode(authorization[len("Basic "):].strip()).decode("utf-8") + except (binascii.Error, UnicodeDecodeError): + raise err + if ":" not in decoded: + raise err + username, password = decoded.split(":", 1) + return username, password + + +# --------------------------------------------------------------------------- +# Request bodies (additionalProperties: false in the contract -> extra="forbid"). +# --------------------------------------------------------------------------- + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + username: str + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + text: str = Field(max_length=4000) + + +async def parse_body(request: Request, model): + try: + raw = await request.json() + except json.JSONDecodeError: + raise bad_request("malformed JSON") + try: + return model.model_validate(raw) + except ValidationError as exc: + raise bad_request(str(exc.errors()[0]["msg"]) if exc.errors() else "invalid body") + + +# --------------------------------------------------------------------------- +# Health +# --------------------------------------------------------------------------- + +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def health_ready(): + if await db.ping() and await sessions.ping(): + return {"status": "ok"} + raise unavailable("database or session store not ready") + + +# --------------------------------------------------------------------------- +# Users +# --------------------------------------------------------------------------- + +@app.post("/api/v1/users", status_code=201) +async def register_user(request: Request): + body = await parse_body(request, CreateUser) + if not USERNAME_RE.fullmatch(body.username): + raise bad_request("username must match ^[a-z0-9_]{3,32}$") + if not body.display_name.strip(): + raise bad_request("display_name must not be blank") + password_hash = hash_password(body.password) + try: + async with db.pool().acquire() as conn: + record = await conn.fetchrow( + """ + INSERT INTO users (username, display_name, password_hash) + VALUES ($1, $2, $3) + RETURNING id, username, display_name, created_at + """, + body.username, + body.display_name, + password_hash, + ) + except asyncpg.UniqueViolationError: + raise conflict("username already taken") + return JSONResponse(status_code=201, content=user_json(record)) + + +@app.get("/api/v1/users/me") +async def current_user(authorization: str | None = Header(default=None)): + record = await require_bearer(authorization) + return user_json(record) + + +# --------------------------------------------------------------------------- +# Sessions +# --------------------------------------------------------------------------- + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(authorization: str | None = Header(default=None)): + username, password = parse_basic(authorization) + async with db.pool().acquire() as conn: + record = await conn.fetchrow("SELECT * FROM users WHERE username=$1", username) + err = ApiError(401, "unauthorized", "invalid credentials") + err.login_path = True + if record is None or not verify_password(password, record["password_hash"]): + raise err + try: + token, expires_at = await sessions.create(record["id"]) + except Exception: # noqa: BLE001 + raise unavailable("session store unavailable") + return JSONResponse( + status_code=201, + content={ + "token": token, + "token_type": "Bearer", + "expires_at": iso(expires_at), + "user": user_json(record), + }, + ) + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def revoke_session(authorization: str | None = Header(default=None)): + await require_bearer(authorization) # validates the token is currently live + token = authorization[len("Bearer "):].strip() + try: + await sessions.revoke(token) + except Exception: # noqa: BLE001 + raise unavailable("session store unavailable") + return Response(status_code=204) + + +# --------------------------------------------------------------------------- +# Chats +# --------------------------------------------------------------------------- + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(request: Request, authorization: str | None = Header(default=None)): + actor = await require_bearer(authorization) + body = await parse_body(request, CreateChat) + try: + member_ids = [uuid.UUID(m) for m in body.member_ids] + except ValueError: + raise bad_request("member_ids must be UUIDs") + if len(set(member_ids)) != len(member_ids): + raise bad_request("member_ids must not contain duplicates") + if actor["id"] not in member_ids: + raise bad_request("caller must be a member of the chat") + async with db.pool().acquire() as conn: + async with conn.transaction(): + existing = await conn.fetch( + "SELECT id FROM users WHERE id = ANY($1::uuid[])", member_ids + ) + if len(existing) != len(member_ids): + raise bad_request("unknown member in member_ids") + chat = await conn.fetchrow( + "INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at", + body.title, + ) + await conn.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", + [(chat["id"], m) for m in member_ids], + ) + return JSONResponse(status_code=201, content=chat_json(chat, member_ids)) + + +@app.get("/api/v1/chats") +async def list_chats( + authorization: str | None = Header(default=None), + limit: int = 50, + cursor: str | None = None, +): + actor = await require_bearer(authorization) + if not (1 <= limit <= 100): + raise bad_request("limit must be between 1 and 100") + after_created_at = after_id = None + if cursor: + payload = decode_cursor(cursor) + try: + after_created_at = datetime.fromisoformat(payload["created_at"]) + after_id = uuid.UUID(payload["id"]) + except (KeyError, ValueError): + raise bad_request("malformed cursor") + async with db.pool().acquire() as conn: + rows = await conn.fetch( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE cm.user_id = $1 + AND ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3)) + ORDER BY c.created_at ASC, c.id ASC + LIMIT $4 + """, + actor["id"], + after_created_at, + after_id, + limit + 1, + ) + has_more = len(rows) > limit + rows = rows[:limit] + items = [] + for row in rows: + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", row["id"]) + items.append(chat_json(row, [m["user_id"] for m in members])) + next_cursor = None + if has_more: + last = rows[-1] + next_cursor = encode_cursor({"created_at": iso(last["created_at"]), "id": str(last["id"])}) + return {"items": items, "next_cursor": next_cursor} + + +async def _load_chat_if_member(conn, chat_id: uuid.UUID, user_id: uuid.UUID): + chat = await conn.fetchrow("SELECT id, title, created_at FROM chats WHERE id=$1", chat_id) + if chat is None: + raise not_found("chat not found") + membership = await conn.fetchrow( + "SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2", chat_id, user_id + ) + if membership is None: + raise not_found("chat not found") + return chat + + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, authorization: str | None = Header(default=None)): + actor = await require_bearer(authorization) + try: + chat_uuid = uuid.UUID(chat_id) + except ValueError: + raise bad_request("chat_id must be a UUID") + async with db.pool().acquire() as conn: + chat = await _load_chat_if_member(conn, chat_uuid, actor["id"]) + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", chat_uuid) + return chat_json(chat, [m["user_id"] for m in members]) + + +# --------------------------------------------------------------------------- +# Messages +# --------------------------------------------------------------------------- + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message(chat_id: str, request: Request, authorization: str | None = Header(default=None)): + actor = await require_bearer(authorization) + try: + chat_uuid = uuid.UUID(chat_id) + except ValueError: + raise bad_request("chat_id must be a UUID") + body = await parse_body(request, CreateMessage) + if not body.text.strip(): + raise bad_request("text must not be blank") + async with db.pool().acquire() as conn: + await _load_chat_if_member(conn, chat_uuid, actor["id"]) + record = await conn.fetchrow( + """ + INSERT INTO messages (chat_id, sender_id, text) + VALUES ($1, $2, $3) + RETURNING id, chat_id, sender_id, text, created_at + """, + chat_uuid, + actor["id"], + body.text, + ) + return JSONResponse(status_code=201, content=message_json(record)) + + +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages( + chat_id: str, + authorization: str | None = Header(default=None), + limit: int = 50, + cursor: str | None = None, +): + actor = await require_bearer(authorization) + try: + chat_uuid = uuid.UUID(chat_id) + except ValueError: + raise bad_request("chat_id must be a UUID") + if not (1 <= limit <= 100): + raise bad_request("limit must be between 1 and 100") + after_created_at = after_id = None + if cursor: + payload = decode_cursor(cursor) + if payload.get("chat_id") != chat_id: + raise bad_request("cursor does not belong to this chat") + try: + after_created_at = datetime.fromisoformat(payload["created_at"]) + after_id = uuid.UUID(payload["id"]) + except (KeyError, ValueError): + raise bad_request("malformed cursor") + async with db.pool().acquire() as conn: + await _load_chat_if_member(conn, chat_uuid, actor["id"]) + rows = await conn.fetch( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3)) + ORDER BY created_at ASC, id ASC + LIMIT $4 + """, + chat_uuid, + after_created_at, + after_id, + limit + 1, + ) + has_more = len(rows) > limit + rows = rows[:limit] + items = [message_json(r) for r in rows] + next_cursor = None + if has_more: + last = rows[-1] + next_cursor = encode_cursor( + {"chat_id": chat_id, "created_at": iso(last["created_at"]), "id": str(last["id"])} + ) + return {"items": items, "next_cursor": next_cursor} + + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- + +@app.on_event("startup") +async def on_startup(): + database_url = _read_secret("DATABASE_URL_FILE", "DATABASE_URL") + cache_url = _read_secret("CACHE_URL_FILE", "CACHE_URL") + await db.init_pool(database_url) + sessions.init(cache_url) + + +@app.on_event("shutdown") +async def on_shutdown(): + await db.close_pool() + await sessions.close() + + +def _read_secret(file_env: str, inline_env: str) -> str: + path = os.environ.get(file_env) + if path and os.path.isfile(path): + return open(path, encoding="utf-8").read().strip() + value = os.environ.get(inline_env) + if not value: + raise RuntimeError(f"{file_env} or {inline_env} must be set") + return value diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..536e287b --- /dev/null +++ b/app/security.py @@ -0,0 +1,16 @@ +"""Password KDF (Argon2id) — never store or compare plaintext passwords.""" +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, InvalidHashError + +_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +def verify_password(password: str, password_hash: str) -> bool: + try: + return _hasher.verify(password_hash, password) + except (VerifyMismatchError, InvalidHashError): + return False diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..4eb4a9cb --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,54 @@ +"""Opaque Bearer sessions backed by Redis/Valkey, TTL-bound, AOF-persistent.""" +import json +import os +import secrets +import uuid +from datetime import datetime, timedelta, timezone + +import redis.asyncio as redis + +_client: redis.Redis | None = None +TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + + +def init(url: str) -> None: + global _client + _client = redis.from_url(url, decode_responses=True, socket_timeout=3, socket_connect_timeout=3) + + +async def close() -> None: + if _client is not None: + await _client.close() + + +def client() -> redis.Redis: + if _client is None: + raise RuntimeError("session store is not initialized") + return _client + + +async def ping() -> bool: + try: + return bool(await client().ping()) + except Exception: # noqa: BLE001 - readiness probe + return False + + +async def create(user_id: uuid.UUID) -> tuple[str, datetime]: + token = secrets.token_urlsafe(32) # 256 bits of entropy, opaque and non-guessable + expires_at = datetime.now(timezone.utc) + timedelta(seconds=TTL_SECONDS) + payload = json.dumps({"user_id": str(user_id), "expires_at": expires_at.isoformat()}) + await client().set(f"session:{token}", payload, ex=TTL_SECONDS) + return token, expires_at + + +async def resolve(token: str) -> uuid.UUID | None: + raw = await client().get(f"session:{token}") + if raw is None: + return None + data = json.loads(raw) + return uuid.UUID(data["user_id"]) + + +async def revoke(token: str) -> None: + await client().delete(f"session:{token}") diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..4ca57d1f --- /dev/null +++ b/compose.yaml @@ -0,0 +1,68 @@ +name: mtusi2026lab2 + +services: + api: + build: . + image: mtusi2026lab2-api:local + ports: + - "8080:8080" + environment: + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: + - database_url + - cache_url + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2)"] + interval: 5s + timeout: 3s + retries: 5 + start_period: 10s + + postgres: + image: postgres:16.4 + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + + redis: + image: redis:7.4.1 + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + +volumes: + pgdata: + redisdata: + +secrets: + database_url: + file: ./secrets/database_url.txt + cache_url: + file: ./secrets/cache_url.txt + postgres_password: + file: ./secrets/postgres_password.txt diff --git a/evidence/explain_analyze_messages.txt b/evidence/explain_analyze_messages.txt new file mode 100644 index 00000000..1a96e0a3 --- /dev/null +++ b/evidence/explain_analyze_messages.txt @@ -0,0 +1,34 @@ + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=112.38..112.51 rows=51 width=88) (actual time=4.990..4.998 rows=51 loops=1) + Buffers: shared hit=271 + -> Sort (cost=112.38..112.51 rows=52 width=88) (actual time=4.986..4.989 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 36kB + Buffers: shared hit=271 + -> Bitmap Heap Scan on messages (cost=4.69..110.90 rows=52 width=88) (actual time=1.292..2.987 rows=12000 loops=1) + Recheck Cond: (chat_id = 'c939f183-65af-4ab7-b565-cd5328e24289'::uuid) + Heap Blocks: exact=148 + Buffers: shared hit=265 + -> Bitmap Index Scan on messages_chat_keyset_idx (cost=0.00..4.67 rows=52 width=0) (actual time=1.247..1.248 rows=12000 loops=1) + Index Cond: (chat_id = 'c939f183-65af-4ab7-b565-cd5328e24289'::uuid) + Buffers: shared hit=117 + Planning: + Buffers: shared hit=102 + Planning Time: 0.488 ms + Execution Time: 5.050 ms +(17 rows) + + QUERY PLAN +-------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..4.65 rows=51 width=65) (actual time=0.040..0.267 rows=51 loops=1) + Buffers: shared hit=53 + -> Index Scan using messages_chat_keyset_idx on messages (cost=0.29..1026.72 rows=12000 width=65) (actual time=0.039..0.258 rows=51 loops=1) + Index Cond: (chat_id = 'c939f183-65af-4ab7-b565-cd5328e24289'::uuid) + Buffers: shared hit=53 + Planning: + Buffers: shared hit=107 + Planning Time: 0.661 ms + Execution Time: 0.309 ms +(9 rows) + diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..005e1b49 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,33 @@ +-- Initial schema: users, chats, membership, messages. +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id); + +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Keyset pagination over (chat_id, created_at, id) avoids a full scan per page. +CREATE INDEX IF NOT EXISTS messages_chat_keyset_idx ON messages (chat_id, created_at, id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..4df3e5a7 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.115.6 +uvicorn[standard]==0.32.1 +asyncpg==0.30.0 +redis==5.2.1 +argon2-cffi==23.1.0 +pydantic==2.10.3 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..fda92e1c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,6 @@ +#!/bin/sh +set -eu +# Restarts API, PostgreSQL and Redis containers without touching their volumes. +cd "$(dirname "$0")/.." +docker compose restart postgres redis api +exit 0