From a3246a08f30876598efbc58ac37aae7cc63aa015 Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 02:07:22 +0300 Subject: [PATCH 1/7] =?UTF-8?q?=D0=A0=D0=B5=D0=B0=D0=BB=D0=B8=D0=B7=D0=B0?= =?UTF-8?q?=D1=86=D0=B8=D1=8F=20=D0=9B=D0=A0=202=20=D0=BD=D0=B0=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 26 +++++ compose.yaml | 44 +++++++++ migrations/001_init.sql | 63 ++++++++++++ requirements.txt | 15 +++ scripts/restart.sh | 7 ++ src/auth.py | 80 ++++++++++++++++ src/chats.py | 208 ++++++++++++++++++++++++++++++++++++++++ src/common.py | 29 ++++++ src/config.py | 21 ++++ src/db.py | 56 +++++++++++ src/main.py | 183 +++++++++++++++++++++++++++++++++++ 11 files changed, 732 insertions(+) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 migrations/001_init.sql create mode 100644 requirements.txt create mode 100755 scripts/restart.sh create mode 100644 src/auth.py create mode 100644 src/chats.py create mode 100644 src/common.py create mode 100644 src/config.py create mode 100644 src/db.py create mode 100644 src/main.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..52a4ede3 --- /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 00000000..ef8e710b --- /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 00000000..a43b5358 --- /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 00000000..15476b6e --- /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 00000000..f69d731a --- /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 00000000..80ff0950 --- /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 00000000..8b54a737 --- /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 00000000..54554224 --- /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 00000000..e11dbc29 --- /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 00000000..d7292bdc --- /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 00000000..3ab0ac33 --- /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 -- 2.54.0 From f4087c16720e74504874743628fcb0be3c29d584 Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 03:03:39 +0300 Subject: [PATCH 2/7] =?UTF-8?q?Evidence=20=D0=B4=D0=BB=D1=8F=20=D0=9B?= =?UTF-8?q?=D0=A0=202=20=D0=BD=D0=B0=203:=20smoke,=20persistence,=20=D0=BC?= =?UTF-8?q?=D0=B8=D0=B3=D1=80=D0=B0=D1=86=D0=B8=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- evidence/migrations.txt | 1 + evidence/persistence.txt | 3 +++ evidence/restart-after.txt | 3 +++ evidence/restart-before.txt | 3 +++ evidence/smoke.txt | 2 ++ 5 files changed, 12 insertions(+) create mode 100644 evidence/migrations.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/restart-after.txt create mode 100644 evidence/restart-before.txt create mode 100644 evidence/smoke.txt diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 00000000..5a84728f --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1 @@ +api-1 | 2026-11-02 22:31:51,587 [INFO] [req_id=-] Applied migration 001_init.sql diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..793b001d --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/restart-after.txt b/evidence/restart-after.txt new file mode 100644 index 00000000..f64ea133 --- /dev/null +++ b/evidence/restart-after.txt @@ -0,0 +1,3 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 38 minutes ago Up Less than a second (health: starting) 127.0.0.1:8080->8080/tcp +mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 38 minutes ago Up 5 seconds (healthy) 5432/tcp diff --git a/evidence/restart-before.txt b/evidence/restart-before.txt new file mode 100644 index 00000000..5a2da7e7 --- /dev/null +++ b/evidence/restart-before.txt @@ -0,0 +1,3 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 38 minutes ago Up 39 seconds (healthy) 127.0.0.1:8080->8080/tcp +mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 38 minutes ago Up 44 seconds (healthy) 5432/tcp diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..404a2c60 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. -- 2.54.0 From 7b0a6aea9b97d4fab67245a30612c98d3f572099 Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 04:06:04 +0300 Subject: [PATCH 3/7] =?UTF-8?q?=D0=9B=D0=A0=202:=20Valkey=20=D0=BA=D0=B0?= =?UTF-8?q?=D0=BA=20=D0=BA=D1=8D=D1=88=20=D1=81=D0=B5=D1=81=D1=81=D0=B8?= =?UTF-8?q?=D0=B9=20=D1=81=20=D0=BE=D0=B1=D1=85=D0=BE=D0=B4=D0=BE=D0=BC=20?= =?UTF-8?q?=D0=BF=D1=80=D0=B8=20=D1=81=D0=B1=D0=BE=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- compose.yaml | 13 ++++++++ requirements.txt | 3 +- scripts/restart.sh | 2 +- src/auth.py | 19 +++++++---- src/cache.py | 82 ++++++++++++++++++++++++++++++++++++++++++++++ src/config.py | 5 ++- src/main.py | 4 +++ 7 files changed, 119 insertions(+), 9 deletions(-) create mode 100644 src/cache.py diff --git a/compose.yaml b/compose.yaml index ef8e710b..6c1b5abd 100644 --- a/compose.yaml +++ b/compose.yaml @@ -17,6 +17,16 @@ services: interval: 5s timeout: 3s retries: 10 + + valkey: + image: valkey/valkey:8.0.1-alpine + restart: unless-stopped + command: ["valkey-server", "--save", "", "--appendonly", "no", "--maxmemory", "64mb", "--maxmemory-policy", "allkeys-lru"] + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 api: build: . @@ -25,10 +35,13 @@ services: depends_on: postgres: condition: service_healthy + valkey: + condition: service_started environment: APP_ENV: ${APP_ENV:-lab} SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL: redis://valkey:6379/0 secrets: - database_url ports: diff --git a/requirements.txt b/requirements.txt index 15476b6e..23aaa3e5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -12,4 +12,5 @@ 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 +argon2-cffi-bindings==21.2.0 +redis==5.2.1 \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh index f69d731a..a19427e9 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -3,5 +3,5 @@ set -eu cd "$(dirname "$0")/.." docker compose --env-file .env stop api -docker compose --env-file .env restart postgres +docker compose --env-file .env restart postgres valkey docker compose --env-file .env start api \ No newline at end of file diff --git a/src/auth.py b/src/auth.py index 80ff0950..4653429d 100644 --- a/src/auth.py +++ b/src/auth.py @@ -61,20 +61,27 @@ def parse_bearer(header: Optional[str]) -> Optional[str]: _SESSION_SQL = """ -SELECT u.id, u.username, u.display_name, u.created_at +SELECT u.id, u.username, u.display_name, u.created_at, + EXTRACT(EPOCH FROM (s.expires_at - now())) AS remaining 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 игнорируется.""" + # Только Bearer. Сначала кэш, при промахе или сбое - PostgreSQL (источник истины). 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) + cache = request.app.state.cache + + user = await cache.get(digest) + if user is None: + row = await request.app.state.pool.fetchrow(_SESSION_SQL, digest) + if row is None: + raise HTTPException(401, headers=BEARER_CHALLENGE) + user = {k: row[k] for k in ("id", "username", "display_name", "created_at")} + await cache.put(digest, user, int(row["remaining"])) request.state.token_hash = digest - return row \ No newline at end of file + return user \ No newline at end of file diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..a2f14c8d --- /dev/null +++ b/src/cache.py @@ -0,0 +1,82 @@ +import asyncio +import json +import logging +import time +import uuid +from datetime import datetime +from typing import Optional + +import redis.asyncio as redis +from redis.exceptions import RedisError + +from . import config +from .common import iso + +logger = logging.getLogger("messenger") + +_FAILURES = (RedisError, OSError, asyncio.TimeoutError) +_RETRY_AFTER = 5.0 # после сбоя 5 секунд не обращаемся к кэшу, чтобы не ждать таймаут на каждом запросе + + +def _key(digest: bytes) -> str: + return "sess:" + digest.hex() + + +class SessionCache: + """Кэш проверенных сессий. Любой сбой = промах: ответ берётся из PostgreSQL.""" + + def __init__(self, url: str): + self._client = ( + redis.Redis.from_url( + url, decode_responses=True, + socket_timeout=config.CACHE_TIMEOUT, socket_connect_timeout=config.CACHE_TIMEOUT, + ) if url else None + ) + self._down_until = 0.0 + + def _usable(self) -> bool: + return self._client is not None and time.monotonic() >= self._down_until + + def _mark_down(self, exc: Exception) -> None: + self._down_until = time.monotonic() + _RETRY_AFTER + logger.warning("Cache unavailable, bypassing: %s", type(exc).__name__) + + async def get(self, digest: bytes) -> Optional[dict]: + if not self._usable(): + return None + try: + raw = await self._client.get(_key(digest)) + except _FAILURES as exc: + self._mark_down(exc) + return None + if raw is None: + return None + try: + d = json.loads(raw) + return {"id": uuid.UUID(d["id"]), "username": d["username"], + "display_name": d["display_name"], "created_at": datetime.fromisoformat(d["created_at"])} + except (ValueError, KeyError): + return None + + async def put(self, digest: bytes, user: dict, remaining_seconds: int) -> None: + ttl = min(remaining_seconds, config.CACHE_TTL_SECONDS) # кэш никогда не живёт дольше сессии + if ttl < 1 or not self._usable(): + return + value = json.dumps({"id": str(user["id"]), "username": user["username"], + "display_name": user["display_name"], "created_at": iso(user["created_at"])}) + try: + await self._client.set(_key(digest), value, ex=ttl) + except _FAILURES as exc: + self._mark_down(exc) + + async def delete(self, digest: bytes) -> None: + if not self._usable(): + return + try: + await self._client.delete(_key(digest)) + except _FAILURES as exc: + self._mark_down(exc) + + async def close(self) -> None: + if self._client is not None: + await self._client.aclose() \ No newline at end of file diff --git a/src/config.py b/src/config.py index e11dbc29..8e18983e 100644 --- a/src/config.py +++ b/src/config.py @@ -18,4 +18,7 @@ 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 +MIGRATIONS_DIR = Path(os.environ.get("MIGRATIONS_DIR", Path(__file__).resolve().parent.parent / "migrations")) +CACHE_URL = _read_secret("CACHE_URL_FILE", "CACHE_URL") +CACHE_TTL_SECONDS = int(os.environ.get("CACHE_TTL_SECONDS", "60")) +CACHE_TIMEOUT = float(os.environ.get("CACHE_TIMEOUT", "0.5")) \ No newline at end of file diff --git a/src/main.py b/src/main.py index 3ab0ac33..89325e07 100644 --- a/src/main.py +++ b/src/main.py @@ -17,6 +17,7 @@ from .auth import (BASIC_CHALLENGE, current_user, hash_password, new_token, 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 +from .cache import SessionCache logging.basicConfig( level=logging.INFO, @@ -43,9 +44,11 @@ USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") async def lifespan(app: FastAPI): app.state.pool = await create_pool_with_retry() await run_migrations(app.state.pool) + app.state.cache = SessionCache(config.CACHE_URL) yield global is_shutting_down is_shutting_down = True + await app.state.cache.close() await app.state.pool.close() logger.info("Application shutdown complete") @@ -180,4 +183,5 @@ 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 ) + await request.app.state.cache.delete(request.state.token_hash) return Response(status_code=204) \ No newline at end of file -- 2.54.0 From aea52f60b64e8c83a05d0d9bb191e00cc9dd6c2b Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 04:58:39 +0300 Subject: [PATCH 4/7] =?UTF-8?q?=D0=9B=D0=A0=202:=20=D0=B0=D0=B2=D1=82?= =?UTF-8?q?=D0=BE=D1=82=D0=B5=D1=81=D1=82=D1=8B=20=D1=83=D1=80=D0=BE=D0=B2?= =?UTF-8?q?=D0=BD=D1=8F=204,=20=D0=BE=D0=B1=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=BA=D0=B0=20=D0=BE=D1=82=D0=BA=D0=B0=D0=B7=D0=B0=20=D0=91?= =?UTF-8?q?=D0=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- evidence/student-tests-level4.txt | 31 ++++++ src/main.py | 2 +- student_tests/test_level4.py | 179 ++++++++++++++++++++++++++++++ 3 files changed, 211 insertions(+), 1 deletion(-) create mode 100644 evidence/student-tests-level4.txt create mode 100644 student_tests/test_level4.py diff --git a/evidence/student-tests-level4.txt b/evidence/student-tests-level4.txt new file mode 100644 index 00000000..6c8df7ff --- /dev/null +++ b/evidence/student-tests-level4.txt @@ -0,0 +1,31 @@ +test_chat_creation_rolls_back (test_level4.Level4.test_chat_creation_rolls_back) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok +test_logout_revokes_session_and_cache (test_level4.Level4.test_logout_revokes_session_and_cache) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok +test_postgres_down_returns_bounded_error (test_level4.Level4.test_postgres_down_returns_bounded_error) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +/opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +/opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok +test_register_race_same_username (test_level4.Level4.test_register_race_same_username) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok +test_valkey_down_falls_back_to_postgres (test_level4.Level4.test_valkey_down_falls_back_to_postgres) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok +test_wrong_password (test_level4.Level4.test_wrong_password) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok +test_x_user_id_gives_no_access (test_level4.Level4.test_x_user_id_gives_no_access) ... ok +test_zz_session_expiry (test_level4.Level4.test_zz_session_expiry) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up + _warnings.warn(self.warn_message, ResourceWarning) +ok + +---------------------------------------------------------------------- +Ran 8 tests in 12.946s + +OK diff --git a/src/main.py b/src/main.py index 89325e07..887e8be2 100644 --- a/src/main.py +++ b/src/main.py @@ -95,7 +95,7 @@ async def dependency_unavailable_handler(request: Request, exc: Exception): return make_error_response(503, "unavailable", "Service temporarily unavailable", _req_id(request)) -for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, ConnectionError, asyncio.TimeoutError): +for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, OSError, asyncio.TimeoutError): app.add_exception_handler(_exc, dependency_unavailable_handler) diff --git a/student_tests/test_level4.py b/student_tests/test_level4.py new file mode 100644 index 00000000..c8d1fde1 --- /dev/null +++ b/student_tests/test_level4.py @@ -0,0 +1,179 @@ +"""Проверки уровня 4. Нужен запущенный стенд (docker compose up -d --build). +Тесты отказов сами останавливают и запускают valkey/postgres/api, volumes не удаляются. +Запуск: python3 -m unittest discover -s student_tests -p "test_level4.py" -v +""" +import base64 +import json +import os +import subprocess +import threading +import time +import unittest +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +BASE = os.environ.get("BASE_URL", "http://localhost:8080") +ROOT = Path(__file__).resolve().parents[1] +PASSWORD = "correct-horse-battery" + + +def call(method, path, body=None, headers=None): + data = json.dumps(body).encode() if body is not None else None + h = {"Content-Type": "application/json"} if body is not None else {} + h.update(headers or {}) + req = urllib.request.Request(BASE + path, data=data, method=method, headers=h) + try: + with urllib.request.urlopen(req, timeout=15) as resp: + raw = resp.read() + return resp.status, (json.loads(raw) if raw else None) + except urllib.error.HTTPError as exc: + raw = exc.read() + try: + return exc.code, (json.loads(raw) if raw else None) + except ValueError: + return exc.code, None + + +def register(username=None): + username = username or "u" + uuid.uuid4().hex[:12] + status, user = call("POST", "/api/v1/users", + {"username": username, "display_name": "Test", "password": PASSWORD}) + assert status == 201, status + return user + + +def login(username, password=PASSWORD): + basic = base64.b64encode(f"{username}:{password}".encode()).decode() + return call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}) + + +def bearer(token): + return {"Authorization": "Bearer " + token} + + +def compose(*args, env=None): + full_env = dict(os.environ) + full_env.update(env or {}) + result = subprocess.run(["docker", "compose", "--env-file", ".env", *args], + cwd=ROOT, env=full_env, check=True, capture_output=True, text=True) + return result.stdout + + +def wait_ready(timeout=90): + deadline = time.time() + timeout + while time.time() < deadline: + try: + if call("GET", "/health/ready")[0] == 200: + return + except OSError: + pass + time.sleep(1) + raise AssertionError("API did not become ready") + + +def new_session(): + user = register() + status, session = login(user["username"]) + assert status == 201 + return user, session["token"] + + +class Level4(unittest.TestCase): + @classmethod + def setUpClass(cls): + wait_ready() + + def test_wrong_password(self): + user = register() + status, body = login(user["username"], "definitely-wrong-password") + self.assertEqual(status, 401) + self.assertEqual(body["error"]["code"], "unauthorized") + status, _ = login("no_such_user_" + uuid.uuid4().hex[:8]) + self.assertEqual(status, 401) + + def test_logout_revokes_session_and_cache(self): + _, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) # прогрев кэша + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", headers=bearer(token))[0], 204) + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 401) + self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", headers=bearer(token))[0], 401) + + def test_x_user_id_gives_no_access(self): + user = register() + status, _ = call("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]}) + self.assertEqual(status, 401) + + def test_register_race_same_username(self): + username = "race" + uuid.uuid4().hex[:10] + results = [] + + def worker(): + status, _ = call("POST", "/api/v1/users", + {"username": username, "display_name": "Race", "password": PASSWORD}) + results.append(status) + + threads = [threading.Thread(target=worker) for _ in range(10)] + for t in threads: + t.start() + for t in threads: + t.join() + self.assertEqual(results.count(201), 1, results) + self.assertEqual(results.count(409), 9, results) + + def test_chat_creation_rolls_back(self): + user, token = new_session() + title = "rollback-" + uuid.uuid4().hex + status, _ = call("POST", "/api/v1/chats", + {"title": title, "member_ids": [user["id"], str(uuid.uuid4())]}, + headers=bearer(token)) + self.assertEqual(status, 400) + # Проверяем саму БД: после отката не осталось ни чата, ни участников. + count = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", + "-tAc", f"SELECT count(*) FROM chats WHERE title = '{title}'").strip() + self.assertEqual(count, "0") + + def test_valkey_down_falls_back_to_postgres(self): + user, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + compose("stop", "valkey") + try: + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + self.assertEqual(login(user["username"])[0], 201) + self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("x" * 43))[0], 401) + finally: + compose("start", "valkey") + + def test_postgres_down_returns_bounded_error(self): + compose("stop", "postgres") + try: + status, body = call("GET", "/health/ready") + self.assertEqual(status, 503) + self.assertEqual(body["error"]["code"], "unavailable") + # неизвестный токен нельзя ни подтвердить, ни отвергнуть без БД: 503, не 200 + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("y" * 43))[0], 503) + self.assertEqual(call("GET", "/api/v1/users/me")[0], 401) # аноним не доверенный + self.assertEqual(call("POST", "/api/v1/users", + {"username": "down" + uuid.uuid4().hex[:8], "display_name": "X", + "password": PASSWORD})[0], 503) + finally: + compose("start", "postgres") + wait_ready() + + def test_zz_session_expiry(self): + compose("up", "-d", "api", env={"SESSION_TTL_SECONDS": "2"}) + try: + wait_ready() + _, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + time.sleep(3.5) + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 401) + finally: + compose("up", "-d", "api") # обратно к TTL из .env + wait_ready() + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file -- 2.54.0 From aa1b6445859fa06b4174d5d545eb451d761bc71d Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 10:56:15 +0300 Subject: [PATCH 5/7] =?UTF-8?q?=D0=9B=D0=A0=202:=20EXPLAIN=20(ANALYZE,=20B?= =?UTF-8?q?UFFERS)=20=D0=B4=D0=BB=D1=8F=20=D0=B8=D1=81=D1=82=D0=BE=D1=80?= =?UTF-8?q?=D0=B8=D0=B8=20=D0=BD=D0=B0=2010=20000=20=D1=81=D0=BE=D0=BE?= =?UTF-8?q?=D0=B1=D1=89=D0=B5=D0=BD=D0=B8=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- evidence/explain.txt | 55 ++++++++++++++++++++++++++++++++++++++++++++ scripts/explain.sql | 45 ++++++++++++++++++++++++++++++++++++ 2 files changed, 100 insertions(+) create mode 100644 evidence/explain.txt create mode 100644 scripts/explain.sql diff --git a/evidence/explain.txt b/evidence/explain.txt new file mode 100644 index 00000000..00a39661 --- /dev/null +++ b/evidence/explain.txt @@ -0,0 +1,55 @@ +BEGIN +INSERT 0 0 +INSERT 0 0 +INSERT 0 0 +INSERT 0 0 +COMMIT +ANALYZE +1. Первая страница (limit 50) + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..5.33 rows=51 width=64) (actual time=0.015..0.020 rows=51 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_history_idx on messages (cost=0.29..989.57 rows=10000 width=64) (actual time=0.015..0.017 rows=51 loops=1) + Index Cond: (chat_id = '00000000-0000-4000-8000-0000000000c1'::uuid) + Buffers: shared hit=3 + Planning: + Buffers: shared hit=23 + Planning Time: 0.108 ms + Execution Time: 0.037 ms +(9 rows) + +2. Страница из середины истории (keyset cursor) + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.29..6.63 rows=51 width=64) (actual time=0.007..0.011 rows=51 loops=1) + Buffers: shared hit=3 + -> Index Scan using messages_history_idx on messages (cost=0.29..620.78 rows=4991 width=64) (actual time=0.006..0.009 rows=51 loops=1) + Index Cond: ((chat_id = '00000000-0000-4000-8000-0000000000c1'::uuid) AND (ROW(created_at, id) > ROW('2026-11-03 06:25:42.350396+00'::timestamp with time zone, 'e5c90185-a58b-4164-b1b3-cb15e30b97e1'::uuid))) + Buffers: shared hit=3 + Planning Time: 0.027 ms + Execution Time: 0.034 ms +(7 rows) + +3. Для сравнения: без индекса messages_history_idx +BEGIN +DROP INDEX + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------- + Limit (cost=581.83..581.96 rows=51 width=64) (actual time=0.915..0.919 rows=51 loops=1) + Buffers: shared hit=123 + -> Sort (cost=581.83..606.83 rows=10000 width=64) (actual time=0.915..0.916 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 31kB + Buffers: shared hit=123 + -> Seq Scan on messages (cost=0.00..248.21 rows=10000 width=64) (actual time=0.004..0.485 rows=10000 loops=1) + Filter: (chat_id = '00000000-0000-4000-8000-0000000000c1'::uuid) + Rows Removed by Filter: 17 + Buffers: shared hit=123 + Planning: + Buffers: shared hit=4 + Planning Time: 0.037 ms + Execution Time: 0.941 ms +(14 rows) + +ROLLBACK diff --git a/scripts/explain.sql b/scripts/explain.sql new file mode 100644 index 00000000..19a8380f --- /dev/null +++ b/scripts/explain.sql @@ -0,0 +1,45 @@ +-- Нагрузочные данные для EXPLAIN: 10 000 сообщений в одном чате (синтетика). +\set ON_ERROR_STOP on +BEGIN; +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('00000000-0000-4000-8000-000000000001', 'explain_user', 'Explain', 'x') +ON CONFLICT DO NOTHING; +INSERT INTO chats (id, title) +VALUES ('00000000-0000-4000-8000-0000000000c1', 'explain-chat') +ON CONFLICT DO NOTHING; +INSERT INTO chat_members (chat_id, user_id, position) +VALUES ('00000000-0000-4000-8000-0000000000c1', '00000000-0000-4000-8000-000000000001', 0) +ON CONFLICT DO NOTHING; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), '00000000-0000-4000-8000-0000000000c1', + '00000000-0000-4000-8000-000000000001', 'msg ' || g, + now() - (10001 - g) * interval '1 second' +FROM generate_series(1, 10000) g +WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-0000000000c1'); +COMMIT; +ANALYZE messages; + +\echo '1. Первая страница (limit 50)' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000c1' +ORDER BY created_at, id LIMIT 51; + +\echo '2. Страница из середины истории (keyset cursor)' +SELECT created_at AS c_ts, id AS c_id FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000c1' +ORDER BY created_at, id OFFSET 5000 LIMIT 1 \gset +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000c1' + AND (created_at, id) > (:'c_ts'::timestamptz, :'c_id'::uuid) +ORDER BY created_at, id LIMIT 51; + +\echo '3. Для сравнения: без индекса messages_history_idx' +BEGIN; +DROP INDEX messages_history_idx; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000000c1' +ORDER BY created_at, id LIMIT 51; +ROLLBACK; \ No newline at end of file -- 2.54.0 From 3feb4a9da3471d685006461c29d7f39c6fcab46f Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 11:33:16 +0300 Subject: [PATCH 6/7] =?UTF-8?q?=D0=9B=D0=A0=202:=20=D1=81=D0=BE=D0=B1?= =?UTF-8?q?=D1=81=D1=82=D0=B2=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D1=82=D0=B5?= =?UTF-8?q?=D1=81=D1=82=D1=8B=20(student=5Ftests),=20lifecycle=20=D0=B8=20?= =?UTF-8?q?SIGTERM=20=D0=BF=D0=BE=D0=B4=20compose?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- evidence/lifecycle.txt | 7 + evidence/sigterm.txt | 6 + evidence/student-tests.txt | 15 + student_tests/test_lab2.py | 585 ++++++++++++++++++++++++++++++++ student_tests/test_lifecycle.py | 68 ++++ student_tests/test_sigterm.py | 129 +++++++ 6 files changed, 810 insertions(+) create mode 100644 evidence/lifecycle.txt create mode 100644 evidence/sigterm.txt create mode 100644 evidence/student-tests.txt create mode 100644 student_tests/test_lab2.py create mode 100644 student_tests/test_lifecycle.py create mode 100644 student_tests/test_sigterm.py diff --git a/evidence/lifecycle.txt b/evidence/lifecycle.txt new file mode 100644 index 00000000..6209241a --- /dev/null +++ b/evidence/lifecycle.txt @@ -0,0 +1,7 @@ +PASS two users created and read two messages: HTTP 201, then HTTP 200 +PASS third user cannot read or write the chat: HTTP 404 +PASS request logs include IDs and statuses, without message contents +Command: scripts/restart.sh (API + PostgreSQL + Valkey, volumes kept) +PASS after restart: same tokens read the same history +PASS logout revokes only alice's session; bob's session still works +PASS persistent lifecycle: data and sessions survive full restart diff --git a/evidence/sigterm.txt b/evidence/sigterm.txt new file mode 100644 index 00000000..857b4e71 --- /dev/null +++ b/evidence/sigterm.txt @@ -0,0 +1,6 @@ +Image: mtusi-messenger:lab2 +Scenario: idle; docker stop --timeout 10 mtusi-messenger-sigterm-60edb300 +PASS idle: exit code 0; shutdown 0.339s; new connections rejected after 0.119s +Scenario: incomplete POST; docker stop --timeout 10 mtusi-messenger-sigterm-859f8a87 +PASS incomplete POST: exit code 0; shutdown 8.356s; new connections rejected after 0.117s +PASS SIGTERM: both scenarios completed within 10 seconds diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..23abefc5 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,15 @@ +Testing http://localhost:8080 +PASS malformed JSON and invalid UTF-8 -> 400 with error envelope +PASS duplicate username -> 409 +PASS outsider cannot access chat -> 404 +PASS empty/whitespace message -> 400 +PASS extra JSON field -> 400 +PASS pagination: 7 messages read through multiple pages +PASS concurrency: 10 clients sent 100 messages; exactly 100 unique messages stored +PASS invalid chat UUID -> 400; unknown valid UUID -> 404 +PASS chat members: 1..100, unique, existing, caller included +PASS invalid cursor/limit and cursor from another chat -> 400 +PASS pagination: 7 chats, changing limit between pages +PASS strict types, Unicode, password rules, Bearer-only identification + +PASS: 12 student test scenarios completed diff --git a/student_tests/test_lab2.py b/student_tests/test_lab2.py new file mode 100644 index 00000000..37dd02fc --- /dev/null +++ b/student_tests/test_lab2.py @@ -0,0 +1,585 @@ +#!/usr/bin/env python3 + +import concurrent.futures +import json +import os +import sys +import uuid +import urllib.error +import urllib.parse +import urllib.request +from datetime import datetime +import base64 + +BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/") +PASSWORD = "correct-horse-battery" + + +def request(method, path, expected, body=None, headers=None, raw_body=None): + url = BASE_URL + path + + request_headers = dict(headers or {}) + + if raw_body is not None: + data = raw_body + elif body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + else: + data = None + + if body is not None or raw_body is not None: + request_headers.setdefault("Content-Type", "application/json") + + req = urllib.request.Request( + url, + data=data, + method=method, + headers=request_headers, + ) + + try: + with urllib.request.urlopen(req, timeout=10) as response: + status = response.status + response_headers = response.headers + response_body = response.read() + + except urllib.error.HTTPError as exc: + status = exc.code + response_headers = exc.headers + response_body = exc.read() + + if status != expected: + raise AssertionError( + f"{method} {path}: expected HTTP {expected}, got {status}. " + f"Body={response_body!r}" + ) + + request_id = response_headers.get("X-Request-Id") + if not request_id: + raise AssertionError( + f"{method} {path}: missing X-Request-Id" + ) + + parsed = None + + if response_body: + content_type = response_headers.get_content_type() + + if content_type == "application/json": + parsed = json.loads(response_body.decode("utf-8")) + + if status >= 400: + codes = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", + 409: "conflict", 413: "payload_too_large", 415: "unsupported_media_type", + 429: "rate_limited", 500: "internal_error", 503: "unavailable", + } + if not isinstance(parsed, dict) or set(parsed) != {"error"}: + raise AssertionError(f"Invalid error response: {parsed!r}") + error = parsed["error"] + if not isinstance(error, dict) or set(error) != {"code", "message", "request_id"}: + raise AssertionError(f"Invalid error fields: {error!r}") + if error["code"] != codes[status] or error["request_id"] != request_id: + raise AssertionError(f"Wrong error code or request ID: {error!r}") + if not isinstance(error["message"], str) or not error["message"].strip(): + raise AssertionError("Error message must be a nonempty string") + + return { + "status": status, + "headers": response_headers, + "json": parsed, + "bytes": response_body, + } + + +def unique_username(prefix): + # username должен соответствовать [a-z0-9_]{3,32} + suffix = uuid.uuid4().hex[:12] + return f"{prefix}_{suffix}" + + +def basic(username, password=PASSWORD): + raw = f"{username}:{password}".encode("utf-8") + return "Basic " + base64.b64encode(raw).decode() + + +def create_user(prefix="usr", login=True): + user = request("POST", "/api/v1/users", 201, body={ + "username": unique_username(prefix), + "display_name": f"Test {prefix}", + "password": PASSWORD, + })["json"] + if login: + session = request("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(user["username"])})["json"] + user["token"] = session["token"] + return user + + +def auth(user): + return {"Authorization": "Bearer " + user["token"]} + + +def create_chat(owner, members, title="Student test chat"): + result = request( + "POST", + "/api/v1/chats", + 201, + headers=auth(owner), + body={ + "title": title, + "member_ids": [u["id"] for u in members], + }, + ) + + return result["json"] + + +def create_message(user, chat, text): + return request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 201, + headers=auth(user), + body={"text": text}, + )["json"] + + +def test_malformed_json(): + for body in (b'{"username": "broken",', b"\xff"): + request("POST", "/api/v1/users", 400, raw_body=body) + + print("PASS malformed JSON and invalid UTF-8 -> 400 with error envelope") + + +def test_duplicate_username(): + username = unique_username("dup") + + body = { + "username": username, + "display_name": "First", + "password": PASSWORD, + } + + request( + "POST", + "/api/v1/users", + 201, + body=body, + ) + + request( + "POST", + "/api/v1/users", + 409, + body={ + "username": username, + "display_name": "Second", + "password": PASSWORD, + }, + ) + + print("PASS duplicate username -> 409") + + +def test_outsider_chat(): + alice = create_user("alice") + bob = create_user("bob") + eve = create_user("eve") + + chat = create_chat( + alice, + [alice, bob], + "Private chat", + ) + + request( + "GET", + f"/api/v1/chats/{chat['id']}", + 404, + headers=auth(eve), + ) + + request( + "GET", + f"/api/v1/chats/{chat['id']}/messages", + 404, + headers=auth(eve), + ) + + request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 404, + headers=auth(eve), + body={"text": "Not allowed"}, + ) + page = request("GET", "/api/v1/chats", 200, headers=auth(eve))["json"] + if page != {"items": [], "next_cursor": None}: + raise AssertionError("Outsider can see a private chat in the list") + + print("PASS outsider cannot access chat -> 404") + + +def test_empty_and_whitespace_message(): + alice = create_user("emptya") + bob = create_user("emptyb") + + chat = create_chat( + alice, + [alice, bob], + "Empty message test", + ) + + request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 400, + headers=auth(alice), + body={"text": ""}, + ) + + request( + "POST", + f"/api/v1/chats/{chat['id']}/messages", + 400, + headers=auth(alice), + body={"text": " \t\n"}, + ) + + print("PASS empty/whitespace message -> 400") + + +def test_extra_json_field(): + request( + "POST", + "/api/v1/users", + 400, + body={ + "username": unique_username("extra"), + "display_name": "Extra", + "password": PASSWORD, + "admin": True, + }, + ) + + print("PASS extra JSON field -> 400") + + +def test_multi_page_history(): + alice = create_user("pagea") + bob = create_user("pageb") + + chat = create_chat( + alice, + [alice, bob], + "Pagination test", + ) + + expected = [] + + for i in range(7): + message = create_message( + alice, + chat, + f"pagination-message-{i}", + ) + + expected.append(message) + + expected.sort( + key=lambda message: ( + datetime.fromisoformat( + message["created_at"].replace("Z", "+00:00") + ), + uuid.UUID(message["id"]).int, + ) + ) + + expected_ids = [ + message["id"] + for message in expected + ] + + collected = [] + cursor = None + + for _ in range(len(expected) + 1): + path = ( + f"/api/v1/chats/{chat['id']}/messages" + f"?limit=2" + ) + + if cursor is not None: + path += "&cursor=" + urllib.parse.quote( + cursor, + safe="", + ) + + page = request( + "GET", + path, + 200, + headers=auth(bob), + )["json"] + + ids = [item["id"] for item in page["items"]] + collected.extend(ids) + + cursor = page["next_cursor"] + + if cursor is None: + break + else: + raise AssertionError("Pagination did not reach the last page") + + if collected != expected_ids: + raise AssertionError( + "Pagination lost, duplicated or reordered messages.\n" + f"Expected: {expected_ids}\n" + f"Received: {collected}" + ) + + if len(collected) != len(set(collected)): + raise AssertionError( + "Pagination returned duplicate messages" + ) + + print( + f"PASS pagination: {len(collected)} messages " + "read through multiple pages" + ) + + +def test_concurrent_100_messages(): + users = [ + create_user(f"c{i}") + for i in range(10) + ] + + chat = create_chat( + users[0], + users, + "Concurrency test", + ) + + def worker(client_index): + sent = [] + + for message_index in range(10): + text = ( + f"client-{client_index}-" + f"message-{message_index}" + ) + + result = create_message( + users[client_index], + chat, + text, + ) + + sent.append(result) + + return sent + + all_sent = [] + + with concurrent.futures.ThreadPoolExecutor( + max_workers=10 + ) as executor: + futures = [ + executor.submit(worker, i) + for i in range(10) + ] + + for future in concurrent.futures.as_completed( + futures + ): + all_sent.extend(future.result()) + + if len(all_sent) != 100: + raise AssertionError( + f"Expected 100 successful POSTs, got {len(all_sent)}" + ) + + page = request( + "GET", + f"/api/v1/chats/{chat['id']}/messages?limit=100", + 200, + headers=auth(users[0]), + )["json"] + + messages = page["items"] + + if len(messages) != 100: + raise AssertionError( + f"Expected exactly 100 stored messages, " + f"got {len(messages)}" + ) + + ids = [message["id"] for message in messages] + + if len(set(ids)) != 100: + raise AssertionError( + "Expected 100 unique message IDs" + ) + + if set(ids) != {message["id"] for message in all_sent}: + raise AssertionError("Stored messages differ from successful POST responses") + + texts = [message["text"] for message in messages] + + if len(set(texts)) != 100: + raise AssertionError( + "Expected 100 unique message texts" + ) + + if page["next_cursor"] is not None: + raise AssertionError( + "100 messages with limit=100 should fit in one page" + ) + + print( + "PASS concurrency: 10 clients sent 100 messages; " + "exactly 100 unique messages stored" + ) + + +def test_invalid_chat_ids(): + user = create_user("uuid") + for chat_id, expected in (("not-a-uuid", 400), (str(uuid.uuid4()), 404)): + path = f"/api/v1/chats/{chat_id}" + request("GET", path, expected, headers=auth(user)) + request("GET", path + "/messages", expected, headers=auth(user)) + request("POST", path + "/messages", expected, + headers=auth(user), body={"text": "Test"}) + print("PASS invalid chat UUID -> 400; unknown valid UUID -> 404") + + +def test_chat_member_limits(): + users = [create_user("member", login=(i == 0)) for i in range(101)] + owner = users[0] + for members in ([], users, [owner, owner], users[1:3]): + request("POST", "/api/v1/chats", 400, headers=auth(owner), body={ + "title": "Invalid members", "member_ids": [user["id"] for user in members], + }) + request("POST", "/api/v1/chats", 400, headers=auth(owner), body={ + "title": "Unknown member", "member_ids": [owner["id"], str(uuid.uuid4())], + }) + chat = create_chat(owner, users[:100]) + if len(chat["member_ids"]) != 100: + raise AssertionError("Chat must accept exactly 100 members") + print("PASS chat members: 1..100, unique, existing, caller included") + + +def test_invalid_pagination(): + user = create_user("cursor") + chat = create_chat(user, [user]) + other_chat = create_chat(user, [user]) + other_message = create_message(user, other_chat, "Other history") + paths = ("/api/v1/chats", f"/api/v1/chats/{chat['id']}/messages") + for path in paths: + for query in ("cursor=", "cursor=unknown", "limit=0", "limit=101", "limit=abc", "limit=1.5"): + request("GET", path + "?" + query, 400, headers=auth(user)) + request("GET", paths[1] + "?cursor=" + other_message["id"], 400, headers=auth(user)) + print("PASS invalid cursor/limit and cursor from another chat -> 400") + + +def test_multi_page_chats(): + user = create_user("chatpage") + chats = [create_chat(user, [user], f"Chat {i}") for i in range(7)] + chats.sort(key=lambda chat: (chat["created_at"], uuid.UUID(chat["id"]).int)) + collected = [] + cursor = None + for page_number in range(len(chats) + 1): + query = {"limit": 2 if page_number == 0 else 3} + if cursor is not None: + query["cursor"] = cursor + page = request("GET", "/api/v1/chats?" + urllib.parse.urlencode(query), + 200, headers=auth(user))["json"] + collected.extend(chat["id"] for chat in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + else: + raise AssertionError("Chat pagination did not reach the last page") + if collected != [chat["id"] for chat in chats]: + raise AssertionError("Chat pagination lost, duplicated or reordered chats") + print("PASS pagination: 7 chats, changing limit between pages") + + +def test_validation_and_unicode(): + for display_name in ("", " \t", "x" * 101, 123, None): + request("POST", "/api/v1/users", 400, body={ + "username": unique_username("invalid"), "display_name": display_name, "password": PASSWORD, + }) + request("POST", "/api/v1/users", 400, + body={"username": True, "display_name": "Test", "password": PASSWORD}) + for password in ("short", "x" * 129, 12345678901234, None): + request("POST", "/api/v1/users", 400, body={ + "username": unique_username("badpw"), "display_name": "Test", "password": password, + }) + request("POST", "/api/v1/users", 400, + body={"username": unique_username("nopw"), "display_name": "Test"}) + + unicode_password = "\U00020000" * 12 # пароль не из ASCII проходит через Basic/UTF-8 и KDF + user = request("POST", "/api/v1/users", 201, body={ + "username": unique_username("unicode"), "display_name": "\U00020000" * 100, + "password": unicode_password, + })["json"] + session = request("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(user["username"], unicode_password)})["json"] + user["token"] = session["token"] + + chat = create_chat(user, [user]) + path = f"/api/v1/chats/{chat['id']}/messages" + text = "\U00020000" * 4000 + message = create_message(user, chat, text) + if message["text"] != text: + raise AssertionError("Unicode message was altered") + for invalid in (text + "x", 123, None): + request("POST", path, 400, headers=auth(user), body={"text": invalid}) + + request("GET", "/api/v1/users/me", 401) + request("GET", "/api/v1/users/me", 401, headers={"X-User-Id": user["id"]}) + request("GET", "/api/v1/users/me", 401, + headers={"Authorization": basic(user["username"], unicode_password)}) + print("PASS strict types, Unicode, password rules, Bearer-only identification") + + +def main(): + tests = [ + test_malformed_json, + test_duplicate_username, + test_outsider_chat, + test_empty_and_whitespace_message, + test_extra_json_field, + test_multi_page_history, + test_concurrent_100_messages, + test_invalid_chat_ids, + test_chat_member_limits, + test_invalid_pagination, + test_multi_page_chats, + test_validation_and_unicode, + ] + + print(f"Testing {BASE_URL}") + + for test in tests: + test() + + print() + print( + f"PASS: {len(tests)} student test scenarios completed" + ) + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + print( + f"FAIL: {type(exc).__name__}: {exc}", + file=sys.stderr, + ) + sys.exit(1) diff --git a/student_tests/test_lifecycle.py b/student_tests/test_lifecycle.py new file mode 100644 index 00000000..5b87eff8 --- /dev/null +++ b/student_tests/test_lifecycle.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +"""Жизненный цикл ЛР 2: данные и сессии переживают перезапуск всего стенда (API, PostgreSQL, Valkey). +Нужен запущенный compose-стенд; перезапуск делает scripts/restart.sh (volumes сохраняются).""" +import os +import sys +import uuid + +import test_lab2 as api +from test_sigterm import ROOT, run, wait_ready + + +def compose_logs(): + return run("docker", "compose", "--project-directory", str(ROOT), "--env-file", str(ROOT / ".env"), + "logs", "api", "--no-color").stdout + + +def main(): + api.BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/") + wait_ready(api.BASE_URL) + + alice = api.create_user("lifealice") + bob = api.create_user("lifebob") + outsider = api.create_user("lifeoutsider") + chat = api.create_chat(alice, [alice, bob], "Lifecycle test") + texts = ["private-lifecycle-" + uuid.uuid4().hex for _ in range(2)] + sent = [api.create_message(user, chat, text) for user, text in zip((alice, bob), texts)] + path = f"/api/v1/chats/{chat['id']}/messages" + page = api.request("GET", path, 200, headers=api.auth(bob))["json"] + if [m["id"] for m in page["items"]] != [m["id"] for m in sent]: + raise AssertionError("Created messages are missing or reordered") + print("PASS two users created and read two messages: HTTP 201, then HTTP 200") + + api.request("GET", path, 404, headers=api.auth(outsider)) + api.request("POST", path, 404, headers=api.auth(outsider), body={"text": "Forbidden"}) + print("PASS third user cannot read or write the chat: HTTP 404") + + logs = compose_logs() + if any(text in logs for text in texts): + raise AssertionError("Message contents leaked into container logs") + if "req_id=" not in logs or "with status 201" not in logs: + raise AssertionError("Request logs are missing") + print("PASS request logs include IDs and statuses, without message contents") + + print("Command: scripts/restart.sh (API + PostgreSQL + Valkey, volumes kept)", flush=True) + run(str(ROOT / "scripts" / "restart.sh"), timeout=120) + wait_ready(api.BASE_URL, timeout=90) + + # те же токены, те же данные + api.request("GET", "/api/v1/users/me", 200, headers=api.auth(alice)) + after = api.request("GET", path, 200, headers=api.auth(bob))["json"] + if after["items"] != page["items"]: + raise AssertionError("History changed after restart") + api.request("GET", path, 404, headers=api.auth(outsider)) + print("PASS after restart: same tokens read the same history") + + api.request("DELETE", "/api/v1/auth/sessions/current", 204, headers=api.auth(alice)) + api.request("GET", path, 401, headers=api.auth(alice)) + api.request("GET", path, 200, headers=api.auth(bob)) + print("PASS logout revokes only alice's session; bob's session still works") + print("PASS persistent lifecycle: data and sessions survive full restart") + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + print(f"FAIL: {type(exc).__name__}: {exc}", file=sys.stderr) + sys.exit(1) \ No newline at end of file diff --git a/student_tests/test_sigterm.py b/student_tests/test_sigterm.py new file mode 100644 index 00000000..384cfc36 --- /dev/null +++ b/student_tests/test_sigterm.py @@ -0,0 +1,129 @@ +#!/usr/bin/env python3 + +import concurrent.futures +import os +import socket +import subprocess +import sys +import time +import urllib.error +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +IMAGE = os.environ.get("IMAGE", "mtusi-messenger:lab2") +NETWORK = os.environ.get("COMPOSE_NETWORK", "mtusi-lab2_default") +PORT = int(os.environ.get("SIGTERM_PORT", "18080")) + + +def run(*args, check=True, timeout=60): + return subprocess.run( + args, check=check, text=True, stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, timeout=timeout, + ) + +def docker_run_args(name, port): + # Отдельный контейнер API в сети compose: те же PostgreSQL и Valkey, секрет только для чтения + return ["docker", "run", "-d", "--name", name, "--network", NETWORK, + "-p", f"127.0.0.1:{port}:8080", + "-v", f"{ROOT}/secrets/database_url:/run/secrets/database_url:ro", + "-e", "DATABASE_URL_FILE=/run/secrets/database_url", + "-e", "CACHE_URL=redis://valkey:6379/0", + IMAGE] + + +def wait_ready(base_url, timeout=60): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + with urllib.request.urlopen(base_url + "/health/ready", timeout=1) as response: + if response.status == 200: + return + except (urllib.error.URLError, ConnectionError, TimeoutError): + pass + time.sleep(0.2) + raise RuntimeError("Test container did not become ready") + + +def connection_rejected(base_url): + try: + with urllib.request.urlopen(base_url + "/health/ready", timeout=0.5): + return False + except urllib.error.HTTPError: + return False + except (urllib.error.URLError, ConnectionError, TimeoutError): + return True + + +def test_shutdown(incomplete_request): + name = "mtusi-messenger-sigterm-" + uuid.uuid4().hex[:8] + base_url = f"http://127.0.0.1:{PORT}" + scenario = "incomplete POST" if incomplete_request else "idle" + pending = None + try: + run(*docker_run_args(name, PORT)) + wait_ready(base_url) + + if incomplete_request: + pending = socket.create_connection(("127.0.0.1", PORT), timeout=3) + pending.sendall( + b"POST /api/v1/users HTTP/1.1\r\n" + b"Host: localhost\r\nContent-Type: application/json\r\n" + b"Content-Length: 100\r\nExpect: 100-continue\r\n\r\n" + ) + response = b"" + while b"\r\n\r\n" not in response: + part = pending.recv(1024) + if not part: + raise AssertionError("Connection closed before 100 Continue") + response += part + if b"100 Continue" not in response: + raise AssertionError(f"Expected 100 Continue, received {response!r}") + pending.sendall(b"{") + + print(f"Scenario: {scenario}; docker stop --timeout 10 {name}", flush=True) + start = time.monotonic() + with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor: + stopped = executor.submit(run, "docker", "stop", "--timeout", "10", name) + deadline = start + 2 + while not connection_rejected(base_url): + if time.monotonic() >= deadline: + raise AssertionError("New connections are still accepted during shutdown") + time.sleep(0.05) + rejected_after = time.monotonic() - start + stopped.result(timeout=12) + elapsed = time.monotonic() - start + + exit_code = int(run("docker", "inspect", name, "--format", "{{.State.ExitCode}}").stdout) + if exit_code != 0: + raise AssertionError(f"Container exited with code {exit_code}, expected 0") + if elapsed > 10: + raise AssertionError(f"Shutdown exceeded 10 seconds: {elapsed:.3f}s") + if not connection_rejected(base_url): + raise AssertionError("API still accepts connections after shutdown") + + logs = run("docker", "logs", name).stdout + if "Application shutdown complete" not in logs: + raise AssertionError("Application did not complete its shutdown handler") + print(f"PASS {scenario}: exit code 0; shutdown {elapsed:.3f}s; " + f"new connections rejected after {rejected_after:.3f}s") + finally: + if pending is not None: + pending.close() + run("docker", "rm", "-f", name, check=False) + + +def main(): + print(f"Image: {IMAGE}") + test_shutdown(False) + test_shutdown(True) + print("PASS SIGTERM: both scenarios completed within 10 seconds") + + +if __name__ == "__main__": + try: + main() + except Exception as exc: + print(f"FAIL: {type(exc).__name__}: {exc}", file=sys.stderr) + sys.exit(1) -- 2.54.0 From 5a745e6434b417d7ccb32f01f3c1ed4b183dcdf1 Mon Sep 17 00:00:00 2001 From: Sona Date: Tue, 3 Nov 2026 12:13:58 +0300 Subject: [PATCH 7/7] =?UTF-8?q?=D0=9B=D0=A0=202:=20=D0=BE=D1=82=D1=87?= =?UTF-8?q?=D1=91=D1=82=20=D0=B8=20=D0=B8=D1=82=D0=BE=D0=B3=D0=BE=D0=B2?= =?UTF-8?q?=D1=8B=D0=B5=20=D0=B4=D0=BE=D0=BA=D0=B0=D0=B7=D0=B0=D1=82=D0=B5?= =?UTF-8?q?=D0=BB=D1=8C=D1=81=D1=82=D0=B2=D0=B0=20(=D1=83=D1=80=D0=BE?= =?UTF-8?q?=D0=B2=D0=B5=D0=BD=D1=8C=204)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 139 +++++++++++++++++++++++++++--- evidence/restart-after.txt | 7 +- evidence/restart-before.txt | 7 +- evidence/student-tests-level4.txt | 3 +- student_tests/test_level4.py | 16 ++++ 5 files changed, 151 insertions(+), 21 deletions(-) diff --git a/REPORT.md b/REPORT.md index e42f2b05..34bc7b9b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,148 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Саргсян Сона, БВТ2302 +- Целевая оценка: 4 +- Commit/PR: +- Использованные источники, библиотеки и помощь ИИ: Claude Code. Библиотеки: FastAPI, Pydantic, Uvicorn, asyncpg, argon2-cffi, redis-py (клиент для Valkey). ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Git, Docker с запущенным daemon (Compose v2), Make, Python 3.9+ (для публичных проверок, только стандартная библиотека) и `openssl`. Порты 8080 (API), 18080 (только SIGTERM-тест) должны быть свободны. При первой сборке нужен доступ к Docker Hub и PyPI. + +Версии: Python 3.12.7 (образ `python:3.12.7-slim`, закреплён digest), FastAPI 0.115.2, Pydantic 2.14.1, Uvicorn 0.32.0, asyncpg 0.30.0, argon2-cffi 23.1.0, redis-py 5.2.1, PostgreSQL 16.6 (`postgres:16.6-alpine`), Valkey 8.0.1 (`valkey/valkey:8.0.1-alpine`). Все runtime-зависимости закреплены в `requirements.txt`. + +Действия оператора (один раз). Секреты создаются локально и в Git не попадают (`secrets/` и `.env` в `.gitignore` и `.dockerignore`): + +```sh +mkdir -p secrets +PW=$(openssl rand -hex 24) +printf '%s' "$PW" > secrets/postgres_password +printf 'postgresql://messenger:%s@postgres:5432/messenger' "$PW" > secrets/database_url +chmod 644 secrets/* +cp .env.example .env +chmod +x scripts/restart.sh +``` + +Права 644 нужны, чтобы непривилегированный пользователь `app` в контейнере прочитал секрет; допустимо только для локального стенда с синтетическими данными. + +Сборка, миграции и запуск. Миграции применяет само приложение при старте (`src/db.py`), отдельного шага нет: + +```sh +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +curl --fail --retry 20 --retry-connrefused --retry-delay 1 http://localhost:8080/health/ready +``` + +Проверки: + +```sh +make check +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +python3 student_tests/test_lab2.py +python3 student_tests/test_lifecycle.py +python3 student_tests/test_sigterm.py +python3 -m unittest discover -s student_tests -p "test_level4.py" -v +docker compose --env-file .env exec -T postgres psql -U messenger -d messenger < scripts/explain.sql +``` + +`test_level4.py` останавливает и запускает контейнеры valkey/postgres/api; volumes не удаляются. `test_sigterm.py` запускает отдельный контейнер API в сети compose (имя сети по умолчанию `mtusi-lab2_default`, переопределяется `COMPOSE_NETWORK`). + +Остановка с сохранением данных: `docker compose --env-file .env down`. Намеренное удаление учебных данных (БД и Valkey): `docker compose --env-file .env down -v`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент ──HTTP──> API (FastAPI) ──> PostgreSQL 16 (volume pgdata) - источник истины + └────────> Valkey 8 (без persistence) — кэш сессий с TTL +``` + +**Источник истины.** PostgreSQL хранит пользователей, чаты, участников, сообщения и сессии (`migrations/001_init.sql`). Сессия — строка в `sessions`: SHA-256 токена (сам токен не хранится), `user_id`, `expires_at`, `revoked_at`. Токен - 256 бит случайности (`secrets.token_urlsafe(32)`). + +**Роль Valkey.** Кэш проверенных сессий: ключ `sess:`, значение - данные пользователя. Valkey запущен без persistence (`--save "" --appendonly no`), с лимитом памяти 64 МБ и политикой `allkeys-lru`. Потеря кэша (рестарт, `FLUSHALL`) ничего не теряет: следующий запрос получает данные из PostgreSQL и наполняет кэш заново. + +**Политика expiry и инвалидации кэша.** +- TTL записи = `min(остаток жизни сессии, CACHE_TTL_SECONDS=60)`, то есть кэш никогда не живёт дольше сессии. +- Logout: сначала `UPDATE sessions SET revoked_at` в PostgreSQL, затем `DEL` ключа в Valkey. +- Данные пользователя в кэше неизменяемы (в API нет редактирования), поэтому других причин инвалидации нет. +- Если Valkey недоступен, кэш обходится (любой сбой - промах); после сбоя обращения к кэшу приостанавливаются на 5 секунд, чтобы не ждать таймаут на каждом запросе. Readiness зависит только от PostgreSQL: Valkey - оптимизация, а не критичная зависимость. + +**Аутентификация.** `POST /auth/sessions` принимает только `Authorization: Basic`; остальные endpoint - только Bearer (зависимость `current_user`). `X-User-Id` не читается. Пароли хешируются Argon2id (argon2-cffi, параметры по умолчанию библиотеки), вычисление выполняется в thread pool. Для несуществующего пользователя проверка идёт по хешу-заглушке, ответ одинаковый 401. Это отличает password KDF (медленный, с солью, защищает слабые пароли от перебора) от быстрого checksum: токен имеет 256 бит случайности, поэтому для него достаточно SHA-256. + +**Транзакционные границы.** +- Создание чата: `INSERT chats` + `INSERT chat_members` в одной транзакции; неизвестный участник нарушает FK и откатывает всё. +- Отправка сообщения: проверка членства и `INSERT` - один оператор (`INSERT ... SELECT ... WHERE EXISTS`). +- Регистрация: гонку одинаковых username решает `UNIQUE`, приложение ловит `UniqueViolationError` и отвечает 409. +- Миграции: каждая в транзакции вместе с записью в `schema_migrations`, под `pg_advisory_lock`. + +**Что перенесено из lab1.** Структура приложения (middleware с `X-Request-Id`, формат ошибок, строгая валидация Pydantic, обработка SIGTERM), Dockerfile, собственные тесты (адаптированы под пароль/Bearer). **Что изменено.** In-memory словари заменены PostgreSQL; `X-User-Id` заменён Bearer; добавлены password KDF, сессии, Valkey, миграции, compose. Курсор пагинации теперь keyset `(created_at, id)`, непрозрачный и привязанный к ресурсу (раньше был ID записи). + +**Соответствие переменных `.env.example`.** + +| Переменная | Реализация | +| --- | --- | +| `APP_HOST`, `APP_PORT` | задаются в Dockerfile (0.0.0.0 / 8080) | +| `APP_ENV` | передаётся в контейнер, поведение не меняет | +| `SESSION_TTL_SECONDS` | срок жизни сессии (по умолчанию 3600) | +| `DATABASE_URL_FILE` | путь к секрету с адресом PostgreSQL | +| `SESSION_STORE` | не используется: сессии всегда в PostgreSQL, Valkey - кэш | +| `CACHE_URL_FILE` | поддерживается; в compose адрес Valkey передаётся через `CACHE_URL` (в нём нет секретов) | + +Дополнительно: `DB_POOL_MIN=2`, `DB_POOL_MAX=10`, `DB_CONNECT_TIMEOUT=5`, `DB_COMMAND_TIMEOUT=5`, `CACHE_TTL_SECONDS=60`, `CACHE_TIMEOUT=0.5`, `MIGRATIONS_DIR`. ## Доказательства критериев +Дата проверок: 03.11.2026; стенд: . + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` | PASS: lab2 public API scenario | `evidence/smoke.txt` | +| Данные и сессии переживают рестарт API и хранилищ без удаления volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; контейнеры postgres/valkey `Up 5 seconds`, api `Up Less than a second` после hook | `evidence/persistence.txt`, `evidence/restart-before.txt`, `evidence/restart-after.txt` | +| Полный жизненный цикл: тот же токен читает те же данные после рестарта, logout → 401 | `python3 student_tests/test_lifecycle.py` | PASS (7 проверок) | `evidence/lifecycle.txt` | +| Таблицы, PK/FK, UNIQUE username, миграции с нуля | `migrations/001_init.sql`, запуск с пустым volume | миграция применена | `evidence/migrations.txt` | +| Миграции повторно запускаются без дублирования | перезапуск стенда, `logs api \| grep migration` | одна строка `Applied migration 001_init.sql` за все рестарты | `evidence/migrations.txt` | +| Атомарность создания чата | `test_chat_creation_rolls_back` | чат с неизвестным участником → 400, `count(*)` в БД = 0 | `evidence/student-tests-level4.txt` | +| Basic только на `POST /auth/sessions`, Bearer на остальных, `X-User-Id` без доступа, срок жизни, отзыв | `test_lab2.py` (`test_validation_and_unicode`), `test_x_user_id_gives_no_access`, `test_logout_...`, `test_zz_session_expiry` | PASS | `evidence/student-tests.txt`, `evidence/student-tests-level4.txt` | +| Пароли хешируются KDF | `src/auth.py` (Argon2id), в БД только `password_hash` | см. код | `src/auth.py` | +| Secrets/volumes не в Git | `.gitignore`, `.dockerignore`, `git status` перед коммитом | `.env`, `secrets/` не отслеживаются | — | +| **4:** Valkey реально используется (сессии с TTL) | `valkey-cli keys 'sess:*'` после запросов; `test_valkey_flush_keeps_sessions` | ключи `sess:...` есть, после `FLUSHALL` сессия работает и кэш наполняется снова | `evidence/student-tests-level4.txt` | +| **4:** параметризованные запросы, ограниченный пул, таймауты | `src/db.py`, `src/chats.py` (все запросы с `$n`) | пул 2–10, таймауты соединения и команд 5 с | `src/db.py` | +| **4:** гонка регистрации | `test_register_race_same_username` | 10 параллельных POST: ровно один 201, девять 409 | `evidence/student-tests-level4.txt` | +| **4:** индекс истории + EXPLAIN на ≥10 000 сообщений | `scripts/explain.sql` | с индексом `messages_history_idx`: Index Scan, 3 страницы буфера и для первой страницы, и для страницы из середины истории (0.03 мс); без индекса: Seq Scan + сортировка, 123 страницы (0.9 мс) | `evidence/explain.txt` | +| **4:** expiry при коротком TTL, logout, неверный пароль | `test_zz_session_expiry` (TTL=2), `test_logout_...`, `test_wrong_password` | PASS | `evidence/student-tests-level4.txt` | +| **4:** недоступность Valkey и PostgreSQL | `test_valkey_down_falls_back_to_postgres`, `test_postgres_down_returns_bounded_error` | Valkey остановлен: запросы работают через PostgreSQL; PostgreSQL остановлен: `/health/ready` 503, неизвестный токен 503, запрос без токена 401, регистрация 503 | `evidence/student-tests-level4.txt` | +| Собственные тесты | `python3 student_tests/test_lab2.py` | PASS: 12 сценариев | `evidence/student-tests.txt` | +| Корректная остановка | `python3 student_tests/test_sigterm.py` | PASS: exit code 0, idle 0.34 с, с незавершённым POST 8.4 с | `evidence/sigterm.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Трек 5 не заявлен. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Объём данных EXPLAIN: 10 000 сообщений в одном чате, синтетика (`scripts/explain.sql`), PostgreSQL 16.6, все чтения из shared buffers (`shared hit`), диска нет. Замер единичный, прогрев не выполнялся, поэтому важно соотношение (3 страницы против 123), а не абсолютные миллисекунды. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Полный рестарт api + postgres + valkey (volumes сохранены) | токен и данные сохраняются | тот же токен читает ту же историю | сервисы `Up` через ~5 с; потери данных нет | +| `FLUSHALL` в Valkey | сессии работают, кэш наполняется заново | ответ 200 из PostgreSQL, ключи `sess:*` появляются снова | без прерывания; потери данных нет | +| Остановка Valkey | чтение и вход работают через PostgreSQL | 200 для действующего токена, 401 для неизвестного и анонимного | после `start` кэш снова используется не позднее чем через 5 с; потери данных нет | +| Остановка PostgreSQL | ограниченная ошибка, аноним не доверенный | `/health/ready` 503 (код `unavailable`), неизвестный токен 503, запрос без токена 401, регистрация 503 | API снова готов после старта PostgreSQL в пределах 90 с ожидания теста (точное время не измерялось) | +| `SESSION_TTL_SECONDS=2` | токен истекает | через 3.5 с запрос с тем же токеном → 401 (в том числе из-за TTL кэша ≤ остатка сессии) | не применимо | + +Ограничения измерения: нагрузочный профиль не снимался (трек 5 не заявлен), время восстановления PostgreSQL точно не измерялось. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Устаревание кэша при сбое инвалидации.** Если logout выполнился, а `DEL` в Valkey не прошёл (кратковременный сбой), запись может остаться в кэше не дольше `CACHE_TTL_SECONDS` (60 с). Это сознательный компромисс; снизить окно можно, уменьшив TTL кэша. +- **Порядок истории при конкурентной записи.** `created_at` задаётся через `clock_timestamp()` в момент вставки, а видимость строки определяется моментом COMMIT. При конкурентных записях возможно, что сообщение с чуть более ранним `created_at` станет видимым после того, как читатель уже получил курсор за ним; такая запись не повторится и не пропадёт при следующем чтении с начала, но может быть пропущена при продолжении по старому курсору. Гарантируется отсутствие повторов при обходе неизменной истории. +- **Просроченные сессии не удаляются** из таблицы `sessions` (нет фоновой очистки); они не принимаются, но занимают место. Следующий шаг - периодическая очистка по индексу `sessions_expires_idx`. +- **Один экземпляр PostgreSQL и Valkey**, без репликации и бэкапов; отказ диска PostgreSQL приведёт к потере данных (backup/restore - трек 2 уровня 5, не реализован). +- **HTTP и Basic без TLS** - допустимо только для локального изолированного стенда с синтетическими данными. Права `644` у секретов - учебное упрощение для локального запуска. +- **Argon2id** использует параметры по умолчанию библиотеки; подбор параметров под целевое железо не выполнялся. +- Удалённый CI для сборки приложения не добавлен: `.github/workflows/contracts.yml` проверяет только контракт. + +## Ответы на вопросы защиты + +- **Что подтверждает COMMIT?** Транзакция записана в WAL и (при `synchronous_commit=on`, значение по умолчанию) сброшена на диск до ответа клиенту; гарантия зависит от настроек `fsync`/`synchronous_commit` и от надёжности диска и Docker volume. +- **Где хранятся сессии и что будет после flush/restart Redis/Valkey?** Источник истины - таблица `sessions` в PostgreSQL; Valkey лишь кэш без persistence. После flush или рестарта кэш пуст, сессии не теряются и наполняют кэш заново (`test_valkey_flush_keeps_sessions`). +- **Чем аутентификация отличается от доступа к чату?** Аутентификация отвечает «кто вы» (Bearer-сессия), доступ - «можно ли этому пользователю в этот чат» (проверка членства в `chat_members`); постороннему возвращается 404, чтобы не раскрывать существование чата. +- **Почему hash пароля и быстрый checksum - разные задачи?** Пароль имеет низкую энтропию и должен защищаться от перебора, поэтому нужен медленный salted KDF (Argon2id); токен сессии - 256 бит случайности, перебор невозможен, и достаточно быстрого SHA-256. \ No newline at end of file diff --git a/evidence/restart-after.txt b/evidence/restart-after.txt index f64ea133..65b72e72 100644 --- a/evidence/restart-after.txt +++ b/evidence/restart-after.txt @@ -1,3 +1,4 @@ -NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS -mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 38 minutes ago Up Less than a second (health: starting) 127.0.0.1:8080->8080/tcp -mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 38 minutes ago Up 5 seconds (healthy) 5432/tcp +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 7 hours ago Up Less than a second (health: starting) 127.0.0.1:8080->8080/tcp +mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 10 hours ago Up 5 seconds (healthy) 5432/tcp +mtusi-lab2-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey 8 hours ago Up 5 seconds (healthy) 6379/tcp diff --git a/evidence/restart-before.txt b/evidence/restart-before.txt index 5a2da7e7..6e32f5cd 100644 --- a/evidence/restart-before.txt +++ b/evidence/restart-before.txt @@ -1,3 +1,4 @@ -NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS -mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 38 minutes ago Up 39 seconds (healthy) 127.0.0.1:8080->8080/tcp -mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 38 minutes ago Up 44 seconds (healthy) 5432/tcp +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi-lab2-api-1 mtusi-messenger:lab2 "sh -c 'exec uvicorn…" api 7 hours ago Up 3 minutes (healthy) 127.0.0.1:8080->8080/tcp +mtusi-lab2-postgres-1 postgres:16.6-alpine "docker-entrypoint.s…" postgres 10 hours ago Up 3 minutes (healthy) 5432/tcp +mtusi-lab2-valkey-1 valkey/valkey:8.0.1-alpine "docker-entrypoint.s…" valkey 8 hours ago Up 3 minutes (healthy) 6379/tcp diff --git a/evidence/student-tests-level4.txt b/evidence/student-tests-level4.txt index 6c8df7ff..7e736adc 100644 --- a/evidence/student-tests-level4.txt +++ b/evidence/student-tests-level4.txt @@ -17,6 +17,7 @@ ok test_valkey_down_falls_back_to_postgres (test_level4.Level4.test_valkey_down_falls_back_to_postgres) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up _warnings.warn(self.warn_message, ResourceWarning) ok +test_valkey_flush_keeps_sessions (test_level4.Level4.test_valkey_flush_keeps_sessions) ... ok test_wrong_password (test_level4.Level4.test_wrong_password) ... /opt/homebrew/Cellar/python@3.14/3.14.0_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/tempfile.py:484: ResourceWarning: Implicitly cleaning up _warnings.warn(self.warn_message, ResourceWarning) ok @@ -26,6 +27,6 @@ test_zz_session_expiry (test_level4.Level4.test_zz_session_expiry) ... /opt/home ok ---------------------------------------------------------------------- -Ran 8 tests in 12.946s +Ran 9 tests in 16.447s OK diff --git a/student_tests/test_level4.py b/student_tests/test_level4.py index c8d1fde1..d523e36b 100644 --- a/student_tests/test_level4.py +++ b/student_tests/test_level4.py @@ -145,6 +145,22 @@ class Level4(unittest.TestCase): self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer("x" * 43))[0], 401) finally: compose("start", "valkey") + + def test_valkey_flush_keeps_sessions(self): + _, token = new_session() + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + compose("exec", "-T", "valkey", "valkey-cli", "FLUSHALL") + # кэш пуст, но сессия живёт в PostgreSQL; ответ не зависит от состояния кэша + deadline = time.time() + 10 + refilled = False + while time.time() < deadline: + self.assertEqual(call("GET", "/api/v1/users/me", headers=bearer(token))[0], 200) + keys = compose("exec", "-T", "valkey", "valkey-cli", "keys", "sess:*") + if keys.strip(): + refilled = True + break + time.sleep(1) + self.assertTrue(refilled, "cache should be refilled after a miss") def test_postgres_down_returns_bounded_error(self): compose("stop", "postgres") -- 2.54.0