diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..52a4ede --- /dev/null +++ b/Dockerfile @@ -0,0 +1,26 @@ +FROM python:3.12.7-slim@sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 + +WORKDIR /app + +RUN groupadd --system app && \ + useradd --system --gid app --create-home app + +COPY requirements.txt /app/requirements.txt +RUN pip install --no-cache-dir --timeout 60 -r requirements.txt + +COPY --chown=app:app src/ /app/src/ +COPY --chown=app:app migrations/ /app/migrations/ + +USER app + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \ + CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2)" || exit 1 + +CMD ["sh", "-c", "exec uvicorn src.main:app --host \"${APP_HOST}\" --port \"${APP_PORT}\" --timeout-graceful-shutdown 8"] \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..ef8e710 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,44 @@ +name: mtusi-lab2 + +services: + postgres: + image: postgres:16.6-alpine + restart: unless-stopped + 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 + + api: + build: . + image: mtusi-messenger:lab2 + restart: unless-stopped + depends_on: + postgres: + condition: service_healthy + environment: + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL_FILE: /run/secrets/database_url + secrets: + - database_url + ports: + - "127.0.0.1:8080:8080" + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + +volumes: + pgdata: \ No newline at end of file diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 0000000..a43b535 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,63 @@ +-- 001_init: базовая схема лабы 2. Повторный запуск безопасен (IF NOT EXISTS). + +CREATE TABLE IF NOT EXISTS users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, -- Argon2id, никогда не отдаётся в API + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK ( + char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> '' + ) +); + +CREATE TABLE IF NOT EXISTS chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT now(), + CONSTRAINT chats_title_len CHECK ( + char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> '' + ) +); + +-- Порядок списка чатов: (created_at, id) +CREATE INDEX IF NOT EXISTS chats_created_idx ON chats (created_at, id); + +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), + position smallint NOT NULL, -- порядок member_ids как в запросе + PRIMARY KEY (chat_id, user_id) +); + +-- Список чатов пользователя и проверка членства +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE IF NOT EXISTS messages ( + id uuid PRIMARY KEY, + 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(), + CONSTRAINT messages_text_len CHECK ( + char_length(text) BETWEEN 1 AND 4000 AND btrim(text) <> '' + ) +); + +-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +-- ORDER BY created_at, id LIMIT n -> index scan без сортировки и полного прохода +CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id); + +CREATE TABLE IF NOT EXISTS sessions ( + token_hash bytea PRIMARY KEY, -- SHA-256 токена; сам токен не хранится + user_id uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT now(), + expires_at timestamptz NOT NULL, + revoked_at timestamptz, + CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at) +); + +CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id); +CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at); \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..15476b6 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,15 @@ +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +fastapi==0.115.2 +h11==0.16.0 +idna==3.20 +pydantic==2.14.1 +pydantic-core==2.50.1 +starlette==0.40.0 +typing-extensions==4.16.0 +typing-inspection==0.4.4 +uvicorn==0.32.0 +asyncpg==0.30.0 +argon2-cffi==23.1.0 +argon2-cffi-bindings==21.2.0 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 0000000..f69d731 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,7 @@ +#!/bin/sh +# Перезапуск API и PostgreSQL с сохранением volume (никаких down -v). +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env stop api +docker compose --env-file .env restart postgres +docker compose --env-file .env start api \ No newline at end of file diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 0000000..80ff095 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,80 @@ +import asyncio +import base64 +import binascii +import hashlib +import secrets +from typing import Optional, Tuple + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError +from fastapi import HTTPException, Request + +_hasher = PasswordHasher() +# Хеш-заглушка: для несуществующего пользователя тратим столько же времени, сколько для существующего. +_DUMMY_HASH = _hasher.hash("dummy-password-for-timing") + +BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'} +BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + + +async def hash_password(password: str) -> str: + return await asyncio.to_thread(_hasher.hash, password) # Argon2 грузит CPU, не блокируем event loop + + +async def verify_password(stored_hash: Optional[str], password: str) -> bool: + try: + return await asyncio.to_thread(_hasher.verify, stored_hash or _DUMMY_HASH, password) + except (VerificationError, InvalidHashError): + return False + + +def new_token() -> str: + return secrets.token_urlsafe(32) # 256 бит случайности + + +def token_hash(token: str) -> bytes: + return hashlib.sha256(token.encode()).digest() + + +def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]: + if not header: + return None + scheme, _, value = header.partition(" ") + if scheme.lower() != "basic" or not value: + return None + try: + raw = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError, ValueError): + return None + username, sep, password = raw.partition(":") # двоеточие в пароле допустимо + return (username, password) if sep else None + + +def parse_bearer(header: Optional[str]) -> Optional[str]: + if not header: + return None + scheme, _, value = header.partition(" ") + value = value.strip() + if scheme.lower() != "bearer" or not value or len(value) > 512: + return None + return value + + +_SESSION_SQL = """ +SELECT u.id, u.username, u.display_name, u.created_at +FROM sessions s JOIN users u ON u.id = s.user_id +WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now() +""" + + +async def current_user(request: Request): + """Зависимость для всех защищённых endpoint: только Bearer, X-User-Id игнорируется.""" + token = parse_bearer(request.headers.get("Authorization")) + if token is None: + raise HTTPException(401, headers=BEARER_CHALLENGE) + digest = token_hash(token) + row = await request.app.state.pool.fetchrow(_SESSION_SQL, digest) + if row is None: + raise HTTPException(401, headers=BEARER_CHALLENGE) + request.state.token_hash = digest + return row \ No newline at end of file diff --git a/src/chats.py b/src/chats.py new file mode 100644 index 0000000..8b54a73 --- /dev/null +++ b/src/chats.py @@ -0,0 +1,208 @@ +import base64 +import json +import uuid +from datetime import datetime +from typing import List, Optional, Tuple + +import asyncpg +from fastapi import APIRouter, Depends, Query, Request +from pydantic import BaseModel, ConfigDict, Field + +from .auth import current_user +from .common import iso, make_error_response + +router = APIRouter() + + +class StrictRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + +class CreateChatRequest(StrictRequest): + title: str + member_ids: List[str] = Field(min_length=1, max_length=100) + + +class CreateMessageRequest(StrictRequest): + text: str + + +def _req_id(request: Request) -> str: + return request.state.request_id + + +# курсор: непрозрачная строка, привязанная к ресурсу (scope) +def encode_cursor(scope: str, created_at: datetime, row_id: uuid.UUID) -> str: + raw = json.dumps([scope, iso(created_at), str(row_id)]).encode() + return base64.urlsafe_b64encode(raw).decode() + + +def decode_cursor(cursor: str, scope: str) -> Tuple[datetime, uuid.UUID]: + """ValueError, если курсор повреждён или выдан для другого ресурса.""" + try: + sc, ts, rid = json.loads(base64.urlsafe_b64decode(cursor.encode())) + if sc != scope: + raise ValueError("scope mismatch") + return datetime.fromisoformat(ts), uuid.UUID(rid) + except Exception as exc: + raise ValueError("invalid cursor") from exc + + +def _bad_text(value: str) -> bool: + return not value.strip() or "\x00" in value # NUL нельзя хранить в PostgreSQL text + + +_CHAT_COLUMNS = ( + "c.id, c.title, c.created_at, " + "array(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.position) AS member_ids" +) + + +def chat_dict(row) -> dict: + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": [str(m) for m in row["member_ids"]], + "created_at": iso(row["created_at"]), + } + + +def message_dict(row) -> dict: + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": iso(row["created_at"]), + } + + +def _check_limit(limit: int) -> bool: + return 1 <= limit <= 100 + + +# чаты +@router.post("/chats", status_code=201) +async def create_chat(req: CreateChatRequest, request: Request, user=Depends(current_user)): + req_id = _req_id(request) + if not (1 <= len(req.title) <= 100) or _bad_text(req.title): + return make_error_response(400, "invalid_request", "Invalid title", req_id) + try: + members = [uuid.UUID(m) for m in req.member_ids] + except ValueError: + return make_error_response(400, "invalid_request", "Invalid member id", req_id) + if len(members) != len(set(members)): + return make_error_response(400, "invalid_request", "Duplicate members found", req_id) + if user["id"] not in members: + return make_error_response(400, "invalid_request", "Caller must be in member_ids", req_id) + + chat_id = uuid.uuid4() + try: + async with request.app.state.pool.acquire() as conn: + # Чат и все участники - одна транзакция: неизвестный участник откатывает всё. + async with conn.transaction(): + created_at = await conn.fetchval( + "INSERT INTO chats (id, title, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING created_at", + chat_id, req.title, + ) + await conn.execute( + "INSERT INTO chat_members (chat_id, user_id, position) " + "SELECT $1, t.u, (t.p - 1)::smallint FROM unnest($2::uuid[]) WITH ORDINALITY AS t(u, p)", + chat_id, members, + ) + except asyncpg.ForeignKeyViolationError: + return make_error_response(400, "invalid_request", "Unknown member", req_id) + + return {"id": str(chat_id), "title": req.title, "member_ids": [str(m) for m in members], + "created_at": iso(created_at)} + + +@router.get("/chats") +async def list_chats(request: Request, limit: int = 50, + cursor: Optional[str] = Query(default=None, min_length=1, max_length=512), + user=Depends(current_user)): + req_id = _req_id(request) + if not _check_limit(limit): + return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id) + scope = "chats:" + str(user["id"]) + base = (f"SELECT {_CHAT_COLUMNS} FROM chats c " + "JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ") + if cursor is None: + rows = await request.app.state.pool.fetch( + base + "ORDER BY c.created_at, c.id LIMIT $2", user["id"], limit + 1) + else: + try: + ts, rid = decode_cursor(cursor, scope) + except ValueError: + return make_error_response(400, "invalid_request", "Invalid cursor", req_id) + rows = await request.app.state.pool.fetch( + base + "WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) " + "ORDER BY c.created_at, c.id LIMIT $4", + user["id"], ts, rid, limit + 1) + items = rows[:limit] + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None + return {"items": [chat_dict(r) for r in items], "next_cursor": next_cursor} + + +@router.get("/chats/{chat_id}") +async def get_chat(chat_id: uuid.UUID, request: Request, user=Depends(current_user)): + row = await request.app.state.pool.fetchrow( + f"SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = $1 " + "AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)", + chat_id, user["id"], + ) + if row is None: + return make_error_response(404, "not_found", "Chat not found", _req_id(request)) + return chat_dict(row) + + +# сообщения +@router.post("/chats/{chat_id}/messages", status_code=201) +async def send_message(chat_id: uuid.UUID, req: CreateMessageRequest, request: Request, + user=Depends(current_user)): + req_id = _req_id(request) + if _bad_text(req.text): + return make_error_response(400, "invalid_request", "Empty message text", req_id) + if len(req.text) > 4000: + return make_error_response(400, "invalid_request", "Message text exceeds 4000 characters", req_id) + # Проверка членства и вставка - один атомарный оператор. + row = await request.app.state.pool.fetchrow( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) " + "SELECT $1, $2, $3, $4, clock_timestamp() " + "WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3) " + "RETURNING id, chat_id, sender_id, text, created_at", + uuid.uuid4(), chat_id, user["id"], req.text, + ) + if row is None: + return make_error_response(404, "not_found", "Chat not found", req_id) + return message_dict(row) + + +@router.get("/chats/{chat_id}/messages") +async def get_messages(chat_id: uuid.UUID, request: Request, limit: int = 50, + cursor: Optional[str] = Query(default=None, min_length=1, max_length=512), + user=Depends(current_user)): + req_id = _req_id(request) + if not _check_limit(limit): + return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id) + pool = request.app.state.pool + is_member = await pool.fetchval( + "SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"]) + if not is_member: + return make_error_response(404, "not_found", "Chat not found", req_id) + + scope = "msgs:" + str(chat_id) + base = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 " + if cursor is None: + rows = await pool.fetch(base + "ORDER BY created_at, id LIMIT $2", chat_id, limit + 1) + else: + try: + ts, rid = decode_cursor(cursor, scope) + except ValueError: + return make_error_response(400, "invalid_request", "Invalid cursor", req_id) + rows = await pool.fetch( + base + "AND (created_at, id) > ($2::timestamptz, $3::uuid) ORDER BY created_at, id LIMIT $4", + chat_id, ts, rid, limit + 1) + items = rows[:limit] + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None + return {"items": [message_dict(r) for r in items], "next_cursor": next_cursor} \ No newline at end of file diff --git a/src/common.py b/src/common.py new file mode 100644 index 0000000..5455422 --- /dev/null +++ b/src/common.py @@ -0,0 +1,29 @@ +from datetime import datetime, timezone +from typing import Optional + +from fastapi.responses import JSONResponse + + +def iso(dt: datetime) -> str: + """RFC 3339 UTC с Z; микросекунды нужны, чтобы курсор был точным.""" + return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def make_error_response(status_code: int, code: str, message: str, req_id: str, headers: Optional[dict] = None): + h = {"X-Request-Id": req_id} + if headers: + h.update(headers) + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": req_id}}, + headers=h, + ) + + +def user_dict(row) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": iso(row["created_at"]), + } \ No newline at end of file diff --git a/src/config.py b/src/config.py new file mode 100644 index 0000000..e11dbc2 --- /dev/null +++ b/src/config.py @@ -0,0 +1,21 @@ +import os +from pathlib import Path + + +def _read_secret(file_var: str, direct_var: str) -> str: + """Секрет из файла (DATABASE_URL_FILE), с запасным вариантом из переменной окружения.""" + path = os.environ.get(file_var) + if path: + return Path(path).read_text().strip() + return os.environ.get(direct_var, "") + + +DATABASE_URL = _read_secret("DATABASE_URL_FILE", "DATABASE_URL") +SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + +DB_POOL_MIN = int(os.environ.get("DB_POOL_MIN", "2")) +DB_POOL_MAX = int(os.environ.get("DB_POOL_MAX", "10")) +DB_CONNECT_TIMEOUT = float(os.environ.get("DB_CONNECT_TIMEOUT", "5")) +DB_COMMAND_TIMEOUT = float(os.environ.get("DB_COMMAND_TIMEOUT", "5")) + +MIGRATIONS_DIR = Path(os.environ.get("MIGRATIONS_DIR", Path(__file__).resolve().parent.parent / "migrations")) \ No newline at end of file diff --git a/src/db.py b/src/db.py new file mode 100644 index 0000000..d7292bd --- /dev/null +++ b/src/db.py @@ -0,0 +1,56 @@ +import asyncio +import logging + +import asyncpg + +from . import config + +logger = logging.getLogger("messenger") + +# Произвольный константный ключ: один экземпляр выполняет миграции, остальные ждут. +MIGRATION_LOCK_KEY = 727_001 + + +async def create_pool() -> asyncpg.Pool: + # Пул ограничен по размеру; у соединений и команд есть таймауты. + return await asyncpg.create_pool( + dsn=config.DATABASE_URL, + min_size=config.DB_POOL_MIN, + max_size=config.DB_POOL_MAX, + timeout=config.DB_CONNECT_TIMEOUT, + command_timeout=config.DB_COMMAND_TIMEOUT, + ) + + +async def create_pool_with_retry(attempts: int = 30, delay: float = 1.0) -> asyncpg.Pool: + # БД в compose может подняться позже API. + for attempt in range(1, attempts + 1): + try: + return await create_pool() + except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc: + logger.warning("DB not ready (%d/%d): %s", attempt, attempts, type(exc).__name__) + await asyncio.sleep(delay) + raise RuntimeError("database is unavailable") + + +async def run_migrations(pool: asyncpg.Pool) -> None: + # Применяет migrations/*.sql по порядку имён, каждую один раз. + files = sorted(config.MIGRATIONS_DIR.glob("*.sql")) + async with pool.acquire() as conn: + await conn.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_KEY) + try: + 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 files: + if path.name in applied: + continue + async with conn.transaction(): + await conn.execute(path.read_text()) + await conn.execute("INSERT INTO schema_migrations (version) VALUES ($1)", path.name) + logger.info("Applied migration %s", path.name) + finally: + await conn.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_KEY) \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..3ab0ac3 --- /dev/null +++ b/src/main.py @@ -0,0 +1,183 @@ +import asyncio +import logging +import re +import sys +import uuid +from contextlib import asynccontextmanager + +import asyncpg +from fastapi import Depends, FastAPI, Request, Response +from fastapi.exceptions import RequestValidationError +from pydantic import BaseModel, ConfigDict +from starlette.exceptions import HTTPException + +from . import config +from .auth import (BASIC_CHALLENGE, current_user, hash_password, new_token, + parse_basic, token_hash, verify_password) +from .chats import router as chats_router +from .common import iso, make_error_response, user_dict +from .db import create_pool_with_retry, run_migrations + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] [req_id=%(request_id)s] %(message)s", + handlers=[logging.StreamHandler(sys.stdout)], +) + + +class RequestIdFilter(logging.Filter): + def filter(self, record): + if not hasattr(record, "request_id"): + record.request_id = "-" + return True + + +logger = logging.getLogger("messenger") +logger.addFilter(RequestIdFilter()) + +is_shutting_down = False +USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") + + +@asynccontextmanager +async def lifespan(app: FastAPI): + app.state.pool = await create_pool_with_retry() + await run_migrations(app.state.pool) + yield + global is_shutting_down + is_shutting_down = True + await app.state.pool.close() + logger.info("Application shutdown complete") + + +app = FastAPI(title="MTUSI Messenger - Lab 2", lifespan=lifespan) +app.include_router(chats_router, prefix="/api/v1") + + +@app.middleware("http") +async def middleware_pipeline(request: Request, call_next): + req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4()) + request.state.request_id = req_id + if is_shutting_down and request.url.path != "/health/live": + return make_error_response(503, "unavailable", "Server is shutting down", req_id) + logger.info(f"Incoming request {request.method} {request.url.path}", extra={"request_id": req_id}) + response: Response = await call_next(request) + response.headers["X-Request-Id"] = req_id + logger.info(f"Completed {request.method} {request.url.path} with status {response.status_code}", + extra={"request_id": req_id}) + return response + + +def _req_id(request: Request) -> str: + return getattr(request.state, "request_id", str(uuid.uuid4())) + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + return make_error_response(400, "invalid_request", "Validation error", _req_id(request)) + + +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + code = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", 409: "conflict", + 413: "payload_too_large", 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable", + }.get(exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request") + return make_error_response(exc.status_code, code, "Request failed", _req_id(request), exc.headers) + + +async def dependency_unavailable_handler(request: Request, exc: Exception): + """БД недоступна или не ответила в срок: ограниченная 503, без деталей и без доверия анониму.""" + logger.error("Dependency failure: %s", type(exc).__name__, extra={"request_id": _req_id(request)}) + return make_error_response(503, "unavailable", "Service temporarily unavailable", _req_id(request)) + + +for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, ConnectionError, asyncio.TimeoutError): + app.add_exception_handler(_exc, dependency_unavailable_handler) + + +@app.exception_handler(Exception) +async def generic_exception_handler(request: Request, exc: Exception): + logger.error("Unhandled exception: %s", type(exc).__name__, extra={"request_id": _req_id(request)}) + return make_error_response(500, "internal_error", "Internal server error", _req_id(request)) + + +class StrictRequest(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + + +class CreateUserRequest(StrictRequest): + username: str + display_name: str + password: str + + +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def health_ready(request: Request): + # Критичная зависимость для готовности - PostgreSQL. + await request.app.state.pool.fetchval("SELECT 1", timeout=2) + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +async def register_user(req: CreateUserRequest, request: Request): + req_id = _req_id(request) + if not USERNAME_RE.fullmatch(req.username): + return make_error_response(400, "invalid_request", "Invalid username format", req_id) + if not (1 <= len(req.display_name) <= 100) or not req.display_name.strip() or "\x00" in req.display_name: + return make_error_response(400, "invalid_request", "Invalid display_name", req_id) + if not (12 <= len(req.password) <= 128): + return make_error_response(400, "invalid_request", "Invalid password length", req_id) + + pw_hash = await hash_password(req.password) + try: + row = await request.app.state.pool.fetchrow( + "INSERT INTO users (id, username, display_name, password_hash, created_at) " + "VALUES ($1, $2, $3, $4, clock_timestamp()) " + "RETURNING id, username, display_name, created_at", + uuid.uuid4(), req.username, req.display_name, pw_hash, + ) + except asyncpg.UniqueViolationError: # гонку одинаковых username решает UNIQUE, а не SELECT + return make_error_response(409, "conflict", "Username already exists", req_id) + return user_dict(row) + +@app.get("/api/v1/users/me") +async def get_current_user(user=Depends(current_user)): + return user_dict(user) + + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(request: Request): + req_id = _req_id(request) + creds = parse_basic(request.headers.get("Authorization")) + if creds is None: + return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE) + username, password = creds + pool = request.app.state.pool + row = await pool.fetchrow( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username + ) + ok = await verify_password(row["password_hash"] if row else None, password) + if row is None or not ok: + return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE) + + token = new_token() + expires_at = await pool.fetchval( + "INSERT INTO sessions (token_hash, user_id, created_at, expires_at) " + "VALUES ($1, $2, now(), now() + make_interval(secs => $3)) RETURNING expires_at", + token_hash(token), row["id"], float(config.SESSION_TTL_SECONDS), + ) + return {"token": token, "token_type": "Bearer", "expires_at": iso(expires_at), "user": user_dict(row)} + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def logout(request: Request, user=Depends(current_user)): + await request.app.state.pool.execute( + "UPDATE sessions SET revoked_at = now() WHERE token_hash = $1", request.state.token_hash + ) + return Response(status_code=204) \ No newline at end of file