From 893beaa79a336540792d97d2a77b20246d2041d9 Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Mon, 12 Oct 2026 19:05:00 +0300 Subject: [PATCH 1/7] =?UTF-8?q?chore:=20=D0=BF=D0=B5=D1=80=D0=B5=D0=BD?= =?UTF-8?q?=D0=BE=D1=81=20=D1=80=D0=B5=D1=88=D0=B5=D0=BD=D0=B8=D1=8F=20lab?= =?UTF-8?q?1=20(src,=20student-tests,=20Dockerfile,=20lock)=20=D0=B1=D0=B5?= =?UTF-8?q?=D0=B7=20=D0=B8=D0=B7=D0=BC=D0=B5=D0=BD=D0=B5=D0=BD=D0=B8=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Исходная точка lab2: код из solution/bvt2302-bodanyuk лабы 1, коммит 472c1bd. Co-Authored-By: Claude Opus 5.5 --- .gitattributes | 3 + Dockerfile | 48 ++++ requirements-test.txt | 4 + requirements.in | 8 + src/messenger/__init__.py | 3 + src/messenger/__main__.py | 64 ++++++ src/messenger/app.py | 271 +++++++++++++++++++++++ src/messenger/config.py | 76 +++++++ src/messenger/cursor.py | 51 +++++ src/messenger/docs.py | 57 +++++ src/messenger/errors.py | 48 ++++ src/messenger/healthcheck.py | 19 ++ src/messenger/logging_setup.py | 36 +++ src/messenger/store.py | 191 ++++++++++++++++ src/messenger/validation.py | 103 +++++++++ student-tests/conftest.py | 91 ++++++++ student-tests/http_concurrency.py | 134 +++++++++++ student-tests/test_chats_and_messages.py | 219 ++++++++++++++++++ student-tests/test_store_concurrency.py | 131 +++++++++++ student-tests/test_users_and_errors.py | 139 ++++++++++++ 20 files changed, 1696 insertions(+) create mode 100644 .gitattributes create mode 100644 Dockerfile create mode 100644 requirements-test.txt create mode 100644 requirements.in create mode 100644 src/messenger/__init__.py create mode 100644 src/messenger/__main__.py create mode 100644 src/messenger/app.py create mode 100644 src/messenger/config.py create mode 100644 src/messenger/cursor.py create mode 100644 src/messenger/docs.py create mode 100644 src/messenger/errors.py create mode 100644 src/messenger/healthcheck.py create mode 100644 src/messenger/logging_setup.py create mode 100644 src/messenger/store.py create mode 100644 src/messenger/validation.py create mode 100644 student-tests/conftest.py create mode 100644 student-tests/http_concurrency.py create mode 100644 student-tests/test_chats_and_messages.py create mode 100644 student-tests/test_store_concurrency.py create mode 100644 student-tests/test_users_and_errors.py diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..fe0e8601 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +# LF everywhere: identical files on Windows/Linux and inside `git archive | docker build -`. +* text=auto eol=lf +*.png binary diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..026e6831 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,48 @@ +# syntax=docker/dockerfile:1 +# In-memory messenger, lab 1. Build: docker build -t mtusi-messenger:lab1 . +# +# Python is interpreted, so there is no separate compile stage; the image +# contains only the interpreter, locked dependencies and the source code. +# Base image is pinned by version AND digest (python 3.13.15, Debian 12 bookworm). +FROM python:3.13.15-slim-bookworm@sha256:2325bb286ec344af3e5898cc224b5844e2707ac6e26b1632516fd3edc84a5e26 + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 + +WORKDIR /app + +# 1. Dependencies first (layer cache survives source edits). Every package, +# including transitive ones, is pinned with sha256 hashes in requirements.txt; +# --no-deps guarantees nothing outside the lock file is installed. +COPY requirements.txt ./ +RUN pip install --root-user-action=ignore --require-hashes --no-deps -r requirements.txt + +# 2. Unprivileged runtime user. Code stays owned by root, so the process +# cannot modify its own code. +RUN groupadd --system --gid 10001 app \ + && useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app + +COPY src/ ./src/ +# Course contract, served read-only at /openapi.json for Swagger UI (/docs). +COPY contracts/openapi.json ./contracts/openapi.json + +# Defaults make `docker run` work without an .env file; --env-file overrides them. +ENV PYTHONPATH=/app/src \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab \ + LOG_LEVEL=info \ + SHUTDOWN_TIMEOUT_SECONDS=8 \ + DOCS_ENABLED=true + +USER app:app +EXPOSE 8080 +STOPSIGNAL SIGTERM + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD ["python", "-m", "messenger.healthcheck"] + +# Exec form: the Python server is PID 1 and receives SIGTERM directly (no shell in between). +CMD ["python", "-m", "messenger"] diff --git a/requirements-test.txt b/requirements-test.txt new file mode 100644 index 00000000..c5ab68ff --- /dev/null +++ b/requirements-test.txt @@ -0,0 +1,4 @@ +# Student tests (in-process, via Starlette TestClient). Runtime deps come from requirements.txt. +pytest==9.1.1 +httpx2==2.13.1 +jsonschema==4.26.0 diff --git a/requirements.in b/requirements.in new file mode 100644 index 00000000..7aa83ddf --- /dev/null +++ b/requirements.in @@ -0,0 +1,8 @@ +# Direct runtime dependencies. The pinned lock with hashes is requirements.txt: +# docker run --rm -v "$PWD:/w" -w /w python:3.13.15-slim-bookworm \ +# sh -c "pip install -q pip-tools==7.6.1 && pip-compile --generate-hashes --strip-extras -o requirements.txt requirements.in" +starlette==1.7.0 +uvicorn==0.54.0 +# Fast C parser/event loop used by uvicorn in the container (Linux only). +httptools==0.8.0 +uvloop==0.22.1 ; sys_platform != "win32" diff --git a/src/messenger/__init__.py b/src/messenger/__init__.py new file mode 100644 index 00000000..26148a23 --- /dev/null +++ b/src/messenger/__init__.py @@ -0,0 +1,3 @@ +"""In-memory messenger for lab 1 (MTUSI, «Высоконагруженные приложения»).""" + +__version__ = "1.0.0" diff --git a/src/messenger/__main__.py b/src/messenger/__main__.py new file mode 100644 index 00000000..6a410d4c --- /dev/null +++ b/src/messenger/__main__.py @@ -0,0 +1,64 @@ +"""Entry point: `python -m messenger`. The HTTP server is the main process (PID 1 in Docker). + +Shutdown sequence on SIGTERM/SIGINT: +1. readiness flips to 503 (`app.state.draining = True`); +2. uvicorn closes the listening socket, so new connections are refused; +3. in-flight requests get up to SHUTDOWN_TIMEOUT_SECONDS (default 8 s < Docker's 10 s) to finish; +4. the process exits with code 0. In-memory data is lost by design. +""" +from __future__ import annotations + +import logging +import sys +from types import FrameType + +import uvicorn + +from . import __version__, logging_setup +from .app import create_app +from .config import ConfigError, Settings + +log = logging.getLogger("messenger") + + +class GracefulServer(uvicorn.Server): + """uvicorn.Server that marks the app as draining before the normal graceful stop.""" + + def handle_exit(self, sig: int, frame: FrameType | None) -> None: + if not self.should_exit: + log.info("shutdown_requested", extra={"fields": {"signal": sig, "timeout_s": self.config.timeout_graceful_shutdown}}) + self.config.app.state.draining = True # config.app is our Starlette instance + super().handle_exit(sig, frame) + + +def main() -> int: + try: + settings = Settings.from_env() + except ConfigError as exc: + print(f"configuration error: {exc}", file=sys.stderr) + return 2 + logging_setup.configure(settings.log_level) + app = create_app(settings) + config = uvicorn.Config( + app, + host=settings.host, + port=settings.port, + log_config=None, + access_log=False, + server_header=False, + proxy_headers=False, + lifespan="off", + timeout_graceful_shutdown=settings.shutdown_timeout, + ) + server = GracefulServer(config) + log.info("starting", extra={"fields": { + "version": __version__, "env": settings.env, "host": settings.host, "port": settings.port, + "python": sys.version.split()[0], "storage": "in-memory (single process)", + }}) + server.run() + log.info("stopped", extra={"fields": {"state": app.state.store.counts(), "note": "in-memory data discarded"}}) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/messenger/app.py b/src/messenger/app.py new file mode 100644 index 00000000..9073cda3 --- /dev/null +++ b/src/messenger/app.py @@ -0,0 +1,271 @@ +"""HTTP layer: Starlette routes, request-id/logging middleware and error mapping.""" +from __future__ import annotations + +import asyncio +import logging +import re +import time +import uuid +from typing import Any + +from starlette.applications import Starlette +from starlette.exceptions import HTTPException +from starlette.requests import Request +from starlette.responses import JSONResponse +from starlette.routing import Route +from starlette.types import ASGIApp, Message as AsgiMessage, Receive, Scope, Send + +from . import cursor, docs, validation +from .config import Settings +from .errors import ApiError, InvalidRequest, PayloadTooLarge, Unauthorized, Unavailable +from .store import Store, User + +log = logging.getLogger("messenger") +access_log = logging.getLogger("messenger.access") + +REQUEST_ID_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}") + + +# -------------------------------------------------------------------------- +# Responses +# -------------------------------------------------------------------------- +def error_response(request_id: str, status: int, code: str, message: str, headers: dict[str, str] | None = None) -> JSONResponse: + body = {"error": {"code": code, "message": message, "request_id": request_id}} + return JSONResponse(body, status_code=status, headers={"X-Request-Id": request_id, **(headers or {})}) + + +async def api_error_handler(request: Request, exc: Exception) -> JSONResponse: + assert isinstance(exc, ApiError) + return error_response(request.state.request_id, exc.status, exc.code, exc.message) + + +async def http_exception_handler(request: Request, exc: Exception) -> JSONResponse: + """Unknown routes and wrong methods also answer in the contract error format.""" + assert isinstance(exc, HTTPException) + if exc.status_code == 404: + return error_response(request.state.request_id, 404, "not_found", "Объект не найден") + if exc.status_code == 405: + return error_response(request.state.request_id, 405, "invalid_request", "Метод не поддерживается", exc.headers) + return error_response(request.state.request_id, exc.status_code, "invalid_request", "Неверный запрос") + + +# -------------------------------------------------------------------------- +# Middleware (pure ASGI, so it also covers 404/405 and unexpected exceptions) +# -------------------------------------------------------------------------- +class RequestContextMiddleware: + """Assigns X-Request-Id to every response, writes one access-log line, turns crashes into 500.""" + + def __init__(self, app: ASGIApp): + self.app = app + + async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None: + if scope["type"] != "http": + await self.app(scope, receive, send) + return + incoming = dict(scope["headers"]).get(b"x-request-id", b"").decode("latin-1") + request_id = incoming if REQUEST_ID_RE.fullmatch(incoming) else uuid.uuid4().hex + scope.setdefault("state", {})["request_id"] = request_id + status = 500 + started = False + begin = time.perf_counter() + + async def send_with_id(message: AsgiMessage) -> None: + nonlocal status, started + if message["type"] == "http.response.start": + started = True + status = message["status"] + headers = [(k, v) for k, v in message.get("headers", []) if k.lower() != b"x-request-id"] + headers.append((b"x-request-id", request_id.encode("latin-1"))) + message = {**message, "headers": headers} + await send(message) + + try: + await self.app(scope, receive, send_with_id) + except asyncio.CancelledError: + # uvicorn cancels requests still running when SHUTDOWN_TIMEOUT_SECONDS expires: + # answer 503 (retryable) instead of a generic 500, then let the cancellation proceed. + if not started: + status = 503 + response = error_response(request_id, 503, "unavailable", "Сервер завершает работу") + await response(scope, receive, send) + raise + except Exception: + log.exception("unhandled_error", extra={"fields": {"request_id": request_id}}) + if not started: + status = 500 + response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера") + await response(scope, receive, send) + finally: + access_log.info("request", extra={"fields": { + "request_id": request_id, + "method": scope["method"], + "path": scope["path"], # ids only; query (cursor) and bodies are never logged + "status": status, + "duration_ms": round((time.perf_counter() - begin) * 1000, 3), + }}) + + +# -------------------------------------------------------------------------- +# Request helpers +# -------------------------------------------------------------------------- +def store_of(request: Request) -> Store: + return request.app.state.store + + +def current_user(request: Request) -> User: + """Lab 1 identification: X-User-Id must be the UUID of an existing user, otherwise 401.""" + raw = request.headers.get("x-user-id") + if raw is None or validation.UUID_RE.fullmatch(raw) is None: + raise Unauthorized() + user = store_of(request).get_user(raw.lower()) + if user is None: + raise Unauthorized() + return user + + +def path_uuid(request: Request, name: str) -> str: + return validation.parse_uuid(request.path_params[name], name) + + +async def read_json(request: Request) -> dict[str, Any]: + content_type = request.headers.get("content-type", "") + media_type, _, params = content_type.partition(";") + if media_type.strip().lower() != "application/json": + raise InvalidRequest("Content-Type должен быть application/json") + charset = params.strip().lower() + if charset and charset.replace(" ", "") not in {"charset=utf-8", "charset=\"utf-8\""}: + raise InvalidRequest("Поддерживается только кодировка UTF-8") + limit: int = request.app.state.settings.max_body_bytes + declared = request.headers.get("content-length") + if declared is not None and declared.isdigit() and int(declared) > limit: + raise PayloadTooLarge() + chunks: list[bytes] = [] + size = 0 + async for chunk in request.stream(): + size += len(chunk) + if size > limit: + raise PayloadTooLarge() + chunks.append(chunk) + return validation.parse_json_object(b"".join(chunks)) + + +def page_params(request: Request) -> tuple[int, str | None]: + query = request.query_params.multi_items() + limit = validation.parse_limit(validation.single_query_param(query, "limit")) + raw_cursor = validation.single_query_param(query, "cursor") + if raw_cursor is not None and raw_cursor == "": + raise InvalidRequest("cursor не может быть пустым") + return limit, raw_cursor + + +def ok(body: Any, status: int = 200) -> JSONResponse: + return JSONResponse(body, status_code=status) + + +# -------------------------------------------------------------------------- +# Handlers +# -------------------------------------------------------------------------- +async def live(request: Request) -> JSONResponse: + return ok({"status": "ok"}) + + +async def ready(request: Request) -> JSONResponse: + # The only critical dependency is process memory; while draining after + # SIGTERM the instance reports 503 so no new traffic is routed to it. + if request.app.state.draining: + raise Unavailable("Сервер завершает работу") + return ok({"status": "ok"}) + + +async def register_user(request: Request) -> JSONResponse: + data = await read_json(request) + validation.check_fields(data, {"username", "display_name"}) + username = validation.username_field(data) + display_name = validation.text_field(data, "display_name", 100) + user = store_of(request).create_user(username, display_name) + log.info("user_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}}) + return ok(user.to_json(), 201) + + +async def me(request: Request) -> JSONResponse: + return ok(current_user(request).to_json()) + + +async def create_chat(request: Request) -> JSONResponse: + user = current_user(request) + data = await read_json(request) + validation.check_fields(data, {"title", "member_ids"}) + title = validation.text_field(data, "title", 100) + member_ids = validation.member_ids_field(data) + chat = store_of(request).create_chat(user.id, title, member_ids) + log.info("chat_created", extra={"fields": {"request_id": request.state.request_id, "chat_id": chat.id, "members": len(member_ids)}}) + return ok(chat.to_json(), 201) + + +async def list_chats(request: Request) -> JSONResponse: + user = current_user(request) + limit, raw_cursor = page_params(request) + after = cursor.decode(raw_cursor, cursor.CHATS, user.id) if raw_cursor else None + items, has_more = store_of(request).list_chats(user.id, after, limit) + next_cursor = cursor.encode(cursor.CHATS, user.id, items[-1].key) if has_more else None + return ok({"items": [c.to_json() for c in items], "next_cursor": next_cursor}) + + +async def get_chat(request: Request) -> JSONResponse: + user = current_user(request) + chat_id = path_uuid(request, "chat_id") + return ok(store_of(request).get_chat(user.id, chat_id).to_json()) + + +async def create_message(request: Request) -> JSONResponse: + user = current_user(request) + chat_id = path_uuid(request, "chat_id") + store = store_of(request) + store.get_chat(user.id, chat_id) # access check before reading the body: outsiders get 404 + data = await read_json(request) + validation.check_fields(data, {"text"}) + text = validation.text_field(data, "text", 4000) + # sender_id is derived from the identification, never taken from the body. + message = store.add_message(user.id, chat_id, text) + return ok(message.to_json(), 201) + + +async def list_messages(request: Request) -> JSONResponse: + user = current_user(request) + chat_id = path_uuid(request, "chat_id") + store = store_of(request) + store.get_chat(user.id, chat_id) # 404 for outsiders before any cursor details leak + limit, raw_cursor = page_params(request) + after = cursor.decode(raw_cursor, cursor.MESSAGES, chat_id) if raw_cursor else None + items, has_more = store.list_messages(user.id, chat_id, after, limit) + next_cursor = cursor.encode(cursor.MESSAGES, chat_id, items[-1].key) if has_more else None + return ok({"items": [m.to_json() for m in items], "next_cursor": next_cursor}) + + +def create_app(settings: Settings | None = None, store: Store | None = None) -> Starlette: + settings = settings or Settings.from_env() + routes = [ + Route("/health/live", live, methods=["GET"]), + Route("/health/ready", ready, methods=["GET"]), + Route("/api/v1/users", register_user, methods=["POST"]), + Route("/api/v1/users/me", me, methods=["GET"]), + Route("/api/v1/chats", create_chat, methods=["POST"]), + Route("/api/v1/chats", list_chats, methods=["GET"]), + Route("/api/v1/chats/{chat_id}", get_chat, methods=["GET"]), + Route("/api/v1/chats/{chat_id}/messages", create_message, methods=["POST"]), + Route("/api/v1/chats/{chat_id}/messages", list_messages, methods=["GET"]), + ] + if settings.docs_enabled: # Swagger UI for manual experiments, not part of the contract + routes += [ + Route("/docs", docs.swagger_page, methods=["GET"]), + Route("/openapi.json", docs.openapi_json, methods=["GET"]), + ] + app = Starlette( + routes=routes, + exception_handlers={ApiError: api_error_handler, HTTPException: http_exception_handler}, + ) + app.add_middleware(RequestContextMiddleware) + app.state.settings = settings + app.state.store = store or Store() + app.state.draining = False + return app diff --git a/src/messenger/config.py b/src/messenger/config.py new file mode 100644 index 00000000..25f4c51e --- /dev/null +++ b/src/messenger/config.py @@ -0,0 +1,76 @@ +"""Runtime configuration read from environment variables (12-factor style). + +Every variable has a safe default, so `docker run` works from a clean clone +even without an .env file. Invalid values stop the process at startup with a +clear message instead of failing later under traffic. +""" +from __future__ import annotations + +import os +from dataclasses import dataclass + + +class ConfigError(ValueError): + pass + + +def _int(name: str, default: int, low: int, high: int) -> int: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + try: + value = int(raw.strip()) + except ValueError: + raise ConfigError(f"{name} must be an integer, got {raw!r}") from None + if not low <= value <= high: + raise ConfigError(f"{name} must be in [{low}, {high}], got {value}") + return value + + +def _float(name: str, default: float, low: float, high: float) -> float: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + try: + value = float(raw.strip()) + except ValueError: + raise ConfigError(f"{name} must be a number, got {raw!r}") from None + if not low <= value <= high: + raise ConfigError(f"{name} must be in [{low}, {high}], got {value}") + return value + + +def _bool(name: str, default: bool) -> bool: + raw = os.environ.get(name, "").strip().lower() + if raw == "": + return default + if raw not in {"true", "false", "1", "0"}: + raise ConfigError(f"{name} must be true/false, got {raw!r}") + return raw in {"true", "1"} + + +@dataclass(frozen=True) +class Settings: + host: str + port: int + env: str + log_level: str + shutdown_timeout: float + max_body_bytes: int + docs_enabled: bool = True + + @classmethod + def from_env(cls) -> "Settings": + log_level = os.environ.get("LOG_LEVEL", "info").strip().lower() or "info" + if log_level not in {"debug", "info", "warning", "error"}: + raise ConfigError(f"LOG_LEVEL must be debug/info/warning/error, got {log_level!r}") + return cls( + host=os.environ.get("APP_HOST", "0.0.0.0").strip() or "0.0.0.0", + port=_int("APP_PORT", 8080, 1, 65535), + env=os.environ.get("APP_ENV", "lab").strip() or "lab", + log_level=log_level, + # Docker sends SIGKILL 10 s after SIGTERM by default; finish earlier. + shutdown_timeout=_float("SHUTDOWN_TIMEOUT_SECONDS", 8.0, 0.0, 9.0), + max_body_bytes=_int("MAX_BODY_BYTES", 64 * 1024, 1024, 1024 * 1024), + docs_enabled=_bool("DOCS_ENABLED", True), + ) diff --git a/src/messenger/cursor.py b/src/messenger/cursor.py new file mode 100644 index 00000000..bb776049 --- /dev/null +++ b/src/messenger/cursor.py @@ -0,0 +1,51 @@ +"""Opaque keyset cursors. + +A cursor encodes the sort key `(created_at, id)` of the last item on the page +plus the resource it belongs to, e.g. `v1|m|||`, +packed in URL-safe base64. The client treats it as an opaque string; the server +rejects cursors of another chat/user (400) and any non-canonical encoding. +""" +from __future__ import annotations + +import base64 +import re + +from .errors import InvalidRequest +from .validation import UUID_RE + +B64_RE = re.compile(r"[A-Za-z0-9_-]{1,512}") +TS_RE = re.compile(r"[0-9]{1,19}") + +MESSAGES = "m" +CHATS = "c" + +SortKey = tuple[int, str] + + +def encode(scope: str, owner_id: str, key: SortKey) -> str: + ts, item_id = key + raw = f"v1|{scope}|{owner_id}|{ts}|{item_id}".encode("ascii") + return base64.urlsafe_b64encode(raw).rstrip(b"=").decode("ascii") + + +def decode(cursor: str, scope: str, owner_id: str) -> SortKey: + """Return the sort key stored in the cursor or raise InvalidRequest.""" + bad = InvalidRequest("Неверный cursor") + if B64_RE.fullmatch(cursor) is None: + raise bad + try: + raw = base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4)).decode("ascii") + except (ValueError, UnicodeDecodeError): + raise bad from None + parts = raw.split("|") + if len(parts) != 5 or parts[0] != "v1": + raise bad + _, got_scope, got_owner, ts, item_id = parts + if TS_RE.fullmatch(ts) is None or UUID_RE.fullmatch(item_id) is None or item_id != item_id.lower(): + raise bad + key = (int(ts), item_id) + if encode(got_scope, got_owner, key) != cursor: + raise bad # only the canonical form produced by the server is accepted + if got_scope != scope or got_owner != owner_id: + raise InvalidRequest("cursor относится к другому ресурсу") + return key diff --git a/src/messenger/docs.py b/src/messenger/docs.py new file mode 100644 index 00000000..cb2ea46e --- /dev/null +++ b/src/messenger/docs.py @@ -0,0 +1,57 @@ +"""Swagger UI for manual experiments: http://127.0.0.1:8080/docs + +The page shows the course contract contracts/openapi.json as is (it is not +generated from our code). Only `servers` is replaced with "/" so that the +"Try it out" requests go to the same host the page was opened from. +Swagger UI itself (JS/CSS) is loaded by the browser from the jsDelivr CDN. +Disable with DOCS_ENABLED=false. +""" +from __future__ import annotations + +import json +from functools import lru_cache +from pathlib import Path + +from starlette.requests import Request +from starlette.responses import HTMLResponse, JSONResponse + +SPEC_PATH = Path(__file__).resolve().parents[2] / "contracts" / "openapi.json" +SWAGGER_UI = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.33.0" + +PAGE = f""" + + + + Messenger lab1 — Swagger UI + + + +
+ + + + +""" + + +@lru_cache(maxsize=1) +def _spec() -> dict: + spec = json.loads(SPEC_PATH.read_text(encoding="utf-8")) + spec["servers"] = [{"url": "/", "description": "этот сервер"}] + return spec + + +async def swagger_page(request: Request) -> HTMLResponse: + return HTMLResponse(PAGE) + + +async def openapi_json(request: Request) -> JSONResponse: + return JSONResponse(_spec()) diff --git a/src/messenger/errors.py b/src/messenger/errors.py new file mode 100644 index 00000000..c1fe3096 --- /dev/null +++ b/src/messenger/errors.py @@ -0,0 +1,48 @@ +"""Domain errors mapped 1:1 to the contract error codes (contracts/README.md).""" +from __future__ import annotations + + +class ApiError(Exception): + status = 500 + code = "internal_error" + default_message = "Внутренняя ошибка сервера" + + def __init__(self, message: str | None = None): + self.message = message or self.default_message + super().__init__(self.message) + + +class InvalidRequest(ApiError): + status = 400 + code = "invalid_request" + default_message = "Неверный запрос" + + +class Unauthorized(ApiError): + status = 401 + code = "unauthorized" + default_message = "Требуется X-User-Id существующего пользователя" + + +class NotFound(ApiError): + status = 404 + code = "not_found" + default_message = "Объект не найден" + + +class Conflict(ApiError): + status = 409 + code = "conflict" + default_message = "Конфликт" + + +class PayloadTooLarge(ApiError): + status = 413 + code = "payload_too_large" + default_message = "Тело запроса слишком большое" + + +class Unavailable(ApiError): + status = 503 + code = "unavailable" + default_message = "Сервис временно недоступен" diff --git a/src/messenger/healthcheck.py b/src/messenger/healthcheck.py new file mode 100644 index 00000000..8411514b --- /dev/null +++ b/src/messenger/healthcheck.py @@ -0,0 +1,19 @@ +"""Docker HEALTHCHECK probe without curl/wget in the image: `python -m messenger.healthcheck`.""" +from __future__ import annotations + +import os +import sys +import urllib.request + + +def main() -> int: + port = os.environ.get("APP_PORT", "8080").strip() or "8080" + try: + with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=2) as response: + return 0 if response.status == 200 else 1 + except Exception: + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/messenger/logging_setup.py b/src/messenger/logging_setup.py new file mode 100644 index 00000000..388f14de --- /dev/null +++ b/src/messenger/logging_setup.py @@ -0,0 +1,36 @@ +"""JSON-lines logging to stdout. Logs never contain message texts or request bodies.""" +from __future__ import annotations + +import datetime as dt +import json +import logging +import sys + + +class JsonFormatter(logging.Formatter): + def format(self, record: logging.LogRecord) -> str: + entry = { + "ts": dt.datetime.fromtimestamp(record.created, dt.timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z"), + "level": record.levelname.lower(), + "logger": record.name, + "event": record.getMessage(), + } + fields = getattr(record, "fields", None) + if fields: + entry.update(fields) + if record.exc_info: + # Stack traces go only to the server log, never to the HTTP client. + entry["exception"] = self.formatException(record.exc_info) + return json.dumps(entry, ensure_ascii=False) + + +def configure(level: str) -> None: + handler = logging.StreamHandler(sys.stdout) + handler.setFormatter(JsonFormatter()) + root = logging.getLogger() + root.handlers[:] = [handler] + root.setLevel(level.upper()) + # uvicorn's own access log is disabled; our middleware writes one line per request. + for name in ("uvicorn", "uvicorn.error"): + logging.getLogger(name).handlers[:] = [] + logging.getLogger(name).propagate = True diff --git a/src/messenger/store.py b/src/messenger/store.py new file mode 100644 index 00000000..881a8c84 --- /dev/null +++ b/src/messenger/store.py @@ -0,0 +1,191 @@ +"""In-memory state of the messenger: the single source of truth for lab 1. + +Concurrency model +----------------- +All data lives in ordinary dicts/lists of ONE process. Every public method +takes `self._lock` for its whole critical section, so each operation is atomic +and readers never see a half-built chat or message. + +The server runs coroutines on one asyncio event loop, and store methods never +`await`, so on the event loop they are already atomic. The lock additionally +protects the store when it is used from several threads (student-tests start +10 threads that write concurrently) and documents the invariant explicitly. + +Ordering invariant +------------------ +`created_at` is assigned INSIDE the same critical section that appends the +object, from a strictly increasing clock (`_next_ts`). Therefore the append +order of every list equals the contract order `(created_at, id)` even under +concurrent writes and even if the wall clock jumps backwards. +""" +from __future__ import annotations + +import bisect +import datetime as dt +import operator +import threading +import time +import uuid +from dataclasses import dataclass +from typing import Callable + +from .cursor import SortKey +from .errors import Conflict, InvalidRequest, NotFound + +_EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc) +# (created_at, id) of a Chat/Message as a C-level getter: cheap to call inside bisect. +_sort_key = operator.attrgetter("ts", "id") + + +def format_ts(ts_us: int) -> str: + """RFC 3339 UTC with fixed microsecond precision, e.g. 2026-09-25T12:00:00.000001Z.""" + return (_EPOCH + dt.timedelta(microseconds=ts_us)).strftime("%Y-%m-%dT%H:%M:%S.%fZ") + + +@dataclass(slots=True, frozen=True) +class User: + id: str + username: str + display_name: str + ts: int + created_at: str + + def to_json(self) -> dict: + return {"id": self.id, "username": self.username, "display_name": self.display_name, "created_at": self.created_at} + + +@dataclass(slots=True, frozen=True) +class Chat: + id: str + title: str + member_ids: tuple[str, ...] + members: frozenset[str] + ts: int + created_at: str + + @property + def key(self) -> SortKey: + return (self.ts, self.id) + + def to_json(self) -> dict: + return {"id": self.id, "title": self.title, "member_ids": list(self.member_ids), "created_at": self.created_at} + + +@dataclass(slots=True, frozen=True) +class Message: + id: str + chat_id: str + sender_id: str + text: str + ts: int + created_at: str + + @property + def key(self) -> SortKey: + return (self.ts, self.id) + + def to_json(self) -> dict: + return {"id": self.id, "chat_id": self.chat_id, "sender_id": self.sender_id, "text": self.text, "created_at": self.created_at} + + +def _page_after(items: list, after: SortKey | None, limit: int) -> tuple[list, bool]: + """Keyset page: up to `limit` items strictly after `after`, plus "has more". + + `items` is always sorted by (created_at, id) (see the ordering invariant), so + the page start is found by binary search in O(log n) instead of scanning the + history from the beginning (O(n)); only the page itself is copied. + """ + start = 0 if after is None else bisect.bisect_right(items, after, key=_sort_key) + page = items[start:start + limit + 1] + return page[:limit], len(page) > limit + + +class Store: + def __init__(self, clock_ns: Callable[[], int] = time.time_ns): + self._lock = threading.Lock() + self._clock_ns = clock_ns + self._last_ts = 0 + self._users: dict[str, User] = {} + self._user_ids_by_name: dict[str, str] = {} + self._chats: dict[str, Chat] = {} + self._chats_by_user: dict[str, list[Chat]] = {} + self._messages: dict[str, list[Message]] = {} + + # -- helpers (caller holds the lock) --------------------------------- + def _next_ts(self) -> tuple[int, str]: + """Strictly increasing server time in microseconds; must be called under the lock.""" + ts = max(self._clock_ns() // 1000, self._last_ts + 1) + self._last_ts = ts + return ts, format_ts(ts) + + def _chat_for_member(self, user_id: str, chat_id: str) -> Chat: + chat = self._chats.get(chat_id) + # A missing chat and a foreign chat are indistinguishable: both 404. + if chat is None or user_id not in chat.members: + raise NotFound("Чат не найден") + return chat + + # -- users ----------------------------------------------------------- + def create_user(self, username: str, display_name: str) -> User: + with self._lock: + if username in self._user_ids_by_name: + raise Conflict("Имя пользователя уже занято") + ts, created_at = self._next_ts() + user = User(str(uuid.uuid4()), username, display_name, ts, created_at) + self._users[user.id] = user + self._user_ids_by_name[username] = user.id + self._chats_by_user[user.id] = [] + return user + + def get_user(self, user_id: str) -> User | None: + with self._lock: + return self._users.get(user_id) + + # -- chats ----------------------------------------------------------- + def create_chat(self, creator_id: str, title: str, member_ids: list[str]) -> Chat: + with self._lock: + if creator_id not in member_ids: + raise InvalidRequest("member_ids должен включать текущего пользователя") + if any(member not in self._users for member in member_ids): + raise InvalidRequest("member_ids содержит несуществующих пользователей") + ts, created_at = self._next_ts() + chat = Chat(str(uuid.uuid4()), title, tuple(member_ids), frozenset(member_ids), ts, created_at) + # All indexes are updated in one critical section: the chat is created atomically. + self._chats[chat.id] = chat + self._messages[chat.id] = [] + for member in member_ids: + self._chats_by_user[member].append(chat) + return chat + + def get_chat(self, user_id: str, chat_id: str) -> Chat: + with self._lock: + return self._chat_for_member(user_id, chat_id) + + def list_chats(self, user_id: str, after: SortKey | None, limit: int) -> tuple[list[Chat], bool]: + """Page of the user's chats ordered by (created_at, id); returns (items, has_more).""" + with self._lock: + return _page_after(self._chats_by_user[user_id], after, limit) + + # -- messages -------------------------------------------------------- + def add_message(self, user_id: str, chat_id: str, text: str) -> Message: + with self._lock: + chat = self._chat_for_member(user_id, chat_id) + ts, created_at = self._next_ts() + message = Message(str(uuid.uuid4()), chat.id, user_id, text, ts, created_at) + self._messages[chat.id].append(message) + return message + + def list_messages(self, user_id: str, chat_id: str, after: SortKey | None, limit: int) -> tuple[list[Message], bool]: + """Page of history strictly after `after` in (created_at, id) order; returns (items, has_more).""" + with self._lock: + chat = self._chat_for_member(user_id, chat_id) + return _page_after(self._messages[chat.id], after, limit) + + # -- diagnostics ----------------------------------------------------- + def counts(self) -> dict[str, int]: + with self._lock: + return { + "users": len(self._users), + "chats": len(self._chats), + "messages": sum(len(h) for h in self._messages.values()), + } diff --git a/src/messenger/validation.py b/src/messenger/validation.py new file mode 100644 index 00000000..6619324d --- /dev/null +++ b/src/messenger/validation.py @@ -0,0 +1,103 @@ +"""Strict request validation according to contracts/openapi.json + contracts/README.md. + +Written by hand instead of a schema library so that every rule is visible: +extra fields, wrong JSON types, whitespace-only strings and lengths counted in +Unicode code points all produce 400 invalid_request. +""" +from __future__ import annotations + +import json +import re +from typing import Any + +from .errors import InvalidRequest + +USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") +# Canonical textual UUID (8-4-4-4-12 hex). Case-insensitive, normalised to lower case. +UUID_RE = re.compile(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}") +LIMIT_RE = re.compile(r"[0-9]{1,3}") +SURROGATES_RE = re.compile("[\ud800-\udfff]") + +DEFAULT_LIMIT = 50 +MAX_LIMIT = 100 + + +def _reject_constant(name: str) -> Any: + # Python's json accepts NaN/Infinity, which are not valid JSON. + raise ValueError(f"invalid JSON constant {name}") + + +def parse_json_object(body: bytes) -> dict[str, Any]: + """Decode a UTF-8 JSON object or raise InvalidRequest (malformed JSON -> 400).""" + try: + text = body.decode("utf-8") + value = json.loads(text, parse_constant=_reject_constant) + except (UnicodeDecodeError, ValueError): + raise InvalidRequest("Тело запроса должно быть корректным JSON в UTF-8") from None + if not isinstance(value, dict): + raise InvalidRequest("Тело запроса должно быть JSON-объектом") + return value + + +def check_fields(data: dict[str, Any], required: set[str], optional: frozenset[str] = frozenset()) -> None: + extra = set(data) - required - optional + if extra: + raise InvalidRequest("Неизвестные поля: " + ", ".join(sorted(extra))) + missing = required - set(data) + if missing: + raise InvalidRequest("Отсутствуют обязательные поля: " + ", ".join(sorted(missing))) + + +def text_field(data: dict[str, Any], name: str, max_len: int, *, min_len: int = 1) -> str: + value = data[name] + if not isinstance(value, str): + raise InvalidRequest(f"Поле {name} должно быть строкой") + if SURROGATES_RE.search(value): + # "\ud800" escapes decode to lone surrogates that cannot be encoded as UTF-8. + raise InvalidRequest(f"Поле {name} содержит недопустимые символы") + # len() of a Python str is the number of Unicode code points, as the contract requires. + if not min_len <= len(value) <= max_len: + raise InvalidRequest(f"Длина поля {name} должна быть от {min_len} до {max_len} символов") + if value.strip() == "": + raise InvalidRequest(f"Поле {name} не может состоять только из пробелов") + return value + + +def username_field(data: dict[str, Any]) -> str: + value = data["username"] + if not isinstance(value, str) or USERNAME_RE.fullmatch(value) is None: + raise InvalidRequest("username должен соответствовать [a-z0-9_]{3,32}") + return value + + +def parse_uuid(value: Any, what: str = "UUID") -> str: + if not isinstance(value, str) or UUID_RE.fullmatch(value) is None: + raise InvalidRequest(f"Неверный {what}") + return value.lower() + + +def member_ids_field(data: dict[str, Any]) -> list[str]: + value = data["member_ids"] + if not isinstance(value, list): + raise InvalidRequest("member_ids должен быть массивом") + if not 1 <= len(value) <= 100: + raise InvalidRequest("member_ids должен содержать от 1 до 100 элементов") + ids = [parse_uuid(item, "UUID участника") for item in value] + if len(set(ids)) != len(ids): + raise InvalidRequest("member_ids содержит дубликаты") + return ids + + +def single_query_param(query: list[tuple[str, str]], name: str) -> str | None: + values = [v for k, v in query if k == name] + if len(values) > 1: + raise InvalidRequest(f"Параметр {name} указан несколько раз") + return values[0] if values else None + + +def parse_limit(raw: str | None) -> int: + if raw is None: + return DEFAULT_LIMIT + if LIMIT_RE.fullmatch(raw) is None or not 1 <= int(raw) <= MAX_LIMIT: + raise InvalidRequest(f"limit должен быть целым числом от 1 до {MAX_LIMIT}") + return int(raw) diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..14b02707 --- /dev/null +++ b/student-tests/conftest.py @@ -0,0 +1,91 @@ +"""Shared fixtures: an isolated in-process app per test + OpenAPI schema validation.""" +from __future__ import annotations + +import json +import os +import sys +import uuid +from pathlib import Path + +import pytest +from jsonschema import Draft202012Validator +from starlette.testclient import TestClient + +ROOT = Path(__file__).resolve().parents[1] +# MESSENGER_SRC lets scripts/race_mutation_check.py run the same tests against a patched copy. +sys.path.insert(0, os.environ.get("MESSENGER_SRC", str(ROOT / "src"))) + +from messenger.app import create_app # noqa: E402 +from messenger.config import Settings # noqa: E402 + +SPEC = json.loads((ROOT / "contracts" / "openapi.json").read_text(encoding="utf-8")) +SETTINGS = Settings(host="127.0.0.1", port=8080, env="test", log_level="warning", shutdown_timeout=1.0, max_body_bytes=64 * 1024) + + +def schema_errors(value, name: str) -> list[str]: + """Validate against components/schemas/ of the course contract (JSON Schema 2020-12).""" + schema = {"$ref": f"#/components/schemas/{name}", "components": SPEC["components"]} + validator = Draft202012Validator(schema, format_checker=Draft202012Validator.FORMAT_CHECKER) + return [e.message for e in validator.iter_errors(value)] + + +class Api: + """Thin helper over TestClient that checks the invariants every response must satisfy.""" + + def __init__(self, client: TestClient): + self.client = client + + def call(self, method: str, path: str, expected: int, *, user=None, json_body=None, raw=None, headers=None, schema=None): + h = dict(headers or {}) + if user is not None: + h["X-User-Id"] = user["id"] + if json_body is not None: + raw = json.dumps(json_body, ensure_ascii=False).encode("utf-8") + h.setdefault("Content-Type", "application/json") + response = self.client.request(method, path, content=raw, headers=h) + assert response.status_code == expected, (method, path, response.status_code, response.text) + request_id = response.headers.get("x-request-id") + assert request_id, "every response must carry X-Request-Id" + if response.status_code >= 400: + body = response.json() + assert schema_errors(body, "Error") == [] + assert body["error"]["request_id"] == request_id + assert "Traceback" not in response.text + elif schema: + assert schema_errors(response.json(), schema) == [], response.text + return response + + def user(self, label: str = "u", display_name: str | None = None) -> dict: + body = {"username": f"{label}_{uuid.uuid4().hex[:10]}", "display_name": display_name or f"Студент {label}"} + return self.call("POST", "/api/v1/users", 201, json_body=body, schema="User").json() + + def chat(self, owner: dict, *members: dict, title: str = "Тестовый чат") -> dict: + ids = [owner["id"], *(m["id"] for m in members)] + return self.call("POST", "/api/v1/chats", 201, user=owner, json_body={"title": title, "member_ids": ids}, schema="Chat").json() + + def send(self, user: dict, chat: dict, text: str) -> dict: + return self.call("POST", f"/api/v1/chats/{chat['id']}/messages", 201, user=user, json_body={"text": text}, schema="Message").json() + + def history(self, user: dict, chat: dict, limit: int) -> tuple[list[dict], int]: + """Walk all pages; returns (items, number_of_pages).""" + items, pages, cursor = [], 0, None + while True: + query = f"?limit={limit}" + (f"&cursor={cursor}" if cursor else "") + page = self.call("GET", f"/api/v1/chats/{chat['id']}/messages{query}", 200, user=user, schema="MessagePage").json() + pages += 1 + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + return items, pages + assert len(page["items"]) == limit, "a non-final page must be full" + + +@pytest.fixture +def app(): + return create_app(SETTINGS) + + +@pytest.fixture +def api(app) -> Api: + with TestClient(app, raise_server_exceptions=False) as client: + yield Api(client) diff --git a/student-tests/http_concurrency.py b/student-tests/http_concurrency.py new file mode 100644 index 00000000..19c3a214 --- /dev/null +++ b/student-tests/http_concurrency.py @@ -0,0 +1,134 @@ +#!/usr/bin/env python3 +"""Black-box race check against a RUNNING server (level 4 criterion). + +10 clients (10 different users, one thread each) send 10 messages each into one +chat at the same moment. Then the whole history is read page by page through +the cursor. PASS requires: 100 confirmed writes, exactly 100 unique messages, +nothing lost, strict (created_at, id) order and per-client order preserved. + + python student-tests/http_concurrency.py --base-url http://127.0.0.1:8080 \ + --output evidence/concurrency.json + +Standard library only (Python 3.9+). Creates synthetic users; run on a lab stand. +""" +from __future__ import annotations + +import argparse +import json +import sys +import threading +import time +import urllib.error +import urllib.request +import uuid +from pathlib import Path + + +def call(base: str, method: str, path: str, body=None, user_id=None, expected=200): + data = None if body is None else json.dumps(body, ensure_ascii=False).encode("utf-8") + headers = {"Accept": "application/json"} + if data is not None: + headers["Content-Type"] = "application/json" + if user_id: + headers["X-User-Id"] = user_id + request = urllib.request.Request(base + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(request, timeout=10) as response: + status, payload = response.status, response.read() + except urllib.error.HTTPError as error: + status, payload = error.code, error.read() + if status != expected: + raise AssertionError(f"{method} {path.split('?')[0]}: expected {expected}, got {status}") + return json.loads(payload) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--base-url", default="http://127.0.0.1:8080") + parser.add_argument("--clients", type=int, default=10) + parser.add_argument("--messages", type=int, default=10, help="messages per client") + parser.add_argument("--page-limit", type=int, default=7, help="small limit => many cursor pages") + parser.add_argument("--output", default=None, help="optional JSON summary (no secrets inside)") + args = parser.parse_args() + base = args.base_url.rstrip("/") + total = args.clients * args.messages + + run = uuid.uuid4().hex[:8] + users = [call(base, "POST", "/api/v1/users", {"username": f"race_{run}_{i}", "display_name": f"Клиент {i}"}, expected=201) + for i in range(args.clients)] + chat = call(base, "POST", "/api/v1/chats", {"title": f"race {run}", "member_ids": [u["id"] for u in users]}, + user_id=users[0]["id"], expected=201) + + barrier = threading.Barrier(args.clients) + confirmed: list[dict] = [] + errors: list[str] = [] + lock = threading.Lock() + + def client(index: int) -> None: + barrier.wait() # all clients start sending at the same moment + for j in range(args.messages): + try: + message = call(base, "POST", f"/api/v1/chats/{chat['id']}/messages", + {"text": f"c{index}-m{j} 🧵"}, user_id=users[index]["id"], expected=201) + with lock: + confirmed.append(message) + except Exception as exc: # noqa: BLE001 - reported below + with lock: + errors.append(f"client {index}: {exc}") + + started = time.monotonic() + threads = [threading.Thread(target=client, args=(i,)) for i in range(args.clients)] + for t in threads: + t.start() + for t in threads: + t.join() + elapsed = time.monotonic() - started + + history, pages, cursor = [], 0, None + while True: + query = f"?limit={args.page_limit}" + (f"&cursor={cursor}" if cursor else "") + page = call(base, "GET", f"/api/v1/chats/{chat['id']}/messages{query}", user_id=users[-1]["id"]) + pages += 1 + history.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None or len(history) > 10 * total: + break + + ids = [m["id"] for m in history] + keys = [(m["created_at"], uuid.UUID(m["id"]).int) for m in history] + per_client_ok = all( + [m["text"] for m in history if m["sender_id"] == u["id"]] == [f"c{i}-m{j} 🧵" for j in range(args.messages)] + for i, u in enumerate(users) + ) + checks = { + "all_writes_confirmed_201": len(confirmed) == total and not errors, + "history_count_equals_sent": len(history) == total, + "ids_unique": len(set(ids)) == len(ids), + "no_confirmed_message_lost": {m["id"] for m in confirmed} <= set(ids), + "strict_created_at_id_order": all(a < b for a, b in zip(keys, keys[1:])), + "per_client_order_preserved": per_client_ok, + } + summary = { + "clients": args.clients, + "messages_per_client": args.messages, + "sent": total, + "confirmed_201": len(confirmed), + "errors": errors[:5], + "history_items": len(history), + "unique_ids": len(set(ids)), + "pages_read": pages, + "page_limit": args.page_limit, + "write_phase_seconds": round(elapsed, 3), + "checks": checks, + "result": "PASS" if all(checks.values()) else "FAIL", + } + text = json.dumps(summary, ensure_ascii=False, indent=2) + print(text) + if args.output: + Path(args.output).parent.mkdir(parents=True, exist_ok=True) + Path(args.output).write_text(text + "\n", encoding="utf-8") + return 0 if summary["result"] == "PASS" else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/student-tests/test_chats_and_messages.py b/student-tests/test_chats_and_messages.py new file mode 100644 index 00000000..83e36dbd --- /dev/null +++ b/student-tests/test_chats_and_messages.py @@ -0,0 +1,219 @@ +"""Chats, membership (foreign chat -> 404), messages and keyset pagination.""" +from __future__ import annotations + +import uuid + +import pytest + + +def key(item: dict) -> tuple[str, int]: + # Fixed-width RFC 3339 strings compare like timestamps; ids compare as UUID integers. + return item["created_at"], uuid.UUID(item["id"]).int + + +# ---------------------------------------------------------------- chats +def test_create_chat_and_read_it(api): + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob, title="Проект по ВНП 🚀") + assert chat["member_ids"] == [alice["id"], bob["id"]] + assert chat["title"] == "Проект по ВНП 🚀" + assert api.call("GET", f"/api/v1/chats/{chat['id']}", 200, user=bob, schema="Chat").json() == chat + + +@pytest.mark.parametrize("case", ["duplicate", "unknown", "without_caller", "empty", "too_many", "not_uuid", "blank_title", "long_title", "extra_field", "ids_not_list"]) +def test_invalid_chat_is_400(api, case): + alice, bob = api.user("alice"), api.user("bob") + body = {"title": "Чат", "member_ids": [alice["id"], bob["id"]]} + if case == "duplicate": + body["member_ids"] = [alice["id"], bob["id"], bob["id"].upper()] + elif case == "unknown": + body["member_ids"] = [alice["id"], str(uuid.uuid4())] + elif case == "without_caller": + body["member_ids"] = [bob["id"]] + elif case == "empty": + body["member_ids"] = [] + elif case == "too_many": + body["member_ids"] = [alice["id"]] + [str(uuid.uuid4()) for _ in range(100)] + elif case == "not_uuid": + body["member_ids"] = [alice["id"], "bob"] + elif case == "blank_title": + body["title"] = " " + elif case == "long_title": + body["title"] = "т" * 101 + elif case == "extra_field": + body["owner_id"] = alice["id"] + elif case == "ids_not_list": + body["member_ids"] = alice["id"] + api.call("POST", "/api/v1/chats", 400, user=alice, json_body=body) + + +def test_chat_with_only_the_caller_is_allowed(api): + alice = api.user("alice") + assert api.chat(alice)["member_ids"] == [alice["id"]] + + +def test_chat_list_contains_only_own_chats_in_order(api): + alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve") + created = [api.chat(alice, bob, title=f"Чат {i}") for i in range(5)] + api.chat(eve, title="Чат Евы") + listed = api.call("GET", "/api/v1/chats?limit=100", 200, user=bob, schema="ChatPage").json() + assert listed == {"items": created, "next_cursor": None} + assert api.call("GET", "/api/v1/chats", 200, user=eve).json()["items"][0]["title"] == "Чат Евы" + assert len(api.call("GET", "/api/v1/chats", 200, user=eve).json()["items"]) == 1 + + +def test_chat_list_pagination(api): + alice = api.user("alice") + created = [api.chat(alice, title=f"Чат {i}") for i in range(5)] + first = api.call("GET", "/api/v1/chats?limit=2", 200, user=alice).json() + second = api.call("GET", f"/api/v1/chats?limit=2&cursor={first['next_cursor']}", 200, user=alice).json() + third = api.call("GET", f"/api/v1/chats?limit=2&cursor={second['next_cursor']}", 200, user=alice).json() + assert first["items"] + second["items"] + third["items"] == created + assert third["next_cursor"] is None + + +def test_chat_cursor_of_another_user_is_400(api): + alice, bob = api.user("alice"), api.user("bob") + for i in range(3): + api.chat(alice, bob, title=f"Чат {i}") + cursor = api.call("GET", "/api/v1/chats?limit=1", 200, user=alice).json()["next_cursor"] + api.call("GET", f"/api/v1/chats?limit=1&cursor={cursor}", 400, user=bob) + + +# ------------------------------------------------------ foreign chat -> 404 +def test_foreign_chat_is_indistinguishable_from_missing_chat(api): + alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve") + chat = api.chat(alice, bob) + api.send(alice, chat, "секрет") + missing = str(uuid.uuid4()) + for chat_id in (chat["id"], missing): + base = f"/api/v1/chats/{chat_id}" + errors = [ + api.call("GET", base, 404, user=eve).json(), + api.call("GET", base + "/messages", 404, user=eve).json(), + api.call("POST", base + "/messages", 404, user=eve, json_body={"text": "чужое"}).json(), + # Even an invalid body or cursor does not reveal that the chat exists. + api.call("POST", base + "/messages", 404, user=eve, json_body={"text": ""}).json(), + api.call("GET", base + "/messages?cursor=garbage", 404, user=eve).json(), + ] + assert all(e["error"]["code"] == "not_found" for e in errors) + assert all(e["error"]["message"] == errors[0]["error"]["message"] for e in errors) + + +def test_invalid_chat_id_is_400_after_authentication(api): + alice = api.user("alice") + api.call("GET", "/api/v1/chats/not-a-uuid", 401) + api.call("GET", "/api/v1/chats/not-a-uuid", 400, user=alice) + api.call("GET", "/api/v1/chats/not-a-uuid/messages", 400, user=alice) + + +# -------------------------------------------------------------- messages +def test_message_sender_is_derived_from_identity(api): + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob) + first = api.send(alice, chat, "Привет, Боб! 👋") + second = api.send(bob, chat, "Привет, Алиса") + assert (first["sender_id"], second["sender_id"]) == (alice["id"], bob["id"]) + assert first["chat_id"] == second["chat_id"] == chat["id"] + assert first["text"] == "Привет, Боб! 👋" + assert key(first) < key(second) + + +@pytest.mark.parametrize("body", [ + {"text": ""}, + {"text": " \n\t "}, + {"text": "я" * 4001}, + {"text": None}, + {"text": 42}, + {}, + {"text": "ok", "sender_id": str(uuid.uuid4())}, # sender cannot be chosen by the client + {"text": "ok", "attachment_ids": []}, # attachments appear only in lab4 +]) +def test_invalid_message_is_400(api, body): + alice = api.user("alice") + chat = api.chat(alice) + error = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, user=alice, json_body=body).json() + assert error["error"]["code"] == "invalid_request" + assert api.call("GET", f"/api/v1/chats/{chat['id']}/messages", 200, user=alice).json()["items"] == [] + + +def test_message_limit_is_4000_code_points(api): + alice = api.user("alice") + chat = api.chat(alice) + text = "🙂" * 4000 # 4000 code points, 16000 UTF-8 bytes + assert api.send(alice, chat, text)["text"] == text + assert api.send(alice, chat, " отступы и\nпереносы сохраняются ")["text"] == " отступы и\nпереносы сохраняются " + + +# ------------------------------------------------------------ pagination +def test_history_walks_several_pages_without_loss_or_duplicates(api): + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob) + sent = [api.send(alice if i % 2 else bob, chat, f"сообщение {i}") for i in range(25)] + items, pages = api.history(bob, chat, limit=7) + assert pages == 4 # 7 + 7 + 7 + 4 + assert items == sent # same order, nothing lost or repeated + assert items == sorted(items, key=key) + assert len({m["id"] for m in items}) == 25 + + +def test_limit_may_change_between_pages_and_default_is_50(api): + alice = api.user("alice") + chat = api.chat(alice) + sent = [api.send(alice, chat, f"m{i}") for i in range(60)] + base = f"/api/v1/chats/{chat['id']}/messages" + first = api.call("GET", base, 200, user=alice).json() + assert len(first["items"]) == 50 and first["next_cursor"] + rest = api.call("GET", f"{base}?limit=100&cursor={first['next_cursor']}", 200, user=alice).json() + assert first["items"] + rest["items"] == sent and rest["next_cursor"] is None + + +def test_exact_page_boundary_has_null_cursor(api): + alice = api.user("alice") + chat = api.chat(alice) + for i in range(3): + api.send(alice, chat, f"m{i}") + page = api.call("GET", f"/api/v1/chats/{chat['id']}/messages?limit=3", 200, user=alice).json() + assert len(page["items"]) == 3 and page["next_cursor"] is None + + +def test_new_message_after_last_page_is_reachable_from_cursor(api): + alice = api.user("alice") + chat = api.chat(alice) + api.send(alice, chat, "m0") + api.send(alice, chat, "m1") + base = f"/api/v1/chats/{chat['id']}/messages" + page = api.call("GET", f"{base}?limit=1", 200, user=alice).json() + newer = api.send(alice, chat, "m2") + tail = api.call("GET", f"{base}?limit=10&cursor={page['next_cursor']}", 200, user=alice).json() + assert [m["text"] for m in tail["items"]] == ["m1", "m2"] and tail["items"][-1] == newer + + +@pytest.mark.parametrize("query", ["limit=0", "limit=101", "limit=-1", "limit=abc", "limit=1.5", "limit=", "limit=%D9%A3", + "limit=1&limit=2", "cursor=", "cursor=garbage", "cursor=%%%", "cursor=djF8bXx4fDF8Mg"]) +def test_invalid_limit_or_cursor_is_400(api, query): + alice = api.user("alice") + chat = api.chat(alice) + api.send(alice, chat, "m") + api.call("GET", f"/api/v1/chats/{chat['id']}/messages?{query}", 400, user=alice) + + +def test_cursor_from_another_chat_is_400(api): + alice = api.user("alice") + chat_a, chat_b = api.chat(alice, title="A"), api.chat(alice, title="B") + for chat in (chat_a, chat_b): + api.send(alice, chat, "1") + api.send(alice, chat, "2") + cursor = api.call("GET", f"/api/v1/chats/{chat_a['id']}/messages?limit=1", 200, user=alice).json()["next_cursor"] + api.call("GET", f"/api/v1/chats/{chat_b['id']}/messages?cursor={cursor}", 400, user=alice) + # A cursor of the chat list is not a message cursor either. + api.chat(alice, title="C") + chats_cursor = api.call("GET", "/api/v1/chats?limit=1", 200, user=alice).json()["next_cursor"] + api.call("GET", f"/api/v1/chats/{chat_a['id']}/messages?cursor={chats_cursor}", 400, user=alice) + + +def test_invalid_cursor_is_400_even_for_empty_history(api): + alice = api.user("alice") + chat = api.chat(alice) # no messages at all + api.call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor=garbage", 400, user=alice) + api.call("GET", "/api/v1/chats?cursor=garbage", 400, user=api.user("bob")) # user without chats diff --git a/student-tests/test_store_concurrency.py b/student-tests/test_store_concurrency.py new file mode 100644 index 00000000..5b80795c --- /dev/null +++ b/student-tests/test_store_concurrency.py @@ -0,0 +1,131 @@ +"""Race protection of the in-memory store with real OS threads. + +The HTTP server itself runs on one event loop; these tests hit the Store from +10 threads at once to prove the lock and the "timestamp under the lock" rule: +no lost/duplicated messages AND the history order equals (created_at, id). +""" +from __future__ import annotations + +import sys +import threading + +import pytest + +from messenger.errors import Conflict +from messenger.store import Store + +CLIENTS = 10 +PER_CLIENT = 10 + + +@pytest.fixture(autouse=True) +def frequent_thread_switches(): + """Force the interpreter to switch threads every 0.1 ms instead of every 5 ms. + + Without this the GIL rarely interrupts a short critical section and a race + such as "timestamp taken before the lock" would + pass unnoticed. With it the broken variant fails reliably. + """ + previous = sys.getswitchinterval() + sys.setswitchinterval(1e-4) + yield + sys.setswitchinterval(previous) + + +def run_concurrently(workers: int, target) -> list: + barrier = threading.Barrier(workers) + results: list = [None] * workers + errors: list[BaseException] = [] + + def body(index: int) -> None: + barrier.wait() # release all threads at the same moment + try: + results[index] = target(index) + except BaseException as exc: # noqa: BLE001 - collected and re-raised in the test + errors.append(exc) + + threads = [threading.Thread(target=body, args=(i,)) for i in range(workers)] + for t in threads: + t.start() + for t in threads: + t.join() + if errors: + raise errors[0] + return results + + +def walk(store: Store, user_id: str, chat_id: str, limit: int, max_items: int = 1000) -> list: + """Cursor traversal like a client does it. If the stored order were broken, + a cursor could point back to an already returned page and the walk would + never end, so the number of returned items is bounded.""" + items, after = [], None + while True: + page, has_more = store.list_messages(user_id, chat_id, after, limit) + items.extend(page) + assert len(items) <= max_items, "cursor traversal repeats messages (order is broken)" + if not has_more: + return items + after = page[-1].key + + +@pytest.mark.parametrize("round_", range(20)) +def test_100_messages_from_10_clients_are_unique_and_ordered(round_): + store = Store() + users = [store.create_user(f"client_{i}", f"Клиент {i}") for i in range(CLIENTS)] + chat = store.create_chat(users[0].id, "Нагрузка", [u.id for u in users]) + + def client(index: int): + return [store.add_message(users[index].id, chat.id, f"c{index}-m{j}") for j in range(PER_CLIENT)] + + confirmed = [m for batch in run_concurrently(CLIENTS, client) for m in batch] + history = walk(store, users[3].id, chat.id, limit=7) # multi-page cursor traversal + + # Compact messages on purpose: pytest's diff of 100 dataclasses is slow and unreadable. + assert len(confirmed) == 100, f"confirmed {len(confirmed)} writes" + ids = [m.id for m in history] + assert len(ids) == 100, f"history has {len(ids)} messages" + assert set(ids) == {m.id for m in confirmed}, "a confirmed message is missing" + assert len(set(ids)) == 100, "duplicated message in history" + keys = [m.key for m in history] + inversions = sum(1 for a, b in zip(keys, keys[1:]) if not a < b) + assert inversions == 0, f"{inversions} neighbours violate strict (created_at, id) order" + for i in range(CLIENTS): + own = [m.text for m in history if m.sender_id == users[i].id] + assert own == [f"c{i}-m{j}" for j in range(PER_CLIENT)], f"client {i} order changed" + + +def test_timestamps_increase_even_if_wall_clock_goes_back(): + ticks = iter([5_000_000_000, 4_000_000_000, 4_000_000_000, 1_000_000_000] + [0] * 10) + store = Store(clock_ns=lambda: next(ticks)) + user = store.create_user("clock_user", "Часы") + chat = store.create_chat(user.id, "Часы", [user.id]) + messages = [store.add_message(user.id, chat.id, str(i)) for i in range(5)] + stamps = [user.ts, chat.ts, *(m.ts for m in messages)] + assert stamps == sorted(stamps) and len(set(stamps)) == len(stamps) + assert [m.created_at for m in messages] == sorted(m.created_at for m in messages) + + +def test_concurrent_registration_of_same_username_creates_one_user(): + store = Store() + + def register(_index: int): + try: + return store.create_user("same_name", "Гонка") + except Conflict: + return None + + created = [u for u in run_concurrently(20, register) if u is not None] + assert len(created) == 1 + assert store.counts()["users"] == 1 + + +def test_concurrent_chat_creation_keeps_indexes_consistent(): + store = Store() + users = [store.create_user(f"member_{i}", "Участник") for i in range(CLIENTS)] + ids = [u.id for u in users] + chats = run_concurrently(CLIENTS, lambda i: store.create_chat(ids[i], f"Чат {i}", ids)) + for user in users: + listed, has_more = store.list_chats(user.id, None, 100) + assert not has_more + assert {c.id for c in listed} == {c.id for c in chats} + assert [c.key for c in listed] == sorted(c.key for c in listed) diff --git a/student-tests/test_users_and_errors.py b/student-tests/test_users_and_errors.py new file mode 100644 index 00000000..b1550ba9 --- /dev/null +++ b/student-tests/test_users_and_errors.py @@ -0,0 +1,139 @@ +"""Registration, identification (X-User-Id), strict JSON validation and the error format.""" +from __future__ import annotations + +import datetime as dt +import uuid + +import pytest + + +def test_health_endpoints(api): + assert api.call("GET", "/health/live", 200, schema="Health").json() == {"status": "ok"} + assert api.call("GET", "/health/ready", 200, schema="Health").json() == {"status": "ok"} + + +def test_readiness_is_503_while_draining(api, app): + app.state.draining = True + body = api.call("GET", "/health/ready", 503).json() + assert body["error"]["code"] == "unavailable" + assert api.call("GET", "/health/live", 200).json() == {"status": "ok"} + + +def test_register_returns_user_with_server_fields_and_unicode(api): + user = api.user("alice", display_name="Алиса 👩‍💻 Ωμέγα") + assert user["display_name"] == "Алиса 👩‍💻 Ωμέγα" + assert uuid.UUID(user["id"]).version == 4 + assert user["created_at"].endswith("Z") + dt.datetime.fromisoformat(user["created_at"].replace("Z", "+00:00")) + assert set(user) == {"id", "username", "display_name", "created_at"} + + +def test_duplicate_username_is_409(api): + body = {"username": "dup_" + uuid.uuid4().hex[:8], "display_name": "Первый"} + api.call("POST", "/api/v1/users", 201, json_body=body) + error = api.call("POST", "/api/v1/users", 409, json_body={**body, "display_name": "Второй"}).json() + assert error["error"]["code"] == "conflict" + + +def test_display_name_limit_is_in_code_points(api): + api.call("POST", "/api/v1/users", 201, json_body={"username": "emoji_ok", "display_name": "😀" * 100}) + api.call("POST", "/api/v1/users", 400, json_body={"username": "emoji_bad", "display_name": "😀" * 101}) + + +@pytest.mark.parametrize("raw", [ + b"{", # malformed JSON + b"", # empty body + b"[]", # not an object + b'"alice"', + b"null", + b'{"username": "abc_def", "display_name": NaN}', # NaN is not JSON + b'{"username": "abc_def", "display_name": "\xff\xfe"}', # invalid UTF-8 + b'{"username": "abc_def", "display_name": "\\ud800"}', # lone surrogate + b'{"username": "abc_def", "display_name": "x"}{"a": 1}', # two objects glued together +]) +def test_malformed_json_is_400(api, raw): + error = api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"}).json() + assert error["error"]["code"] == "invalid_request" + + +@pytest.mark.parametrize("body", [ + {"username": "abc_def"}, # missing field + {"username": "abc_def", "display_name": "x", "extra": 1}, # unknown field + {"username": "abc_def", "display_name": "x", "password": "p"}, # lab2 field is not accepted yet + {"username": 123, "display_name": "x"}, # wrong type + {"username": "abc_def", "display_name": None}, + {"username": "abc_def", "display_name": ["x"]}, + {"username": "abc_def", "display_name": ""}, + {"username": "abc_def", "display_name": " \t\n "}, # only whitespace + {"username": "ab", "display_name": "x"}, # too short + {"username": "a" * 33, "display_name": "x"}, # too long + {"username": "Alice", "display_name": "x"}, # upper case + {"username": "алиса", "display_name": "x"}, # non-ASCII + {"username": "abc-def", "display_name": "x"}, + {"username": "abc_def\n", "display_name": "x"}, # `$` trap in regex +]) +def test_invalid_user_fields_are_400(api, body): + api.call("POST", "/api/v1/users", 400, json_body=body) + + +@pytest.mark.parametrize("content_type", ["text/plain", "application/x-www-form-urlencoded", "application/json; charset=latin-1"]) +def test_wrong_content_type_is_400(api, content_type): + raw = b'{"username": "abc_def", "display_name": "x"}' + api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": content_type}) + + +def test_json_with_utf8_charset_is_accepted(api): + raw = '{"username": "charset_ok", "display_name": "Юникод"}'.encode() + api.call("POST", "/api/v1/users", 201, raw=raw, headers={"Content-Type": "application/json; charset=UTF-8"}) + + +def test_oversized_body_is_413(api): + body = {"username": "big_body", "display_name": "x" * 70_000} + assert api.call("POST", "/api/v1/users", 413, json_body=body).json()["error"]["code"] == "payload_too_large" + + +@pytest.mark.parametrize("header", [None, "", "not-a-uuid", str(uuid.uuid4()), "11111111-1111-4111-8111-11111111111"]) +def test_missing_or_unknown_identity_is_401(api, header): + headers = {} if header is None else {"X-User-Id": header} + for method, path in [("GET", "/api/v1/users/me"), ("GET", "/api/v1/chats"), ("GET", f"/api/v1/chats/{uuid.uuid4()}")]: + error = api.call(method, path, 401, headers=headers).json() + assert error["error"]["code"] == "unauthorized" + + +def test_me_returns_selected_user(api): + alice, bob = api.user("alice"), api.user("bob") + assert api.call("GET", "/api/v1/users/me", 200, user=alice, schema="User").json() == alice + assert api.call("GET", "/api/v1/users/me", 200, user=bob).json() == bob + upper = api.call("GET", "/api/v1/users/me", 200, headers={"X-User-Id": alice["id"].upper()}).json() + assert upper == alice + + +def test_unknown_route_and_method_use_error_format(api): + assert api.call("GET", "/api/v1/nope", 404).json()["error"]["code"] == "not_found" + api.call("DELETE", "/api/v1/users", 405) + + +def test_request_id_is_unique_and_propagated(api): + first = api.call("GET", "/health/live", 200).headers["x-request-id"] + second = api.call("GET", "/health/live", 200).headers["x-request-id"] + assert first != second + assert api.call("GET", "/health/live", 200, headers={"X-Request-Id": "trace-42"}).headers["x-request-id"] == "trace-42" + + +def test_unexpected_exception_is_500_without_details(api, app, monkeypatch): + def boom(*_args, **_kwargs): + raise RuntimeError("secret internal detail") + + monkeypatch.setattr(app.state.store, "get_user", boom) + response = api.call("GET", "/api/v1/users/me", 500, headers={"X-User-Id": str(uuid.uuid4())}) + assert response.json()["error"]["code"] == "internal_error" + assert "secret" not in response.text + + +def test_swagger_ui_and_contract_are_served(api): + page = api.call("GET", "/docs", 200) + assert "swagger-ui" in page.text + spec = api.call("GET", "/openapi.json", 200).json() + assert spec["info"]["title"].startswith("MTUSI Messenger") + assert spec["servers"] == [{"url": "/", "description": "этот сервер"}] + assert "/api/v1/chats/{chat_id}/messages" in spec["paths"] -- 2.54.0 From 01524165dd9b2d91d6ded40413ca3933247dddc4 Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Mon, 12 Oct 2026 19:24:11 +0300 Subject: [PATCH 2/7] =?UTF-8?q?feat:=20PostgreSQL,=20Bearer-=D1=81=D0=B5?= =?UTF-8?q?=D1=81=D1=81=D0=B8=D0=B8=20(Valkey/PostgreSQL),=20Argon2id,=20?= =?UTF-8?q?=D0=BC=D0=B8=D0=B3=D1=80=D0=B0=D1=86=D0=B8=D0=B8,=20compose?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - схема и миграции (migrations/0001_init.sql, python -m messenger.migrate); - регистрация с паролем (Argon2id), вход по Basic, opaque Bearer, logout, expiry; - сессии: SESSION_STORE=valkey (AOF, appendfsync always) или postgres; - пул соединений, statement/lock timeout и клиентский дедлайн: отказ БД = 503; - keyset-пагинация по индексу (chat_id, created_at, id), два запроса без OR; - compose.yaml с закреплёнными образами, secrets, restart.sh. Co-Authored-By: Claude Opus 5.5 --- .dockerignore | 12 + .env.example | 14 +- .gitattributes | 2 + .gitignore | 1 + Dockerfile | 15 +- compose.yaml | 108 +++++++++ docs/DATA_MODEL.md | 41 ++++ infra/valkey/valkey.conf | 17 ++ migrations/0001_init.sql | 65 ++++++ requirements.in | 16 +- requirements.txt | 452 ++++++++++++++++++++++++++++++++++++ scripts/init_secrets.py | 47 ++++ scripts/restart.cmd | 6 + scripts/restart.sh | 15 ++ src/messenger/__main__.py | 9 +- src/messenger/app.py | 141 +++++++---- src/messenger/authhdr.py | 48 ++++ src/messenger/config.py | 57 ++++- src/messenger/cursor.py | 5 + src/messenger/db.py | 109 +++++++++ src/messenger/errors.py | 19 +- src/messenger/migrate.py | 76 ++++++ src/messenger/passwords.py | 53 +++++ src/messenger/repo.py | 244 +++++++++++++++++++ src/messenger/sessions.py | 160 +++++++++++++ src/messenger/store.py | 191 --------------- src/messenger/timefmt.py | 22 ++ src/messenger/validation.py | 14 ++ 28 files changed, 1710 insertions(+), 249 deletions(-) create mode 100644 compose.yaml create mode 100644 docs/DATA_MODEL.md create mode 100644 infra/valkey/valkey.conf create mode 100644 migrations/0001_init.sql create mode 100644 requirements.txt create mode 100755 scripts/init_secrets.py create mode 100644 scripts/restart.cmd create mode 100755 scripts/restart.sh create mode 100644 src/messenger/authhdr.py create mode 100644 src/messenger/db.py create mode 100644 src/messenger/migrate.py create mode 100644 src/messenger/passwords.py create mode 100644 src/messenger/repo.py create mode 100644 src/messenger/sessions.py delete mode 100644 src/messenger/store.py create mode 100644 src/messenger/timefmt.py diff --git a/.dockerignore b/.dockerignore index bc16e556..ff084d9a 100644 --- a/.dockerignore +++ b/.dockerignore @@ -18,3 +18,15 @@ __pycache__ node_modules evidence .DS_Store +# Not needed in the image (only requirements.txt, src/, migrations/ and the contract are copied) +.pytest_cache +student-tests +bench +tests +contracts/* +!contracts/openapi.json +examples +scripts +infra +docs +*.md diff --git a/.env.example b/.env.example index 714c8076..c84d3545 100644 --- a/.env.example +++ b/.env.example @@ -5,7 +5,19 @@ APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. +# The files are created by `python scripts/init_secrets.py` and mounted by compose as secrets. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +# valkey = sessions live only in Valkey (AOF, appendfsync always); postgres = table `sessions`. +SESSION_STORE=valkey CACHE_URL_FILE=/run/secrets/cache_url +# Additional settings of this implementation (defaults shown; all optional): +LOG_LEVEL=info +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_TIMEOUT_SECONDS=3 +CACHE_TIMEOUT_SECONDS=0.5 +PASSWORD_HASH_CONCURRENCY=2 +DOCS_ENABLED=true +# Host port of the API (compose publishes it on 127.0.0.1 only) +APP_PUBLISH_PORT=8080 diff --git a/.gitattributes b/.gitattributes index fe0e8601..3c10fe54 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,3 +1,5 @@ # LF everywhere: identical files on Windows/Linux and inside `git archive | docker build -`. * text=auto eol=lf *.png binary +# cmd.exe expects CRLF in batch files. +*.cmd text eol=crlf diff --git a/.gitignore b/.gitignore index b5a71896..ed8abe81 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,4 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. +.pytest_cache/ diff --git a/Dockerfile b/Dockerfile index 026e6831..470f37a6 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,10 +1,10 @@ # syntax=docker/dockerfile:1 -# In-memory messenger, lab 1. Build: docker build -t mtusi-messenger:lab1 . +# Messenger API, lab 2 (PostgreSQL + Valkey). Built by compose.yaml (services api, migrate). # # Python is interpreted, so there is no separate compile stage; the image # contains only the interpreter, locked dependencies and the source code. -# Base image is pinned by version AND digest (python 3.13.15, Debian 12 bookworm). -FROM python:3.13.15-slim-bookworm@sha256:2325bb286ec344af3e5898cc224b5844e2707ac6e26b1632516fd3edc84a5e26 +# Base image is pinned by version AND digest (python 3.13.16, Debian 12 bookworm). +FROM python:3.13.16-slim-bookworm@sha256:a1165e272e578941b84abc79e4ab38a0305cd12803a5c4247979ac7655f4d641 ENV PYTHONDONTWRITEBYTECODE=1 \ PYTHONUNBUFFERED=1 \ @@ -25,17 +25,22 @@ RUN groupadd --system --gid 10001 app \ && useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app COPY src/ ./src/ +# Versioned SQL migrations, applied by `python -m messenger.migrate` (compose service migrate). +COPY migrations/ ./migrations/ # Course contract, served read-only at /openapi.json for Swagger UI (/docs). COPY contracts/openapi.json ./contracts/openapi.json -# Defaults make `docker run` work without an .env file; --env-file overrides them. +# Non-secret defaults; compose.yaml passes the rest. Passwords come only as files +# (DATABASE_URL_FILE / CACHE_URL_FILE -> Docker secrets), never as ENV or COPY. ENV PYTHONPATH=/app/src \ APP_HOST=0.0.0.0 \ APP_PORT=8080 \ APP_ENV=lab \ LOG_LEVEL=info \ SHUTDOWN_TIMEOUT_SECONDS=8 \ - DOCS_ENABLED=true + DOCS_ENABLED=true \ + SESSION_TTL_SECONDS=3600 \ + DATABASE_URL_FILE=/run/secrets/database_url USER app:app EXPOSE 8080 diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..1f76ebe6 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,108 @@ +# Lab 2 stand: API + PostgreSQL + Valkey. Start from a clean clone: +# python scripts/init_secrets.py # once: random local credentials into ./secrets (git-ignored) +# cp .env.example .env # optional overrides +# docker compose up -d --build --wait +# Images are pinned by version AND digest. Passwords are passed only as secret files. +name: mtusi-lab2 + +x-api-env: &api-env + APP_ENV: ${APP_ENV:-lab} + LOG_LEVEL: ${LOG_LEVEL:-info} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-valkey} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + DB_POOL_MIN: ${DB_POOL_MIN:-1} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_TIMEOUT_SECONDS: ${DB_TIMEOUT_SECONDS:-3} + CACHE_TIMEOUT_SECONDS: ${CACHE_TIMEOUT_SECONDS:-0.5} + PASSWORD_HASH_CONCURRENCY: ${PASSWORD_HASH_CONCURRENCY:-2} + DOCS_ENABLED: ${DOCS_ENABLED:-true} + +services: + postgres: + image: postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: + - pgdata:/var/lib/postgresql # PostgreSQL 18 image keeps PGDATA under this path + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger -q"] + interval: 2s + timeout: 3s + retries: 30 + start_period: 10s + stop_grace_period: 30s # clean shutdown checkpoint instead of crash recovery + restart: unless-stopped + + valkey: + image: valkey/valkey:8.1.3-bookworm@sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571 + # The password goes into a config include readable only by the valkey user, + # so it never appears in the process arguments. docker-entrypoint.sh drops root. + command: + - sh + - -c + - >- + umask 077 && + printf 'requirepass %s\n' "$$(cat /run/secrets/valkey_password)" > /tmp/requirepass.conf && + chown valkey /tmp/requirepass.conf && + exec docker-entrypoint.sh valkey-server /etc/valkey/valkey.conf + secrets: [valkey_password] + volumes: + - ./infra/valkey/valkey.conf:/etc/valkey/valkey.conf:ro + - valkeydata:/data + healthcheck: + test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/valkey_password)\" valkey-cli ping | grep -q PONG"] + interval: 2s + timeout: 3s + retries: 30 + start_period: 5s + restart: unless-stopped + + migrate: + build: . + image: mtusi-messenger:lab2 + command: ["python", "-m", "messenger.migrate"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: [database_url] + depends_on: + postgres: + condition: service_healthy + healthcheck: + disable: true + restart: "no" + + api: + build: . + image: mtusi-messenger:lab2 + environment: *api-env + secrets: [database_url, cache_url] + ports: + - "127.0.0.1:${APP_PUBLISH_PORT:-8080}:8080" # only on localhost of the host + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + migrate: + condition: service_completed_successfully + stop_grace_period: 10s + restart: unless-stopped + +volumes: + pgdata: + valkeydata: + +secrets: + postgres_password: + file: ./secrets/postgres_password + valkey_password: + file: ./secrets/valkey_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/docs/DATA_MODEL.md b/docs/DATA_MODEL.md new file mode 100644 index 00000000..d6d7f3bc --- /dev/null +++ b/docs/DATA_MODEL.md @@ -0,0 +1,41 @@ +# Модель данных lab2 + +Схема: [migrations/0001_init.sql](../migrations/0001_init.sql). Источник истины для пользователей, чатов, участников и сообщений — PostgreSQL 18. Для сессий источник истины — хранилище, выбранное через `SESSION_STORE`. По умолчанию это Valkey с AOF, его можно переключить на таблицу `sessions` в PostgreSQL. + +## Таблицы и ограничения + +| Таблица | Ключ | Ограничения | Зачем | +| --- | --- | --- | --- | +| `users` | `id uuid` | `UNIQUE (username)`, `CHECK` формата username, длина `display_name` | уникальность имени держит БД, а не код: гонку регистрации разрешает уникальный индекс | +| `chats` | `id uuid` | FK `created_by → users`, длина `title` | `last_message_at` — «часы» чата для упорядочивания сообщений | +| `chat_members` | `(chat_id, user_id)` | FK на `chats` и `users`, `UNIQUE (chat_id, position)` | `position` хранит порядок `member_ids`; `chat_created_at` — копия времени чата для keyset-списка чатов | +| `messages` | `id uuid` | FK `(chat_id, sender_id) → chat_members`, длина `text` | отправитель обязан быть участником — это гарантирует сама БД | +| `sessions` | `token_hash bytea` | FK `user_id → users`, длина хеша 32 байта | хранится SHA-256 токена; сам токен не хранится нигде | +| `schema_migrations` | `version` | checksum файла | какие миграции применены; изменённую задним числом миграцию мигратор не применит | + +**Почему `bytea` для текста.** Контракт разрешает символ U+0000, а тип `text` в PostgreSQL не может содержать байт NUL (`DataError`). Поэтому `display_name`, `title` и `text` хранятся как байты UTF-8. Длину в code points проверяет API, а `CHECK` в байтах — страховка (1 code point ≤ 4 байта). + +## Индексы и запросы + +- `messages_chat_keyset (chat_id, created_at, id)`. Первая страница — `WHERE chat_id=$1 ORDER BY created_at, id LIMIT n`, следующая — `WHERE chat_id=$1 AND (created_at, id) > ($2, $3) ORDER BY ... LIMIT n`. Сравнение строк `(created_at, id) > (...)` попадает в `Index Cond`: поиск начинается прямо с позиции cursor и читает только `n+1` строк. Запросов два, а не один с `($2 IS NULL OR ...)`: иначе при generic plan условие cursor уходит в `Filter`, и поздняя страница сканирует всю историю чата до неё. +- `chat_members_user_keyset (user_id, chat_created_at, chat_id)` — список чатов пользователя тем же keyset-способом. +- `users_username_key` — вход по username и уникальность. +- `sessions_expires_at` — очистка истёкших сессий. + +## Транзакционные границы + +| Операция | Транзакция | Что гарантирует | +| --- | --- | --- | +| Регистрация | один `INSERT` | `UniqueViolation` → 409; ровно одна строка при гонке | +| Создание чата | `INSERT chats` → `INSERT chat_members` (все участники одним запросом) → `COMMIT` | неизвестный участник вызывает FK-ошибку **после** вставки чата; откат удаляет и чат, и частичное членство | +| Сообщение | проверка членства → `UPDATE chats SET last_message_at = greatest(clock_timestamp(), last_message_at + 1 мкс) RETURNING` → `INSERT messages` → `COMMIT` | строка чата заблокирована до конца транзакции, поэтому писатели одного чата идут по очереди. Время сообщений строго растёт **в порядке коммитов**: страница по cursor не пропустит сообщение, закоммиченное «задним числом» | +| Вход | `SELECT` пользователя, проверка Argon2id, запись сессии | неверный пароль ничего не пишет | +| Logout | `DELETE` сессии (или `DEL` в Valkey) | повтор с тем же токеном — 401 | + +Чтение истории не требует snapshot между HTTP-запросами (так в контракте): новое сообщение появится на следующей странице. Список чатов сортируется по `chats.created_at = clock_timestamp()` без блокировки. Два чата, создаваемые одновременно, могут закоммититься не в порядке времени. Тогда у обхода, который уже начался, такой чат может оказаться «до» cursor; новый обход его увидит. Чаты создаются редко, поэтому мы не сериализуем их глобальным замком; это ограничение описано в REPORT.md. + +## Сессии + +- Токен: `secrets.token_urlsafe(32)` — 256 бит случайности, в ответе 43 символа. В хранилище лежит только SHA-256 токена. Для случайного 256-битного значения быстрого хеша достаточно, медленный KDF нужен только для низкоэнтропийных паролей. +- `SESSION_STORE=valkey` (по умолчанию): ключ `session:`, значение `{user_id, expires_at}`. Срок жизни задаётся абсолютным `PXAT expires_at`, поэтому рестарт его не продлевает. Включён `appendonly yes` + `appendfsync always`: подтверждённые вход и logout сохраняются до ответа клиенту. Valkey — **единственное** хранилище сессий, это не кэш над PostgreSQL. Поэтому нет второй копии, которая могла бы «оживить» отозванный токен после отказа. Если Valkey недоступен, проверить сессию нельзя: защищённые запросы и logout получают 503, анонимный доступ не открывается. +- `SESSION_STORE=postgres`: таблица `sessions`, проверка `expires_at > now()` в запросе. diff --git a/infra/valkey/valkey.conf b/infra/valkey/valkey.conf new file mode 100644 index 00000000..510785b2 --- /dev/null +++ b/infra/valkey/valkey.conf @@ -0,0 +1,17 @@ +# Valkey is the single store of sessions (SESSION_STORE=valkey), so it must be durable. +# AOF with fsync on every write: a confirmed login or logout survives a crash/restart, +# a logout can never be lost and "resurrect" a token. Sessions are small and rare +# writes, so the fsync cost is acceptable here (see REPORT.md). +appendonly yes +appendfsync always +appenddirname "appendonlydir" +# RDB snapshots are not needed on top of AOF. +save "" +dir /data +port 6379 +protected-mode yes +# Sessions are never evicted silently: if memory is full, writes fail and login returns 503. +maxmemory 128mb +maxmemory-policy noeviction +# Password, generated by scripts/init_secrets.py and written here at container start. +include /tmp/requirepass.conf diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..aef95c4f --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,65 @@ +-- 0001: initial schema of the messenger (lab 2). Design rationale: docs/DATA_MODEL.md +-- Applied once by `python -m messenger.migrate`; the version is recorded in schema_migrations. + +-- User-supplied free text (display_name, title, message text) is stored as UTF-8 in BYTEA: +-- the contract allows U+0000, and PostgreSQL TEXT cannot contain NUL bytes. +-- Lengths are limited in code points by the API; the CHECKs below are byte-level safety nets +-- (one code point is at most 4 bytes in UTF-8). + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name bytea NOT NULL, + password_hash text NOT NULL, -- Argon2id PHC string, never the password + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_key UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (octet_length(display_name) BETWEEN 1 AND 400) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title bytea NOT NULL, + created_by uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + -- Per-chat clock: created_at of the newest message. Updating this row serialises writers + -- of one chat, so message timestamps strictly increase in commit order (see DATA_MODEL.md). + last_message_at timestamptz, + CONSTRAINT chats_title_len CHECK (octet_length(title) BETWEEN 1 AND 400) +); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + position smallint NOT NULL, -- order of member_ids sent by the creator + chat_created_at timestamptz NOT NULL, -- copy of chats.created_at for keyset listing + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_position_key UNIQUE (chat_id, position) +); +-- GET /chats of one user: (user_id, created_at, id) range scan, no sort. +CREATE INDEX chat_members_user_keyset ON chat_members (user_id, chat_created_at, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text bytea NOT NULL, + created_at timestamptz NOT NULL, + -- The sender must be a member of this chat: enforced by the database, not only by the API. + CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id), + CONSTRAINT messages_text_len CHECK (octet_length(text) BETWEEN 1 AND 16000) +); +-- History page: WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n +-- becomes an index range scan that starts exactly at the cursor. +CREATE INDEX messages_chat_keyset ON messages (chat_id, created_at, id); + +-- Sessions for SESSION_STORE=postgres (the default store is Valkey; see docs/DATA_MODEL.md). +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, -- SHA-256 of the token; the token is not stored + user_id uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + expires_at timestamptz NOT NULL, + CONSTRAINT sessions_token_hash_len CHECK (octet_length(token_hash) = 32) +); +CREATE INDEX sessions_expires_at ON sessions (expires_at); diff --git a/requirements.in b/requirements.in index 7aa83ddf..bdaae420 100644 --- a/requirements.in +++ b/requirements.in @@ -1,8 +1,16 @@ # Direct runtime dependencies. The pinned lock with hashes is requirements.txt: -# docker run --rm -v "$PWD:/w" -w /w python:3.13.15-slim-bookworm \ -# sh -c "pip install -q pip-tools==7.6.1 && pip-compile --generate-hashes --strip-extras -o requirements.txt requirements.in" +# docker run --rm -v "$PWD:/w" -w /w python:3.13.16-slim-bookworm \ +# sh -c "pip install -q pip-tools==7.6.1 && pip-compile --generate-hashes --strip-extras --no-emit-index-url -o requirements.txt requirements.in" starlette==1.7.0 uvicorn==0.54.0 # Fast C parser/event loop used by uvicorn in the container (Linux only). -httptools==0.8.0 -uvloop==0.22.1 ; sys_platform != "win32" +httptools==0.9.0 +uvloop==0.23.0 ; sys_platform != "win32" +# PostgreSQL driver (libpq bundled in the binary wheel) and its async connection pool. +psycopg==3.3.6 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +# Valkey client (Valkey speaks the Redis protocol). +redis==8.1.0 +# Argon2id password KDF. +argon2-cffi==25.1.0 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..78a3b4a7 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,452 @@ +# +# This file is autogenerated by pip-compile with Python 3.13 +# by the following command: +# +# pip-compile --generate-hashes --no-emit-index-url --no-index --output-file=requirements.txt --strip-extras requirements.in +# +anyio==4.15.1 \ + --hash=sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101 \ + --hash=sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94 + # via starlette +argon2-cffi==25.1.0 \ + --hash=sha256:694ae5cc8a42f4c4e2bf2ca0e64e51e23a040c6a517a85074683d3959e1346c1 \ + --hash=sha256:fdc8b074db390fccb6eb4a3604ae7231f219aa669a2652e0f20e16ba513d5741 + # via -r requirements.in +argon2-cffi-bindings==26.1.0 \ + --hash=sha256:061a6919145bbf282ebf1f9c59d3135d4833c25313c8595c0d68cf7712ddfce2 \ + --hash=sha256:0cc40f7b4050bb93eb67de95d2d759322fc7ce4930b9d645581ecf4913ec651e \ + --hash=sha256:151dfaad9de753f4af2a7854e707e4784f2acc434340ade64239c5b104b2d605 \ + --hash=sha256:19423e5d7ac1cc354baab59eaabf18db2ec04ef6593b5abe5a34f323c4a8f87a \ + --hash=sha256:19b562b1de4b9052ef1214a2821c44b6e6f22945daa102c32ae4eff929d8b6d8 \ + --hash=sha256:1a0a29ed86960e44eaace7e081bdfab4f08b012fd96ec8edba71e2ad020939e4 \ + --hash=sha256:1af817e84578ef8b7295ad17de0f9896e4c8520dbf2233c7aa5aa3d487256fc4 \ + --hash=sha256:1b0bcac4d490a237e18cf91f57352920c29f77f2fa39efd0813fb81298bf17ba \ + --hash=sha256:1d98e33bd8bd67d7206c124e200bf2229c4cfa8c9c19f7b44a897f0fc71837eb \ + --hash=sha256:21ca0396fe5ec995dd54431c32698189666f9224810acfa752e50d2bd94d9df2 \ + --hash=sha256:224865cbbcb7a2bd1356741dff12b0134df726b6d44bb7b500df8e303cbd9e81 \ + --hash=sha256:242bb0cda2ae3650764fc194593d9ea45fc9e72729acd89778c7cfe184cec2a5 \ + --hash=sha256:27f1821903e2ceadcb88ec2b45ef190897b7682449c772f4d9b53e42c520cf29 \ + --hash=sha256:28524438cd3e723f25412f63d4fd516ff5bae9ae5aa56acbe2a1404398a0cf31 \ + --hash=sha256:2b741888c93147444fdfc851abd81cc207f37f7f7da42062a00deb3888e57da8 \ + --hash=sha256:2c36ff87b5dfaa477d0bd51e9d7f6abdae7c8955d2983c97419085d842154b3e \ + --hash=sha256:34b7d9c24a4165a2c61cc8ae11d44d48c9ce2830fb536cb7914e11fdd9962728 \ + --hash=sha256:49d525938467d52c923a890153c99087c9d5a937d1f6b585dbdba34ec82e397a \ + --hash=sha256:4f84cdd868978d7b7350a566c254042d44216d9e37f241f3a6d3b1dfebeede35 \ + --hash=sha256:62ff20cd130c956c7c9144d5fe35228f98b51c579b2439e988b27ef93e16c02a \ + --hash=sha256:63505c71542a44b68b1e38060450fb006404170da375feb31af153e7f9c6205d \ + --hash=sha256:6376d4b3aca039375ca8bf92f770da0ec424a1ce3a37077a8d3c557411aa56ca \ + --hash=sha256:6a4e68eed961a8de6928d1c17ff3dc2a547e0e923c17f8f1cd79fb7bc9502f98 \ + --hash=sha256:6ab674f668d5962a3a4136ae0812519b0f1586874263723a32181d60d64137e1 \ + --hash=sha256:7014ab7e6f5d8511af92544667a0346ea6dfc314ea9a7cad1dba9fdb5c9a6e33 \ + --hash=sha256:76ae29acace5d33355344612844d588e19deaaba4639d8bb01601e4b1418ef36 \ + --hash=sha256:78de2d65e0b9ea7ce9d1b1c3e87297b2d7305a02c266ee2a2d6910daddd7ee69 \ + --hash=sha256:9bacedc04b0402837586a17f0919e3dfdd95291f441f1f56bd80ec274c2840a1 \ + --hash=sha256:a86c069c91a747a2c4e5c51473590aeb48172fff9b2130d23729a42d98665ecb \ + --hash=sha256:ac82fc756a446b6ccd7139ce70efa9d8bbe541e7ad579a12dcb52764b7175c5f \ + --hash=sha256:af11ac37a7c53dc16cb7950a6190851b0870fe218b6c60c0bb7ac355234e3083 \ + --hash=sha256:b70225b5fd1e0d2ef4f7fd30d24658454535f0924dff0caca5dc08efbbbadfbb \ + --hash=sha256:c49e853a3bef9dd10329f31f702e7fa9b5c58229ff9c2ff6d069efaf09177c08 \ + --hash=sha256:ccaf0a46cbb380f1fd102a874e32aa629fd3cb0c0e94f4943fa1f6d5edc5dac6 \ + --hash=sha256:d157ddfab1e8b21f2f1dedda9c09645d98b5ed0b667b0626be600a345d426440 \ + --hash=sha256:d88e5f7e60f28ae0b0cc6b2f16c43e87cd642a196a86f85e0d8bb6fe016fc16d \ + --hash=sha256:db0fcd827ca61622a01b220aadfbece01939acf53888f2cb98cd93e9b1e2c97e \ + --hash=sha256:df612391feca41c44d20118f3b88d1b86419465cd1f5496859f715ca60ec2210 \ + --hash=sha256:f0c3103fcff20183e593459cfea6e012281c0e76ae3ed8b5565ad1b92eac3990 \ + --hash=sha256:f9c4420a7a864fe1b86ce35befc95b8e39fb852493b81cf798671ddc265de638 \ + --hash=sha256:ffff613aaa9ce6236766e2fc6dc560bb5abde7a2e2416e3db1f9ae395a2b4dd4 + # via argon2-cffi +cffi==2.1.1 \ + --hash=sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e \ + --hash=sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66 \ + --hash=sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2 \ + --hash=sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0 \ + --hash=sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6 \ + --hash=sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971 \ + --hash=sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c \ + --hash=sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d \ + --hash=sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9 \ + --hash=sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517 \ + --hash=sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735 \ + --hash=sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80 \ + --hash=sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f \ + --hash=sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1 \ + --hash=sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29 \ + --hash=sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8 \ + --hash=sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c \ + --hash=sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e \ + --hash=sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48 \ + --hash=sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813 \ + --hash=sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac \ + --hash=sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632 \ + --hash=sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6 \ + --hash=sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1 \ + --hash=sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659 \ + --hash=sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688 \ + --hash=sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004 \ + --hash=sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0 \ + --hash=sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062 \ + --hash=sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779 \ + --hash=sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94 \ + --hash=sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50 \ + --hash=sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab \ + --hash=sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac \ + --hash=sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6 \ + --hash=sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676 \ + --hash=sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1 \ + --hash=sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9 \ + --hash=sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf \ + --hash=sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13 \ + --hash=sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e \ + --hash=sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e \ + --hash=sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973 \ + --hash=sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527 \ + --hash=sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72 \ + --hash=sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890 \ + --hash=sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c \ + --hash=sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990 \ + --hash=sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd \ + --hash=sha256:75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9 \ + --hash=sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94 \ + --hash=sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3 \ + --hash=sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80 \ + --hash=sha256:7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41 \ + --hash=sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5 \ + --hash=sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c \ + --hash=sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a \ + --hash=sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4 \ + --hash=sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e \ + --hash=sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6 \ + --hash=sha256:9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98 \ + --hash=sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b \ + --hash=sha256:a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1 \ + --hash=sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03 \ + --hash=sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af \ + --hash=sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231 \ + --hash=sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2 \ + --hash=sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3 \ + --hash=sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836 \ + --hash=sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5 \ + --hash=sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399 \ + --hash=sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96 \ + --hash=sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e \ + --hash=sha256:baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be \ + --hash=sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf \ + --hash=sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc \ + --hash=sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455 \ + --hash=sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0 \ + --hash=sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12 \ + --hash=sha256:ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b \ + --hash=sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7 \ + --hash=sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692 \ + --hash=sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54 \ + --hash=sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3 \ + --hash=sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b \ + --hash=sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be \ + --hash=sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d \ + --hash=sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358 \ + --hash=sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a \ + --hash=sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7 \ + --hash=sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc \ + --hash=sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960 \ + --hash=sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125 \ + --hash=sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb \ + --hash=sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a \ + --hash=sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa \ + --hash=sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf \ + --hash=sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3 \ + --hash=sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4 \ + --hash=sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264 + # via argon2-cffi-bindings +click==8.5.0 \ + --hash=sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360 \ + --hash=sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34 + # via uvicorn +h11==0.16.0 \ + --hash=sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1 \ + --hash=sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86 + # via uvicorn +httptools==0.9.0 \ + --hash=sha256:02bc5b3dcb6394b9d825fd62a7bfa0b2943063a3c89abc4492ad45e334a20eb5 \ + --hash=sha256:050f7ab098121873c8f13e35857f97ab60a76185c8302bde9a384939bb7c3b96 \ + --hash=sha256:050f84b7ec46a6efe0e5f521cf8729e3397c1cef4384f62ed8d5d68ca0045776 \ + --hash=sha256:06bfe7fad972a417269d8a5fc53b87e4eca970354abf5e9e24336fd06d64292e \ + --hash=sha256:088de1738e1af624466a01c35d652dbe6fb825be887c76d68aa850621d81db88 \ + --hash=sha256:0adc974916efe1fbf89d0363a86dcb2c746727643e362ff398de1a4b50b6bc77 \ + --hash=sha256:0cc339a807c156d840b54f8bf050ba0fc265eb81692c24bca8535b52fbd797c6 \ + --hash=sha256:0fd73d0bbf700a30dd87e4412adf41cfa71542a533d6b390c7244bbb8a1152bb \ + --hash=sha256:130635fea6e611a6b2026120037965ddb88b3dafd11bb64e264b101a70a76630 \ + --hash=sha256:13873eb8aef5972fcfee614f63d47064312ad4efbfe65ade15b8a3b77f8c8659 \ + --hash=sha256:18d800aaa2d6bff7d889df810d1b19a5fde72b1f6c0ca96e8d9f28a692fe5460 \ + --hash=sha256:1a4050a651e1f2faf05eb028ce9f2168abbcee9e24b209f5c1f2eb96d8c569e4 \ + --hash=sha256:1a7f1df31829c258158be01bb04eb668c4fba7df1ddf2262131a972962e651b6 \ + --hash=sha256:1b01c0fcd6725a8d79a164ecdc4116866282479d68bb3d6d74a909bf994656c4 \ + --hash=sha256:1b95775f6292d72cb452c33e5c0f8b8551807c29a10e3c1671fef7f61361370a \ + --hash=sha256:1f6da814aeecbc6cb8872d6d3e85ed16e8ab1653f9557cea8658725ce212348a \ + --hash=sha256:2095207b75a83c9e947346da9c127fb7e4fb29f41589df2643764f06b750989c \ + --hash=sha256:22ab1b10b06d357f01092e60f5e6856a0d479ed79b0ec2166a339ea26c699be2 \ + --hash=sha256:2319858018eedd0c0b2f950a620413c0a9d1352607be4267eb28209eca8b1e3f \ + --hash=sha256:268d18601feb5367885c6ebf6f402c18fc25a324cee215784adafe0a1eef925f \ + --hash=sha256:26e1d9629f3bf70d23f0d22238152aec51c837a7c9e384cb74f356fdccad7eb3 \ + --hash=sha256:272db0c51e8b71e953c1f2ecbe63402b819680e4564be2ef285cfd4584ee8355 \ + --hash=sha256:289f213d2a3dde2e8312c415ffecec5a01698589ec6249ec4e8fb3b47c0444ba \ + --hash=sha256:29b0d823e3c1e7cd1093a5dc889245db693ef13ada624cd66e2262421ef38867 \ + --hash=sha256:310266a2db1377ffae3bdf6556ab4973f4f94508a8ce37b2f6bb096a89bcefa1 \ + --hash=sha256:3238e198429cb8909ec42951b82d6a33fe0fdfcf86371732f8f09311c5b8ac32 \ + --hash=sha256:34266cec8c1d4e3e91fcca7efe38971d6bdda64a7944f2a46ab576da15173680 \ + --hash=sha256:36fac804b8cfd6b935ae64f71349f833d2b6298404626d017a2c57bb942bc643 \ + --hash=sha256:3af4e45ff455fce5511fdf2653c1ce428ef09c56fe37a83eb4d924c2d474f31e \ + --hash=sha256:3e3201fe4d46e0d15d7ff9fafc94a605da9eb82d2c5b9837f0368acb325481f1 \ + --hash=sha256:45b3002392948dcf578029c89f6318e1289a993a1a5ec38a4161560fab60f811 \ + --hash=sha256:465bc1526debf53a3be92022a16ca0c38f891ea3b5c1587af4f52e44020f8a07 \ + --hash=sha256:48c705bd0b1afb6253ed71eca9f9ba7ac7d47838e5fed1ef7891d67f21ecd4de \ + --hash=sha256:4a4d8c2c7e73ba5967be74d7c3a5ff81fde815ee1b48d9c5c0f14de8463a847b \ + --hash=sha256:4a85401b0c3f893cf5695c1199e8679fbf673f7f78c2f6c11d6b1850f8c7e358 \ + --hash=sha256:4c58dc91aefb31adad500aa68054334f429b840b36dd29e34e834101044cb2ef \ + --hash=sha256:4efbee349138a3fee7a4cc3a95abd2d499fae70dd5bff9fed9138d6f570f4283 \ + --hash=sha256:4fb995082fe41ec410b33c48b54fb1d44abb8a6ee762c31e8c42519e8c3a30a9 \ + --hash=sha256:5042aa1c7e2b1a24c17dab31d8770b63a5101c9abc25f832c6aef6b201e1ca4f \ + --hash=sha256:52fe0176682a25b15370f23f5b0f1366a84771df89144fb0cd979cb72a94b5ca \ + --hash=sha256:5332a020a60bbe32ede4bda1a62b3d56c4831d309cdf0932842c0fca8ad6aaa3 \ + --hash=sha256:563e4568217dc907a91843f38c737be865222c0400a38cdcd0d26ce92b3db271 \ + --hash=sha256:581b27663c6e9f4df68068f32fe6d1cd7647b31fac90237221a66f8821c342eb \ + --hash=sha256:58a1b0ec4cbb930e69669f9771715b2c7898d3cdf064d9811f7a66afef96b544 \ + --hash=sha256:5cc5d3a29f9ec86ce406e5ec09c241dd8dc4d30e838f74f68d728b89131a3acf \ + --hash=sha256:63d38e9a9a10a20fb57593742e63c6b1e78dd7f6ef5472de8e0b1e4cf4f3db26 \ + --hash=sha256:6b1ac7f1bc6c0dbf90684b77571a51a21b2463909fd916ce0ac9bfc4d566dc75 \ + --hash=sha256:6b900073e7b8481ef1aaf4f6c1789d210a1db01a9da8789821578cfeb4c2d540 \ + --hash=sha256:6c12d0393a903b58bc5f5a7406d6c5290acfb8284290d68547ce620c06f7d133 \ + --hash=sha256:6e2780e33a58a93f27cc3bb74a55bae6f9a8278a1dbabdff392940d30d381671 \ + --hash=sha256:6ebd39ee26db460cfe5ab8b71a15d1149b289139a0d3981522757d6af620887e \ + --hash=sha256:6f8b41299b203ce8f627db670cfea82067d9638853dbeaf86dccd93878879b85 \ + --hash=sha256:6f9549ca354a1d6d6167c458a1f1b12147726b968f02dd64b6a5801dba91ae0f \ + --hash=sha256:6ff0145b34610e57c9fae20df4e133c8d54266447387de6fcc0bdabfe4db4569 \ + --hash=sha256:6ff5f0ed70783dcb9562dbd20edca51c3d4d277f128223709e3da6b75986d1d4 \ + --hash=sha256:714bf348f468532d86bed670837e7d5ddff3834dd7f5d3c08066da400c86f088 \ + --hash=sha256:757e3f79cb865a7db94e0db5f4d0ed3284a69e39d53568f433982ea13c60cac1 \ + --hash=sha256:7e32b83bd8c2f8b6fa726ef34e63e21c4d7eddc277d40d4ef7245ea3ed28e5b6 \ + --hash=sha256:805b0f2618e5d4c3e28f45b731eb1a0539691ae4a2f97b4ce014de0bf96a1ff5 \ + --hash=sha256:80eae881cfb69383303e9a4d7961a478025b89c24f38f2e69b30c516fa0d57f2 \ + --hash=sha256:813a32f94991b9627795528053c73a57d2ce3eb98ede89f0e1c7a31095938e81 \ + --hash=sha256:8463b34ebde3f000627e9dbd8a545f995ad49fbf7ff9dd5abc0cd507da98a603 \ + --hash=sha256:8a59c749a73fbdbc8e63b895a3079825fa085d752e75bc0a500042cb8a801e48 \ + --hash=sha256:8d90d10e9b6594c28f27896a68fab97fd784c43804e9fe419dab8e8dcfcf4b02 \ + --hash=sha256:8e1e037bb57dbc549c6fe20370b763ea74bdb09413cdcf857e4f14d9e4e2fb13 \ + --hash=sha256:931f45f84e15daafec5f82cc92e6710569e1f50933f3253d206eab4132bec678 \ + --hash=sha256:995b52f7c260ac7023640221f27472303968753cb6fc6fce1ddfb0e9db59a398 \ + --hash=sha256:9b4da5789d7cf576c7e81f0088c632f6ee3786d87d17f08e90e703c22ce15633 \ + --hash=sha256:a3ed60ea9a7c352c590182c67404599e6b5a0c901e75ae4cceee9a9fd6bfa455 \ + --hash=sha256:a4d1ecad62e83cc65b411ea0125972cf3af98821e8117129947fd1e3a113f8d2 \ + --hash=sha256:ae9bb62a7902e2ab65782447cd3eeb753510feace4e3ea03937a85489b01b16b \ + --hash=sha256:b2ab3aad55d75d0b8df8d8a1b5920baaec9b161112cd5e95984848b4d2cd3dfe \ + --hash=sha256:b2cc6991f16f6d666d48e4b57318104e7b29109e32e2f6b86e9d44c4e6a27f4e \ + --hash=sha256:b5a3f5f70967a1aa2bc47fec42a1e19d2fb38c61700e3ee62b63a4af4f4fd001 \ + --hash=sha256:b68fb053b37c258a473ab67f4965c3b439500dc160fe364667035a6833eaf50a \ + --hash=sha256:b6ee42112d785a913dd63ec0335435a3dddbea5040c151252db815b0095cf066 \ + --hash=sha256:b928ab0ecaa664e8caecc529dcb8bc881b6b35bb2b74bf9a39ae25f982ee8812 \ + --hash=sha256:b9430f65db521db7962ad951571d446171213686f96c998a54dc18ed574821e2 \ + --hash=sha256:b9cd15cb7cf0d5cc41f649fd789aae12c56c3b83eff593f8e095c1d4555ad5c3 \ + --hash=sha256:bb1533541c729ad422f870a780d8b4af924f9817d45b5f580390418cda72eaa2 \ + --hash=sha256:bbf7377fbd41b7c87d47820e25b9876724963681c2a1d6f6ff2adb4db46ac174 \ + --hash=sha256:bca180cbe84e4fba7807eb408a8655295f697928512324517e30a091ede522a8 \ + --hash=sha256:beb2c8a34cc90fb4d862b7284eafdb322030d6a8b2ee5eb6a744f84205beedc3 \ + --hash=sha256:bfdabac0c6d3d6a5be8c2a100a001c92c14a39bbafd5999545a675c493626e64 \ + --hash=sha256:c0e45def4d9ce7073e2226535572442d9d6efb4047c7a5fd8960807e877ce70a \ + --hash=sha256:c0f537e5e8152e8d9cae82804024790cb973061abd3b7ef8f66f46e2b5c7bb51 \ + --hash=sha256:c195a69df0ab2541252ab5b1d76e3c182e5688ac2a9b708e5e6f66aaeda91e9a \ + --hash=sha256:c271bfb832be5c5c020b4e2fcbc1e70a0b990adba6de874b0bba1184b89cdea3 \ + --hash=sha256:c42424213c28804f8d0e20f5692106cfb57bf72e1dbc4092b8481fb2f9e4c707 \ + --hash=sha256:c4fa57d3c31889722f64bfa785545a5e603a893b6f29ac1a41bfa830abeaefd5 \ + --hash=sha256:cb2bb3ac0af7fdab2311b895c9eb95442b45deb14cc949b9e65545e74aa0be69 \ + --hash=sha256:cb3e7a4fd0168e362673a980380bf4fd6ae3b1555150e60c5390b4b10d9c50c4 \ + --hash=sha256:cbbfcd5d15056fbd1edd5e725cf3feeb47c7cbccbe205927ebab422cc229f417 \ + --hash=sha256:cd3e55223a77d6e08d5730ebacb4930ecca5d2ce7c57e7ba10833be7e52903f1 \ + --hash=sha256:ce8e723b4637034b76f5382a30a6b725518c332273e8d62a6c7d46e90837c947 \ + --hash=sha256:d1e329a1866981efe0201d05a374617f6c6cf14434a501d78ab22793d1ab1fa6 \ + --hash=sha256:d20ba5c84cf0592afb2713336f07e2b6ced082e4ae803ceada153a85613efc9f \ + --hash=sha256:d2b095129b9a98eb46a271ee9631089529c4e40354576b4aa74e24de9d2bf2f7 \ + --hash=sha256:d3906b5c549ff2ad2473cb711e1fc65d76715c2726a402108fbf55eab6c6b49d \ + --hash=sha256:d484ebb7e3a3f3597b0f645fbd1b85633674ca808c1f5ba11c2caf7c66f5c8b6 \ + --hash=sha256:db735a23ecb0f0450d2b24e0a05fb00a8a35c9db172919c4d3e023e7c7ee4c9b \ + --hash=sha256:dbc9fd1521e573045d71b6afab7398439c5cc259e8cb9d416fe62d485c4899c6 \ + --hash=sha256:df3867518b205be3648e2fbd522bf380c851b5c2500588047505afdd786b6669 \ + --hash=sha256:e0acbd474d0af4afacc6e66c4273f8a19e25f8af4379fc816388095ea6b01371 \ + --hash=sha256:eacf0f45ca3ff84c01481c60c15da9ee56711f7292f66663df0f57af61e011c2 \ + --hash=sha256:ead1a40543a033a6732a9e1e515944979a19db3737ce77363fc0660e38554344 \ + --hash=sha256:eae4e9c7a0785a1a715de0a74fb822ab40084c060f444f18f075d05e322aa7ef \ + --hash=sha256:ecf7037e491c220cd73987838c1ac3958d787bb098c3be0bfaf7f04204a6162c \ + --hash=sha256:ecfeee649184ffd800955068be9a6b579a0f33fc3c98535d685d5779cb59347f \ + --hash=sha256:edd5aa045fa3cc57143db018dd32ce7962bd5b525d05230709015d7e570100aa \ + --hash=sha256:f0ef48ce353f6b6a52232ba23d0983d4c2c84c84a778899404e34b4718509bf2 \ + --hash=sha256:f1734bd6f588975ffc246211e8b96c11933344087ca280d2cbcbf35cf835d7a9 \ + --hash=sha256:f67db0ba2bedafec15b8e5330d40da1e1c7921559fa715af021252bfef81a6f8 \ + --hash=sha256:f6ac1414556b910a879c108d79736f77e797871f9919ed0d2c3cf8cf3ecca986 \ + --hash=sha256:f78f7ae1c2e5aabf29583fc0d302d8081a663776f84578025662eb6f5d63a921 \ + --hash=sha256:f9489c1d87160c126f73b004742fe8654fa1ce37ed89e9e01330a1c10aaecde4 \ + --hash=sha256:f9ccc9884241efceb4547a92955d128574c864681f11b7ea3ecbde295fafbe8b \ + --hash=sha256:fc1a4f9d18d32a6e0a0a0a382986a60a2126f5144dd08715be7adb8df18e8a46 + # via -r requirements.in +idna==3.20 \ + --hash=sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44 \ + --hash=sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c + # via anyio +psycopg==3.3.6 \ + --hash=sha256:a1db9f7148b06a28606767efaca51fa6f9398c5c0a3810519be69d7000bdb631 \ + --hash=sha256:c081f2250df751a943036e42db6df4571c66cd0aabe8291a7a506512b12007d2 + # via -r requirements.in +psycopg-binary==3.3.6 \ + --hash=sha256:05a83ac9fd52b9bca7cb5ab04b3691163170bd16f53defa27216ea3aa07ee781 \ + --hash=sha256:0a52991594ac4db888c7d39bccef331797e30cb31a95cae02cf2607f83a42dc2 \ + --hash=sha256:0bf08b749cc144f33b44a91b78e3f71c60eb07963746a0df5a100b36ce3d7475 \ + --hash=sha256:0ebfad5d131de9f892ae9e70cc7616207768b6714b66a52d4612b8ceaf78b372 \ + --hash=sha256:1679a1cb93fbe5a6d1fd58d82cbddcc6fcb8c61446ba7cae6eb2a7b19bc585de \ + --hash=sha256:198a48e68cc99ccac03ba95ac857e73aa66f3bf6be77019fafb0832a05f7ad03 \ + --hash=sha256:1fbd30e537dab22cafdf080608f10148fe2a5f3a61294ddb5113caac8a623840 \ + --hash=sha256:289aadd6a00e151203c081f708348ec89f1e483c9b510ef4ac3981f847f01f79 \ + --hash=sha256:2f122603f36050937982abf9668d8bc4769a79f7c93a65013b1c49f1cab7b56b \ + --hash=sha256:303732e798fe6729f8e12021b9c96107df8e95ecec4dd487c67b98ec2a59435e \ + --hash=sha256:31cd942c23f613276b81a6e6598cefa12960058b0f46e1e874b540c793f6aca5 \ + --hash=sha256:366db6e97e66b37211475f20c4c1324a2dc0dd825e46d4e87f9d599304d276f9 \ + --hash=sha256:373704aea331d3f3e3402c125a1543f5875e2986ebb54f97d1647942161f803f \ + --hash=sha256:37d40450659401600e6d043ff586c89a71a69f33cbb8bcdba6cdb2569beecdbe \ + --hash=sha256:37e517c146b185f9c0c6e8d0a0ebbdeeeb67896af28466e032bc810d0c7dc7a7 \ + --hash=sha256:3af90f92769d8cc10f94515ee7a0aef36ea85ca733a0ce22858f6e0953f41138 \ + --hash=sha256:3c9e663b2e800e3218994cf948c11bcc2844e6491b34aa80d089baf6531827bf \ + --hash=sha256:3f84dab25e0385692ee13274c68678377e0b1a70ab9d14e56264cbf61f60c62d \ + --hash=sha256:4690cf67738f0e0e49a32aeec99bf0e4595cc2b4f1af984a4345394b1dcff91a \ + --hash=sha256:566dd827f17728efdf7d88a5b066f815170f6fdad13967ae952842d90e6aaa9f \ + --hash=sha256:5927b7ba63153cd8e9862987290a2b783a5c590daf2a4ef981700cc3569166d4 \ + --hash=sha256:5ad8f35e67cc16d1fad1fa8c88972dc9b3a3141ea67897399904edab96a301b6 \ + --hash=sha256:5ea8beeb5541780b4b50b462eeacbc4f594ce3b911dc20c81c75f267876f71d2 \ + --hash=sha256:5f598f19fa9a91540b5cee17932ffd227b7b53a481605bcc4573c0eafa647300 \ + --hash=sha256:612382ac3ed13651c7fa44b5fee9fbf7baaa2ddbc6f500391672682c5f1df9e0 \ + --hash=sha256:6ff05561e4a067d35507dc5c90f1deb2ec1c9703ac5cccc1bc26e08a197f9c5a \ + --hash=sha256:7308c93cf0b19bbaf8e6ff0a6ad50d3c442385739245fe15a8d593bf841734a6 \ + --hash=sha256:79a2a1c3449f6c3409427078ed1cec10de79f3023cb5f2504f0597d350ad46c7 \ + --hash=sha256:7beb3e41c9a1e509f3ed85263386588cbe3e975aa67be21f79f44fd35ffaeefc \ + --hash=sha256:86147cb5d140341c3363fb5bacce31f8d5543902a46699d3c536b101bbceaf9e \ + --hash=sha256:889e42acec10450185e0cdfb396f375e2c1a8d7737c114830a7fde4654f59e30 \ + --hash=sha256:910ace140e3e7b7596898d083f37a8fe90c5c40684252ad4e682364b2cd3deba \ + --hash=sha256:955e3dd94da361e052d2e49acf591017158dc8f8ed2c8a42c2e3943403c39dc2 \ + --hash=sha256:9892188bb15e5803beb51afe8a25add6b56be391a53058e8bca03b74e1e6bf22 \ + --hash=sha256:98c02090d88f2ebc0ec1e8da538f77d225ce0fffecf372aa39262e62a1b054ef \ + --hash=sha256:9b2f11794e017ce340934e35de46181c46ef71ec75ea3d85dd75cd836761c01e \ + --hash=sha256:a2e44a342d2aee40508e28a563d8961c39d9bbd8cae36d8578f0a3c6658aab0f \ + --hash=sha256:a4ee3bdd5468a725f2a4d9aab8a74b6d0279f768c8b5d3aeb102c5307ff3d59c \ + --hash=sha256:a5165300324efd5a772c48a88ab3a928513ab3979fca76553e62ee815f7b2b9c \ + --hash=sha256:a9348c5b43a3bb5ef8c2e89d5237c9c87eeafb01d338c84a7aebbc5cd0313299 \ + --hash=sha256:aa73160077345ec21b3f51e8e24b3de2e99586217e497629326eb9b2ea88c52e \ + --hash=sha256:ad1c785e784cfd87e8436c6b7702f2d321fc39601bbaf29bc63a41a867091638 \ + --hash=sha256:b3f75dee0f9afafabe4edc52c4842f1e1878ed2069bd05b22d6fe961e97e4dba \ + --hash=sha256:b599defe9190b17e9907c8b4d114c181e702c87efcd1b8a0ad40971cdcc4634a \ + --hash=sha256:b82491019b884d62318b5f30706c3d7e6d4e5a6cb7eabcb3edc0c1b0fdaceae9 \ + --hash=sha256:b8ece331509f7a975b90501f41e83ad905e4141753fedf3f2711b2bc70a8efbc \ + --hash=sha256:b979a42815410432420275412633960807178b1ce26591a16ce06e78a5bd4bb2 \ + --hash=sha256:be4f9b3c9338ac5dd217c5847e21521b396c8117f78dc420d495a5c49bbef874 \ + --hash=sha256:bf8c8481d026b85dd70c5fa7dde85b2333aed0b32a2602bcd38a900cbd78a49c \ + --hash=sha256:c61617eaae0112ca154da87ffb99b73af2c74067acac28dfb9a4455b019dff2e \ + --hash=sha256:c6d19cb4999d03231e8730a5f66c8f5068bc3b532677eb39dab0f600bff3e312 \ + --hash=sha256:c7753871eb57e6a5f4646f6168590c6653073dea5e9e720b201c8875332df4c8 \ + --hash=sha256:c7f92daa0d2a1c76f07264abddf8cbabd30152a2f09c3270e50f0c7efdf5dcac \ + --hash=sha256:cbd5f73073ed19c378d4c35499db1e3e703a5b1a324e521204065967bfaa7a18 \ + --hash=sha256:cec5ea900390897d0b46130f60bc2883bf19c314f9044235217c8be88b0ef269 \ + --hash=sha256:d636338c8f21b0df2f84657b00bc34f9313f826ef93f1155bc743607e4a0c5eb \ + --hash=sha256:dc75da5a20951049f7b773145f998f69d181adad9c58a0ff36e0cf1d73c10e10 \ + --hash=sha256:e23a66a763fbe83fcc210bc77c27e5a5ea380ebf091c06f34d8561b695e5a40f \ + --hash=sha256:e8cbb54454dbf1bbf2ff08dd7693e8d94ac94b1a20f70f4b3b813d52ecb5cbc1 \ + --hash=sha256:ee2c4728c691245e24501fcd7a97b5b381236b9985bc445bba88cdce7d1b5784 \ + --hash=sha256:f0535693ce476a722b718b002d5d2c27d47e71ca945276ac194409c98e74c492 \ + --hash=sha256:f19cc87343eaa55255e76b31259a570072ac95d6ae82c92dd34b97691f5e49dc \ + --hash=sha256:f21d057f3e5f5491067e5b292498073b73847d48799b099803fef100775fcc52 \ + --hash=sha256:f87dbdc42e78ee0f7ea180c03f8c78e80a949e373066629bd90fefff10552dff \ + --hash=sha256:fa34eb47969297471db7b7f193622c7e3ee839ec05abd05f1fe104d5b1b1dcf4 \ + --hash=sha256:fdccb3a0e184b03e9baa673b15a809cf36c339c85dbda0ebc25a698846dfbee8 + # via -r requirements.in +psycopg-pool==3.3.3 \ + --hash=sha256:9b9cd6a4fcec47a410f7e82d408540e7f77b478509e91b44c1a5457a13e5ff37 \ + --hash=sha256:df87b5d9d0ad7db37f6cdad4fa8ce113d250f5997f6db38e9a99192fb67f9e1d + # via -r requirements.in +pycparser==3.11 \ + --hash=sha256:51d5a8ba2be0bbe440b99d2112604c95bbbc3c2748a64260186c541e1729cd80 \ + --hash=sha256:d875f09c3507d00e1aba0eecc6dcadc1352f30fff09dc6bff2f1c2935e97c2bc + # via cffi +redis==8.1.0 \ + --hash=sha256:6e1a19beef9225c83efd689c7e6b7da2d5215b1f42cd13b7fc3714d0a09c7b25 \ + --hash=sha256:a4fe1aac3d3b3cc791d4b3d5931c5a956045dc951ee74d1c913ee3ac4d2ee9fb + # via -r requirements.in +starlette==1.7.0 \ + --hash=sha256:67f8e99895493dd2911a03f11314af6ceebeae4e704bb9f43dfc6a9db151c93e \ + --hash=sha256:c79f74ea63cff761804fbbfb182f1e0b440c2d07b164d24700c5a1bab5d6ff5d + # via -r requirements.in +typing-extensions==4.16.0 \ + --hash=sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8 \ + --hash=sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5 + # via + # anyio + # psycopg-pool +uvicorn==0.54.0 \ + --hash=sha256:505bdb0f318731d45f1f712071fc781a8981f6847a31c902c9f5e652d4f67faf \ + --hash=sha256:a2e33cbfaa0306f8e6b0c13e0cb89d7d7a2da3e62b90c66e18c33d9807b28620 + # via -r requirements.in +uvloop==0.23.0 ; sys_platform != "win32" \ + --hash=sha256:0305871ac712f54b62af73f943dbf21ae3ce80a44bc0f0151424484affa85645 \ + --hash=sha256:090865d8ce7a03986755a3ce711b7dd0d4b44eb14ab74368b717f3fad1180208 \ + --hash=sha256:098a85e1393ef5202767b7e5fb41a32cd8bd81e6ee4af364c179801c4aa3f6d4 \ + --hash=sha256:0efdd55bddbd36bb2fcb842d64c0d5f6407c6958c68088cc25df8c09edc5b5fd \ + --hash=sha256:12634f15e6625f78b3f2922f91404c4d7173487eba11746764153f556e9852dc \ + --hash=sha256:1748321e3c59a14a75404b1ae8d5a8d81c4e201803ea0e14c1b6fd84421024b5 \ + --hash=sha256:19c64108b507cd0bc140e400e3396bacebd9d504956aa7726272bf6de7d9aabb \ + --hash=sha256:1e84575f11873c109cf3962ad0bdf679094466184125f4cadcc41a73febff41f \ + --hash=sha256:24c58ae4a83e93a04c504bcc678125e36a0bfc44af928ad69444880c60f187a5 \ + --hash=sha256:28d160f51ab4da3b187063652e643dea6831072add4adc1e6d62afbe73b6be27 \ + --hash=sha256:2dcff2d69be43e6559e5dad2c5a7a2dbfb60e05a77311b6c4b7a4a8123d86c65 \ + --hash=sha256:31e0cf90bc8fd88784f6802cdba968a51fb1aec1cc3feec74d862b2d371d1330 \ + --hash=sha256:378188efbb1524f2219d05246a3e1e5907217848d2882144dff59585f1b81d55 \ + --hash=sha256:42feced24b9b44b856c633eafb5cc5dec354972da55ce77598db6844c054bc7c \ + --hash=sha256:4448e9124537620f9c25d004c227bb5104440b58955c19bbd312d910af919a63 \ + --hash=sha256:4a08875543bbd4519faf30497506c9cda8a48470467ffdf967c7313c7a5981a8 \ + --hash=sha256:4b8e207c67d207a8608fec57e116511030af3495dc0109b8c333cf9cb412b16f \ + --hash=sha256:4bb7f5d0b62b5afaaaea2b7b60d508921c24b0fe39c22c1438bec1811ffe10ec \ + --hash=sha256:4f1798f56c6f4ba5ac11fa2869e5717926e4470d97a1dd42b4f59219d43b5027 \ + --hash=sha256:514698d3683189031dcbfdc31e87115992e5ce9e1b19fe5359941323f2df800c \ + --hash=sha256:53c2c5d7e2024e46776c2d90e6c637d01102126b61aaf5faa5edaf05f8b5722a \ + --hash=sha256:55d6f4135d914305929fe9e9c44d8b5383a9b3fa1bee3bfcf60ee97e01af07ea \ + --hash=sha256:5a2bbad3a63007f7e9524d4903ba04fee252557c2acd86f9a3d4f91786695254 \ + --hash=sha256:5a3e0f56ec19bfd9ad1605572878dd6ff7f01b325f4fc154812ae70d615c3aff \ + --hash=sha256:5bb9be71d9ee39b4359b832f9569518ec9bc08704194034e79e4958e6bc4d46d \ + --hash=sha256:60ec798c40a1810d282ee046f61ecac1c5675cb898763d9f08d97d53a5e00a81 \ + --hash=sha256:6b3cbc4f96ddfa1fb88a78a69dd851369825b7816d9702eee8c4461505ba172e \ + --hash=sha256:6c7ef4701a96553514b2688e342ef1bf2beae6cfd172d89a76c768292aabf405 \ + --hash=sha256:7337b06a9f9ed9ea3049f04b76f65819db9b19bb832ee598e97b388eadf25e5f \ + --hash=sha256:76345f51367fb1f23e08605c6efb18374f669be5b223658fbab6b17627950507 \ + --hash=sha256:7e35c9bc977760981693e1a7a51493b58ee5a501f9ebb1e547565ee40b6c6208 \ + --hash=sha256:80cac5cb90ed7b9b72a217a1d6982b15b829cdbd0ee6bc19b93e3a9e47fb0ac9 \ + --hash=sha256:8af88fe5c7dd68fe1fec6dea8155caa1a47155d219a750ff34049541cf536a5e \ + --hash=sha256:8fcd721113260ffb5e38bf14a8725b17d431f34209f7d1c7005b667946e630b3 \ + --hash=sha256:93087a845cdfb35753e539354ac9551bdd2ff528c202a98df0ae46e852bcf021 \ + --hash=sha256:93935ab27b6eaef4c3e5489aebc84284f0644592f7ab516df60ee1b27eaf5eb3 \ + --hash=sha256:9bf08e4b6362dd1c08623bbfa2d061e8bac0f1da8fc2007062cfe1dc360a49fa \ + --hash=sha256:a6ac96da66c35bf789bdcde78a88dc7d56b7907d8379648c54adc1c61594575d \ + --hash=sha256:ab17b3a8aa754be0de0e397f7b95f13b14e56f077a4c6ae295e3d4afd199b325 \ + --hash=sha256:b0d106d9314546d69b3df1b5352639aa628530ec3ecef8a98a21942d2a2a64f5 \ + --hash=sha256:b90397a50ad6332ed3e459c648ac20d182cce24a557354363ad85fc9ea4a17cd \ + --hash=sha256:bbbdb8fcd5e7062e546eec1ac78c28bb21ae7df54c18f8e4b06e15a18d661a49 \ + --hash=sha256:bd6f2f81c7b9da99d301c0b16b82044e76fe887086e42e1590ecf520b94dbdac \ + --hash=sha256:be53e1d5f83de43dc175c87612ecc128d444b38e5c56cb3f807f5a73d6887476 \ + --hash=sha256:c3f23f403a273900d57de6ee5ca0614c650f7f58563065dad1a4744498960e53 \ + --hash=sha256:cbe8d03d4efcccdb7fcedecbaa1e1fa02913eaf3a74cb933634a6bc6d2ea9e2a \ + --hash=sha256:ce17bc317d089f361b33521654c13e30eacfd3d2034fd34e613ca9c51c969686 \ + --hash=sha256:d918d6f304a309222a784bbd140b85ec5594d97e4dc0e79f590549d28970663a \ + --hash=sha256:dc61e4f9e37b507069dc7e659ae28bca7adcb04c993c3508214315d12c63f848 \ + --hash=sha256:e095f9e105af76593b4c183bb0bcbdae64bd913a59ec595732dc108b48730ab5 \ + --hash=sha256:e2cba180d6451822763eda8364f342435a873bcfb3849cbd82fdeca248ca65eb \ + --hash=sha256:e49eba8f1e28e7c03648b7a476e1ba05309e087ccdea859fc6dd659564aa8d7e \ + --hash=sha256:f1341c6abcee1c31277cfe28d34e46196f2143ec3d755e6efe7452126e1f626d \ + --hash=sha256:f3fbfe82829d8e381426a289b87e59e585278728361db9ce975b88b51f64f410 \ + --hash=sha256:f50b580fad005a092ed87c5a3a4683459b21d1620497d6a5bccad203bee4c071 \ + --hash=sha256:f5576e8ae1723ece60d8f93c6710abf784714e99388bcf023ba9ca800bc587f6 \ + --hash=sha256:f673d835bdb1a60229cc3609a113fd2c9ce3f4a3c75ad4eaed111180c00199d2 \ + --hash=sha256:f7548ede3ee908cfabc0d068106e303a9a2d811af959cdf6ab85676344cedcda \ + --hash=sha256:fa8ed556fcc87a4091cf61587ef172fa104323dc89ecc085a618ba7ff8629a8f \ + --hash=sha256:fefea5cf8cdda9053b962ca8a90216fb0b1d40907dcb6819382b42e483e6e9f6 \ + --hash=sha256:ff7144d8167e513fe39fbb46bffb4f6f192dfb1f4b0b4e9102e1fd4f212e4747 + # via -r requirements.in diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100755 index 00000000..b02f635c --- /dev/null +++ b/scripts/init_secrets.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +"""Create local synthetic credentials for the stand in ./secrets (ignored by Git). + + python scripts/init_secrets.py + +Idempotent: existing files are kept, so re-running never changes passwords of a +database that already has data. Prints only file names, never values. +Delete ./secrets together with the volumes (`docker compose down -v`) to start over. +""" +from __future__ import annotations + +import os +import secrets +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +SECRETS = ROOT / "secrets" + + +def write(name: str, value: str) -> None: + path = SECRETS / name + if path.exists(): + print(f"keep secrets/{name}") + return + path.write_text(value + "\n", encoding="utf-8", newline="\n") + # Readable by the container users (postgres, valkey, app uid 10001) through the + # compose bind mount. Local synthetic lab credentials only. + os.chmod(path, 0o644) + print(f"created secrets/{name}") + + +def read(name: str) -> str: + return (SECRETS / name).read_text(encoding="utf-8").strip() + + +def main() -> int: + SECRETS.mkdir(exist_ok=True) + write("postgres_password", secrets.token_urlsafe(24)) # [A-Za-z0-9_-]: safe inside URLs + write("valkey_password", secrets.token_urlsafe(24)) + write("database_url", f"postgresql://messenger:{read('postgres_password')}@postgres:5432/messenger") + write("cache_url", f"redis://:{read('valkey_password')}@valkey:6379/0") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..f8a4ff9a --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,6 @@ +@echo off +rem Windows wrapper: tests/resilience.py starts the hook as a program, and Windows +rem cannot execute a .sh file directly. Runs the same scripts\restart.sh with Git Bash. +rem python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +"%ProgramFiles%\Git\bin\bash.exe" "%~dp0restart.sh" +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..973048a8 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# Restart hook for `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. +# Restarts the API and ALL state stores (PostgreSQL, Valkey) of compose.yaml. +# Volumes, schema and data are preserved: no `down -v`, no FLUSH, no re-seed. +# Output is suppressed by the test; run it by hand to see the steps. +set -eu +cd "$(dirname "$0")/.." + +# 1. API first: no request is served while the stores restart underneath it. +docker compose stop api +# 2. Stores: clean shutdown (PostgreSQL checkpoint, Valkey AOF fsync), then start again. +docker compose restart postgres valkey +# 3. API again; it waits for healthy stores via depends_on and reconnects its pool. +docker compose start api +echo "restart.sh: api, postgres and valkey restarted with volumes preserved" diff --git a/src/messenger/__main__.py b/src/messenger/__main__.py index 6a410d4c..331a1fd2 100644 --- a/src/messenger/__main__.py +++ b/src/messenger/__main__.py @@ -4,7 +4,8 @@ Shutdown sequence on SIGTERM/SIGINT: 1. readiness flips to 503 (`app.state.draining = True`); 2. uvicorn closes the listening socket, so new connections are refused; 3. in-flight requests get up to SHUTDOWN_TIMEOUT_SECONDS (default 8 s < Docker's 10 s) to finish; -4. the process exits with code 0. In-memory data is lost by design. +4. the lifespan closes the DB pool and the Valkey client; the process exits with code 0. + Data stays in PostgreSQL and Valkey volumes. """ from __future__ import annotations @@ -47,16 +48,16 @@ def main() -> int: access_log=False, server_header=False, proxy_headers=False, - lifespan="off", + lifespan="on", timeout_graceful_shutdown=settings.shutdown_timeout, ) server = GracefulServer(config) log.info("starting", extra={"fields": { "version": __version__, "env": settings.env, "host": settings.host, "port": settings.port, - "python": sys.version.split()[0], "storage": "in-memory (single process)", + "python": sys.version.split()[0], "storage": "postgresql", }}) server.run() - log.info("stopped", extra={"fields": {"state": app.state.store.counts(), "note": "in-memory data discarded"}}) + log.info("stopped") return 0 diff --git a/src/messenger/app.py b/src/messenger/app.py index 9073cda3..9d0bf79b 100644 --- a/src/messenger/app.py +++ b/src/messenger/app.py @@ -2,6 +2,7 @@ from __future__ import annotations import asyncio +import contextlib import logging import re import time @@ -11,14 +12,16 @@ from typing import Any from starlette.applications import Starlette from starlette.exceptions import HTTPException from starlette.requests import Request -from starlette.responses import JSONResponse +from starlette.responses import JSONResponse, Response from starlette.routing import Route from starlette.types import ASGIApp, Message as AsgiMessage, Receive, Scope, Send -from . import cursor, docs, validation +from . import authhdr, cursor, docs, passwords, repo, validation from .config import Settings -from .errors import ApiError, InvalidRequest, PayloadTooLarge, Unauthorized, Unavailable -from .store import Store, User +from .db import Database +from .errors import BASIC_CHALLENGE, ApiError, InvalidRequest, PayloadTooLarge, Unauthorized, Unavailable +from .sessions import SessionStore, build_store +from .timefmt import rfc3339 log = logging.getLogger("messenger") access_log = logging.getLogger("messenger.access") @@ -36,7 +39,7 @@ def error_response(request_id: str, status: int, code: str, message: str, header async def api_error_handler(request: Request, exc: Exception) -> JSONResponse: assert isinstance(exc, ApiError) - return error_response(request.state.request_id, exc.status, exc.code, exc.message) + return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers) async def http_exception_handler(request: Request, exc: Exception) -> JSONResponse: @@ -108,19 +111,24 @@ class RequestContextMiddleware: # -------------------------------------------------------------------------- # Request helpers # -------------------------------------------------------------------------- -def store_of(request: Request) -> Store: - return request.app.state.store +def db_of(request: Request) -> Database: + return request.app.state.db -def current_user(request: Request) -> User: - """Lab 1 identification: X-User-Id must be the UUID of an existing user, otherwise 401.""" - raw = request.headers.get("x-user-id") - if raw is None or validation.UUID_RE.fullmatch(raw) is None: - raise Unauthorized() - user = store_of(request).get_user(raw.lower()) - if user is None: - raise Unauthorized() - return user +def sessions_of(request: Request) -> SessionStore: + return request.app.state.sessions + + +async def authenticate(request: Request) -> str: + """User id of a valid Bearer session, otherwise 401. X-User-Id is ignored since lab 2. + + Store failures are 503 (Unavailable), never 401 and never anonymous access. + """ + token = authhdr.parse_bearer(request.headers.get("authorization")) + user_id = await sessions_of(request).user_id_for(token) + if user_id is None: + raise Unauthorized("Сессия недействительна, истекла или отозвана") + return user_id def path_uuid(request: Request, name: str) -> str: @@ -170,85 +178,136 @@ async def live(request: Request) -> JSONResponse: async def ready(request: Request) -> JSONResponse: - # The only critical dependency is process memory; while draining after - # SIGTERM the instance reports 503 so no new traffic is routed to it. + """200 only if the mandatory synchronous path can be served: PostgreSQL and, + with SESSION_STORE=valkey, Valkey answer. 503 while draining after SIGTERM.""" if request.app.state.draining: raise Unavailable("Сервер завершает работу") + db_ok, store_ok = await asyncio.gather(db_of(request).ping(), sessions_of(request).ping()) + if not db_ok: + raise Unavailable("PostgreSQL недоступен") + if not store_ok: + raise Unavailable("Хранилище сессий недоступно") return ok({"status": "ok"}) async def register_user(request: Request) -> JSONResponse: data = await read_json(request) - validation.check_fields(data, {"username", "display_name"}) + validation.check_fields(data, {"username", "display_name", "password"}) username = validation.username_field(data) display_name = validation.text_field(data, "display_name", 100) - user = store_of(request).create_user(username, display_name) + password = validation.password_field(data) + password_hash = await passwords.hash_password(password) + user = await repo.create_user(db_of(request), username, display_name, password_hash) log.info("user_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}}) return ok(user.to_json(), 201) +async def create_session(request: Request) -> JSONResponse: + """Login: only `Authorization: Basic`; wrong user and wrong password give the same 401.""" + username, password = authhdr.parse_basic(request.headers.get("authorization")) + found = await repo.get_credentials(db_of(request), username) + user, stored_hash = found if found else (None, None) + if not await passwords.verify_password(stored_hash, password) or user is None: + log.info("login_failed", extra={"fields": {"request_id": request.state.request_id}}) + raise Unauthorized("Неверное имя пользователя или пароль", challenge=BASIC_CHALLENGE) + ttl = request.app.state.settings.session_ttl_seconds + token, expires_at = await sessions_of(request).create(user.id, ttl) + log.info("session_created", extra={"fields": {"request_id": request.state.request_id, "user_id": user.id}}) + return ok({"token": token, "token_type": "Bearer", "expires_at": rfc3339(expires_at), "user": user.to_json()}, 201) + + +async def revoke_session(request: Request) -> Response: + token = authhdr.parse_bearer(request.headers.get("authorization")) + if not await sessions_of(request).revoke(token): + raise Unauthorized("Сессия недействительна, истекла или отозвана") + log.info("session_revoked", extra={"fields": {"request_id": request.state.request_id}}) + return Response(status_code=204) + + async def me(request: Request) -> JSONResponse: - return ok(current_user(request).to_json()) + user_id = await authenticate(request) + user = await repo.get_user(db_of(request), user_id) + if user is None: + raise Unauthorized("Сессия недействительна, истекла или отозвана") + return ok(user.to_json()) async def create_chat(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) data = await read_json(request) validation.check_fields(data, {"title", "member_ids"}) title = validation.text_field(data, "title", 100) member_ids = validation.member_ids_field(data) - chat = store_of(request).create_chat(user.id, title, member_ids) + chat = await repo.create_chat(db_of(request), user_id, title, member_ids) log.info("chat_created", extra={"fields": {"request_id": request.state.request_id, "chat_id": chat.id, "members": len(member_ids)}}) return ok(chat.to_json(), 201) async def list_chats(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) limit, raw_cursor = page_params(request) - after = cursor.decode(raw_cursor, cursor.CHATS, user.id) if raw_cursor else None - items, has_more = store_of(request).list_chats(user.id, after, limit) - next_cursor = cursor.encode(cursor.CHATS, user.id, items[-1].key) if has_more else None + after = cursor.decode(raw_cursor, cursor.CHATS, user_id) if raw_cursor else None + items, has_more = await repo.list_chats(db_of(request), user_id, after, limit) + next_cursor = cursor.encode(cursor.CHATS, user_id, items[-1].key) if has_more else None return ok({"items": [c.to_json() for c in items], "next_cursor": next_cursor}) async def get_chat(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) chat_id = path_uuid(request, "chat_id") - return ok(store_of(request).get_chat(user.id, chat_id).to_json()) + return ok((await repo.get_chat(db_of(request), user_id, chat_id)).to_json()) async def create_message(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) chat_id = path_uuid(request, "chat_id") - store = store_of(request) - store.get_chat(user.id, chat_id) # access check before reading the body: outsiders get 404 + db = db_of(request) + await repo.ensure_member(db, user_id, chat_id) # outsiders get 404 before the body is read data = await read_json(request) validation.check_fields(data, {"text"}) text = validation.text_field(data, "text", 4000) - # sender_id is derived from the identification, never taken from the body. - message = store.add_message(user.id, chat_id, text) + # sender_id is derived from the session, never taken from the body. + message = await repo.add_message(db, user_id, chat_id, text) return ok(message.to_json(), 201) async def list_messages(request: Request) -> JSONResponse: - user = current_user(request) + user_id = await authenticate(request) chat_id = path_uuid(request, "chat_id") - store = store_of(request) - store.get_chat(user.id, chat_id) # 404 for outsiders before any cursor details leak + db = db_of(request) + await repo.ensure_member(db, user_id, chat_id) # 404 for outsiders before cursor details leak limit, raw_cursor = page_params(request) after = cursor.decode(raw_cursor, cursor.MESSAGES, chat_id) if raw_cursor else None - items, has_more = store.list_messages(user.id, chat_id, after, limit) + items, has_more = await repo.list_messages(db, chat_id, after, limit) next_cursor = cursor.encode(cursor.MESSAGES, chat_id, items[-1].key) if has_more else None return ok({"items": [m.to_json() for m in items], "next_cursor": next_cursor}) -def create_app(settings: Settings | None = None, store: Store | None = None) -> Starlette: +def create_app(settings: Settings | None = None) -> Starlette: settings = settings or Settings.from_env() + db = Database(settings) + sessions = build_store(settings, db) + + @contextlib.asynccontextmanager + async def lifespan(app: Starlette): + passwords.configure(settings.hash_concurrency) + await db.open() + log.info("dependencies_configured", extra={"fields": { + "session_store": sessions.name, "session_ttl_s": settings.session_ttl_seconds, + "db_pool_max": settings.db_pool_max, "db_timeout_s": settings.db_timeout_seconds}}) + try: + yield + finally: + await sessions.close() + await db.close() + routes = [ Route("/health/live", live, methods=["GET"]), Route("/health/ready", ready, methods=["GET"]), Route("/api/v1/users", register_user, methods=["POST"]), Route("/api/v1/users/me", me, methods=["GET"]), + Route("/api/v1/auth/sessions", create_session, methods=["POST"]), + Route("/api/v1/auth/sessions/current", revoke_session, methods=["DELETE"]), Route("/api/v1/chats", create_chat, methods=["POST"]), Route("/api/v1/chats", list_chats, methods=["GET"]), Route("/api/v1/chats/{chat_id}", get_chat, methods=["GET"]), @@ -263,9 +322,11 @@ def create_app(settings: Settings | None = None, store: Store | None = None) -> app = Starlette( routes=routes, exception_handlers={ApiError: api_error_handler, HTTPException: http_exception_handler}, + lifespan=lifespan, ) app.add_middleware(RequestContextMiddleware) app.state.settings = settings - app.state.store = store or Store() + app.state.db = db + app.state.sessions = sessions app.state.draining = False return app diff --git a/src/messenger/authhdr.py b/src/messenger/authhdr.py new file mode 100644 index 00000000..f849b029 --- /dev/null +++ b/src/messenger/authhdr.py @@ -0,0 +1,48 @@ +"""Parsing of the Authorization header. Any malformed value is 401, never 500. + +Basic (RFC 7617) is accepted only by POST /auth/sessions; everything else needs +Bearer. Basic is an encoding, not encryption: plain HTTP is acceptable only for the +local synthetic lab stand (lab 7 adds TLS). +""" +from __future__ import annotations + +import base64 +import binascii +import re + +from .errors import BASIC_CHALLENGE, BEARER_CHALLENGE, Unauthorized +from .validation import USERNAME_RE + +B64_RE = re.compile(r"[A-Za-z0-9+/]+={0,2}") +TOKEN_RE = re.compile(r"[A-Za-z0-9_-]{32,128}") # token_urlsafe(32) gives 43 characters + + +def _split(header: str | None) -> tuple[str, str]: + if not header: + return "", "" + scheme, _, value = header.strip().partition(" ") + return scheme.lower(), value.strip() + + +def parse_basic(header: str | None) -> tuple[str, str]: + """(username, password) from `Basic base64(username:password)`; the password may contain ':'.""" + invalid = Unauthorized("Неверное имя пользователя или пароль", challenge=BASIC_CHALLENGE) + scheme, value = _split(header) + if scheme != "basic" or B64_RE.fullmatch(value) is None or len(value) > 1024: + raise invalid + try: + decoded = base64.b64decode(value, validate=True).decode("utf-8") + except (binascii.Error, ValueError, UnicodeDecodeError): + raise invalid from None + username, sep, password = decoded.partition(":") # split at the FIRST colon + if not sep or USERNAME_RE.fullmatch(username) is None or not password: + raise invalid + return username, password + + +def parse_bearer(header: str | None) -> str: + scheme, value = _split(header) + if scheme != "bearer" or TOKEN_RE.fullmatch(value) is None: + # Missing header, Basic on a business endpoint, garbage token: one answer. + raise Unauthorized("Требуется действительная Bearer-сессия", challenge=BEARER_CHALLENGE) + return value diff --git a/src/messenger/config.py b/src/messenger/config.py index 25f4c51e..4cecbcd1 100644 --- a/src/messenger/config.py +++ b/src/messenger/config.py @@ -1,13 +1,15 @@ """Runtime configuration read from environment variables (12-factor style). -Every variable has a safe default, so `docker run` works from a clean clone -even without an .env file. Invalid values stop the process at startup with a -clear message instead of failing later under traffic. +Non-secret settings have safe defaults. Connection strings with passwords are +read from files (`DATABASE_URL_FILE`, `CACHE_URL_FILE` → Docker secrets in +/run/secrets), so they never appear in `docker inspect`, compose files or logs. +Invalid values stop the process at startup with a clear message. """ from __future__ import annotations import os from dataclasses import dataclass +from pathlib import Path class ConfigError(ValueError): @@ -49,6 +51,22 @@ def _bool(name: str, default: bool) -> bool: return raw in {"true", "1"} +def _secret(name: str, required: bool) -> str: + """Value of _FILE (preferred, Docker secret) or (local runs/tests).""" + path = os.environ.get(f"{name}_FILE", "").strip() + if path: + try: + value = Path(path).read_text(encoding="utf-8").strip() + except OSError as exc: + # The message names the file, never its content. + raise ConfigError(f"{name}_FILE={path} cannot be read: {exc.strerror}") from None + else: + value = os.environ.get(name, "").strip() + if required and not value: + raise ConfigError(f"{name}_FILE (or {name}) must be set") + return value + + @dataclass(frozen=True) class Settings: host: str @@ -58,12 +76,35 @@ class Settings: shutdown_timeout: float max_body_bytes: int docs_enabled: bool = True + database_url: str = "" + session_store: str = "postgres" + cache_url: str = "" + session_ttl_seconds: int = 3600 + db_pool_min: int = 1 + db_pool_max: int = 10 + db_timeout_seconds: float = 3.0 + cache_timeout_seconds: float = 0.5 + hash_concurrency: int = 2 + + @property + def db_statement_timeout_ms(self) -> int: + # The server stops a statement a bit before the client-side deadline fires. + return max(100, int(self.db_timeout_seconds * 1000) - 500) @classmethod def from_env(cls) -> "Settings": log_level = os.environ.get("LOG_LEVEL", "info").strip().lower() or "info" if log_level not in {"debug", "info", "warning", "error"}: raise ConfigError(f"LOG_LEVEL must be debug/info/warning/error, got {log_level!r}") + session_store = os.environ.get("SESSION_STORE", "postgres").strip().lower() or "postgres" + if session_store == "redis": + session_store = "valkey" # same protocol; the course allows Redis OR Valkey + if session_store not in {"postgres", "valkey"}: + raise ConfigError(f"SESSION_STORE must be postgres or valkey, got {session_store!r}") + db_pool_min = _int("DB_POOL_MIN", 1, 0, 50) + db_pool_max = _int("DB_POOL_MAX", 10, 1, 100) + if db_pool_min > db_pool_max: + raise ConfigError("DB_POOL_MIN must not exceed DB_POOL_MAX") return cls( host=os.environ.get("APP_HOST", "0.0.0.0").strip() or "0.0.0.0", port=_int("APP_PORT", 8080, 1, 65535), @@ -73,4 +114,14 @@ class Settings: shutdown_timeout=_float("SHUTDOWN_TIMEOUT_SECONDS", 8.0, 0.0, 9.0), max_body_bytes=_int("MAX_BODY_BYTES", 64 * 1024, 1024, 1024 * 1024), docs_enabled=_bool("DOCS_ENABLED", True), + database_url=_secret("DATABASE_URL", required=True), + session_store=session_store, + cache_url=_secret("CACHE_URL", required=session_store == "valkey"), + # Contract name. Minimum 1 s so the expiry test can use 2 s. + session_ttl_seconds=_int("SESSION_TTL_SECONDS", 3600, 1, 30 * 24 * 3600), + db_pool_min=db_pool_min, + db_pool_max=db_pool_max, + db_timeout_seconds=_float("DB_TIMEOUT_SECONDS", 3.0, 0.5, 30.0), + cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.5, 0.05, 10.0), + hash_concurrency=_int("PASSWORD_HASH_CONCURRENCY", 2, 1, 16), ) diff --git a/src/messenger/cursor.py b/src/messenger/cursor.py index bb776049..8e2d5ee6 100644 --- a/src/messenger/cursor.py +++ b/src/messenger/cursor.py @@ -16,6 +16,9 @@ from .validation import UUID_RE B64_RE = re.compile(r"[A-Za-z0-9_-]{1,512}") TS_RE = re.compile(r"[0-9]{1,19}") +# Latest instant both Python datetime and PostgreSQL accept: 9999-12-31T23:59:59.999999Z. +MAX_TS_US = 253402300799999999 + MESSAGES = "m" CHATS = "c" @@ -44,6 +47,8 @@ def decode(cursor: str, scope: str, owner_id: str) -> SortKey: if TS_RE.fullmatch(ts) is None or UUID_RE.fullmatch(item_id) is None or item_id != item_id.lower(): raise bad key = (int(ts), item_id) + if key[0] > MAX_TS_US: + raise bad # out-of-range time must be 400, not an overflow (500) in datetime/SQL if encode(got_scope, got_owner, key) != cursor: raise bad # only the canonical form produced by the server is accepted if got_scope != scope or got_owner != owner_id: diff --git a/src/messenger/db.py b/src/messenger/db.py new file mode 100644 index 00000000..6c753a6e --- /dev/null +++ b/src/messenger/db.py @@ -0,0 +1,109 @@ +"""PostgreSQL access: a bounded connection pool and a hard deadline for every unit of work. + +Three independent limits keep a request from hanging when the database misbehaves: + +* pool `timeout` — waiting for a free connection (pool exhausted); +* server `statement_timeout` / `lock_timeout` — PostgreSQL itself cancels a slow + statement or a statement stuck behind a lock; +* client deadline — covers what the server cannot report, e.g. a + paused/frozen PostgreSQL container or a dead network. + +The client deadline needs care: when a psycopg query is cancelled, psycopg sends a +cancel request to the server and waits for it (up to 5 s + 5 s) before giving up. +With a frozen server that would stretch a 3 s deadline to 13 s. Therefore every unit +of work runs as its own task: at the deadline the request stops waiting and gets 503 +at once, while the task finishes its cleanup (cancel, close, return to the pool) in +the background. Any failure becomes 503 `unavailable` — never 401, never a hang. +""" +from __future__ import annotations + +import asyncio +import logging +from collections.abc import Awaitable, Callable +from typing import TypeVar + +import psycopg +from psycopg_pool import AsyncConnectionPool, PoolTimeout + +from .config import Settings +from .errors import Unavailable + +log = logging.getLogger("messenger.db") + +T = TypeVar("T") +Work = Callable[[psycopg.AsyncConnection], Awaitable[T]] + +# Errors that mean "the database is unavailable right now", not "the request is wrong". +# QueryCanceled (statement_timeout), LockNotAvailable (lock_timeout) and AdminShutdown +# (server restart) are subclasses of OperationalError. +UNAVAILABLE_ERRORS = (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout, TimeoutError) + + +def _forget(task: asyncio.Task) -> None: + """Done-callback for abandoned tasks: retrieve the result so nothing is logged as 'never retrieved'.""" + if not task.cancelled(): + task.exception() + + +class Database: + def __init__(self, settings: Settings): + self.deadline = settings.db_timeout_seconds + options = ( + f"-c statement_timeout={settings.db_statement_timeout_ms} " + f"-c lock_timeout={max(100, settings.db_statement_timeout_ms // 2)} " + "-c idle_in_transaction_session_timeout=10000" + ) + self.pool = AsyncConnectionPool( + conninfo=settings.database_url, + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + timeout=settings.db_timeout_seconds, # max wait for a free connection + open=False, + name="messenger", + check=AsyncConnectionPool.check_connection, # drop connections broken by a DB restart + kwargs={ + "options": options, + "connect_timeout": max(1, int(settings.db_timeout_seconds)), + "application_name": "messenger-api", + }, + ) + + async def open(self) -> None: + # wait=False: the API starts (liveness 200) even if PostgreSQL is not up yet; + # readiness stays 503 until the database answers. + await self.pool.open(wait=False) + + async def close(self) -> None: + await self.pool.close(timeout=2) + + async def run(self, work: Work[T], deadline: float | None = None) -> T: + """Run `work(conn)` in one transaction (COMMIT on success, ROLLBACK on any exception). + + Domain errors raised by `work` (NotFound, Conflict, ...) propagate unchanged; + database unavailability and the deadline become Unavailable (503). + """ + async def unit() -> T: + async with self.pool.connection() as conn: + async with conn.transaction(): + return await work(conn) + + task = asyncio.ensure_future(unit()) + try: + return await asyncio.wait_for(asyncio.shield(task), deadline or self.deadline) + except UNAVAILABLE_ERRORS as exc: + log.warning("database_unavailable", extra={"fields": {"error": type(exc).__name__}}) + raise Unavailable("База данных временно недоступна") from None + finally: + if not task.done(): + # Deadline or cancelled request: stop waiting now, let psycopg clean up later. + task.cancel() + task.add_done_callback(_forget) + + async def ping(self, timeout: float = 1.0) -> bool: + async def select_one(conn: psycopg.AsyncConnection) -> None: + await conn.execute("SELECT 1") + try: + await self.run(select_one, deadline=timeout) + return True + except Unavailable: + return False diff --git a/src/messenger/errors.py b/src/messenger/errors.py index c1fe3096..22dbe74a 100644 --- a/src/messenger/errors.py +++ b/src/messenger/errors.py @@ -1,6 +1,9 @@ """Domain errors mapped 1:1 to the contract error codes (contracts/README.md).""" from __future__ import annotations +BEARER_CHALLENGE = 'Bearer realm="messenger"' +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' + class ApiError(Exception): status = 500 @@ -11,6 +14,10 @@ class ApiError(Exception): self.message = message or self.default_message super().__init__(self.message) + @property + def headers(self) -> dict[str, str]: + return {} + class InvalidRequest(ApiError): status = 400 @@ -19,9 +26,19 @@ class InvalidRequest(ApiError): class Unauthorized(ApiError): + """401 with the challenge of the scheme the endpoint expects (RFC 7235).""" + status = 401 code = "unauthorized" - default_message = "Требуется X-User-Id существующего пользователя" + default_message = "Требуется действительная сессия" + + def __init__(self, message: str | None = None, challenge: str = BEARER_CHALLENGE): + super().__init__(message) + self.challenge = challenge + + @property + def headers(self) -> dict[str, str]: + return {"WWW-Authenticate": self.challenge} class NotFound(ApiError): diff --git a/src/messenger/migrate.py b/src/messenger/migrate.py new file mode 100644 index 00000000..10b18e9f --- /dev/null +++ b/src/messenger/migrate.py @@ -0,0 +1,76 @@ +"""Versioned SQL migrations: `python -m messenger.migrate` (compose service `migrate`). + +* Files `migrations/NNNN_name.sql` are applied in name order, each in its own + transaction together with its row in `schema_migrations` (DDL is transactional + in PostgreSQL, so a failed migration leaves nothing behind). +* Re-running is safe: applied versions are skipped, so data is never duplicated. +* The SHA-256 of every applied file is stored; if an applied file was edited later, + the run stops instead of silently diverging from the real schema. +* `pg_advisory_lock` serialises concurrent runs (two API replicas starting at once). +""" +from __future__ import annotations + +import hashlib +import sys +import time +from pathlib import Path + +import psycopg + +from .config import ConfigError, _secret + +MIGRATIONS_DIR = Path(__file__).resolve().parents[2] / "migrations" +LOCK_ID = 2026_02 # arbitrary application-wide advisory lock id + + +def say(text: str) -> None: + print(f"migrate: {text}", flush=True) + + +def connect(url: str, wait_seconds: float = 60) -> psycopg.Connection: + deadline = time.monotonic() + wait_seconds + while True: + try: + return psycopg.connect(url, autocommit=True, connect_timeout=3, application_name="messenger-migrate") + except psycopg.OperationalError as exc: + if time.monotonic() > deadline: + raise SystemExit(f"migrate: database is not reachable: {type(exc).__name__}") from None + time.sleep(1) + + +def main() -> int: + try: + url = _secret("DATABASE_URL", required=True) + except ConfigError as exc: + print(f"configuration error: {exc}", file=sys.stderr) + return 2 + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + with connect(url) as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + try: + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + " version text PRIMARY KEY, checksum text NOT NULL," + " applied_at timestamptz NOT NULL DEFAULT now())") + applied = dict(conn.execute("SELECT version, checksum FROM schema_migrations").fetchall()) + for path in files: + version, sql = path.stem, path.read_bytes() + checksum = hashlib.sha256(sql).hexdigest() + if version in applied: + if applied[version] != checksum: + say(f"{version}: file changed after it was applied; create a new migration instead") + return 1 + say(f"{version}: already applied, skipped") + continue + with conn.transaction(): + conn.execute(sql.decode("utf-8")) + conn.execute("INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)", (version, checksum)) + say(f"{version}: applied") + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,)) + say(f"done, {len(files)} migration file(s) checked") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/messenger/passwords.py b/src/messenger/passwords.py new file mode 100644 index 00000000..a1fc35ad --- /dev/null +++ b/src/messenger/passwords.py @@ -0,0 +1,53 @@ +"""Password hashing with Argon2id (memory-hard password KDF; also mandatory in lab 7). + +* Parameters follow the OWASP minimum for Argon2id: m=19 MiB, t=2, p=1. Unlike bcrypt + there is no 72-byte limit, so any 12-128 code point UTF-8 password is hashed whole. +* Hashing takes tens of milliseconds of CPU and 19 MiB of RAM. It runs in a worker + thread (argon2-cffi releases the GIL), so the event loop keeps serving other + requests, and a semaphore caps parallel hashes (memory/CPU DoS protection). +* An unknown username is checked against a dummy hash, so "no such user" and + "wrong password" take the same time and return the same 401. +""" +from __future__ import annotations + +import asyncio + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError + +_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1, hash_len=32, salt_len=16) +_semaphore: asyncio.Semaphore | None = None +_dummy_hash: str | None = None + + +def configure(concurrency: int) -> None: + global _semaphore + _semaphore = asyncio.Semaphore(concurrency) + + +async def _run(func, *args): + if _semaphore is None: + configure(2) + async with _semaphore: + return await asyncio.to_thread(func, *args) + + +async def hash_password(password: str) -> str: + return await _run(_hasher.hash, password) + + +def _verify(stored_hash: str, password: str) -> bool: + try: + return _hasher.verify(stored_hash, password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False + + +async def verify_password(stored_hash: str | None, password: str) -> bool: + global _dummy_hash + if stored_hash is None: + if _dummy_hash is None: + _dummy_hash = await hash_password("dummy-password-for-timing") + await _run(_verify, _dummy_hash, password) + return False + return await _run(_verify, stored_hash, password) diff --git a/src/messenger/repo.py b/src/messenger/repo.py new file mode 100644 index 00000000..4ae4d952 --- /dev/null +++ b/src/messenger/repo.py @@ -0,0 +1,244 @@ +"""SQL for users, chats and messages. All statements are parameterised (%s placeholders): +values travel separately from the SQL text, so input can never change the query. + +Free text is stored as UTF-8 BYTEA (PostgreSQL TEXT cannot hold U+0000), so it is +encoded on the way in and decoded on the way out. See docs/DATA_MODEL.md. +""" +from __future__ import annotations + +import datetime as dt +import uuid +from dataclasses import dataclass + +import psycopg +from psycopg import errors as pg_errors + +from .cursor import SortKey +from .db import Database +from .errors import Conflict, InvalidRequest, NotFound +from .timefmt import from_us, rfc3339, to_us + + +def _b(text: str) -> bytes: + return text.encode("utf-8") + + +def _s(raw: bytes | memoryview) -> str: + return bytes(raw).decode("utf-8") + + +@dataclass(slots=True, frozen=True) +class User: + id: str + username: str + display_name: str + created_at: dt.datetime + + def to_json(self) -> dict: + return {"id": self.id, "username": self.username, "display_name": self.display_name, + "created_at": rfc3339(self.created_at)} + + +@dataclass(slots=True, frozen=True) +class Chat: + id: str + title: str + member_ids: tuple[str, ...] + created_at: dt.datetime + + @property + def key(self) -> SortKey: + return (to_us(self.created_at), self.id) + + def to_json(self) -> dict: + return {"id": self.id, "title": self.title, "member_ids": list(self.member_ids), + "created_at": rfc3339(self.created_at)} + + +@dataclass(slots=True, frozen=True) +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: dt.datetime + + @property + def key(self) -> SortKey: + return (to_us(self.created_at), self.id) + + def to_json(self) -> dict: + return {"id": self.id, "chat_id": self.chat_id, "sender_id": self.sender_id, "text": self.text, + "created_at": rfc3339(self.created_at)} + + +def _user(row) -> User: + return User(str(row[0]), row[1], _s(row[2]), row[3]) + + +# ------------------------------------------------------------------ users +async def create_user(db: Database, username: str, display_name: str, password_hash: str) -> User: + async def work(conn: psycopg.AsyncConnection) -> User: + cur = await conn.execute( + "INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s) " + "RETURNING id, username, display_name, created_at", + (uuid.uuid4(), username, _b(display_name), password_hash)) + return _user(await cur.fetchone()) + try: + return await db.run(work) + except pg_errors.UniqueViolation: + # Two concurrent registrations: the unique index lets exactly one INSERT commit. + raise Conflict("Имя пользователя уже занято") from None + + +async def get_user(db: Database, user_id: str) -> User | None: + async def work(conn: psycopg.AsyncConnection) -> User | None: + cur = await conn.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)) + row = await cur.fetchone() + return _user(row) if row else None + return await db.run(work) + + +async def get_credentials(db: Database, username: str) -> tuple[User, str] | None: + async def work(conn: psycopg.AsyncConnection) -> tuple[User, str] | None: + cur = await conn.execute( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", + (username,)) + row = await cur.fetchone() + return (_user(row), row[4]) if row else None + return await db.run(work) + + +# ------------------------------------------------------------------ chats +async def create_chat(db: Database, creator_id: str, title: str, member_ids: list[str]) -> Chat: + """Atomic: the chat row and all memberships commit together or not at all. + + The chat is inserted FIRST; an unknown member then fails the membership INSERT + with a foreign-key violation and the whole transaction (chat row included) is + rolled back. student-tests check that nothing is left behind. + """ + if creator_id not in member_ids: + raise InvalidRequest("member_ids должен включать текущего пользователя") + chat_id = uuid.uuid4() + + async def work(conn: psycopg.AsyncConnection) -> dt.datetime: + cur = await conn.execute( + "INSERT INTO chats (id, title, created_by) VALUES (%s, %s, %s) RETURNING created_at", + (chat_id, _b(title), creator_id)) + (created_at,) = await cur.fetchone() + await conn.execute( + "INSERT INTO chat_members (chat_id, user_id, position, chat_created_at) " + "SELECT %s, m.user_id, m.ord - 1, %s " + "FROM unnest(%s::uuid[]) WITH ORDINALITY AS m(user_id, ord)", + (chat_id, created_at, member_ids)) + return created_at + try: + created_at = await db.run(work) + except pg_errors.ForeignKeyViolation: + raise InvalidRequest("member_ids содержит несуществующих пользователей") from None + return Chat(str(chat_id), title, tuple(member_ids), created_at) + + +async def _load_chats(conn: psycopg.AsyncConnection, rows) -> list[Chat]: + if not rows: + return [] + ids = [r[0] for r in rows] + cur = await conn.execute( + "SELECT chat_id, user_id FROM chat_members WHERE chat_id = ANY(%s) ORDER BY chat_id, position", (ids,)) + members: dict[uuid.UUID, list[str]] = {i: [] for i in ids} + for chat_id, user_id in await cur.fetchall(): + members[chat_id].append(str(user_id)) + return [Chat(str(r[0]), _s(r[1]), tuple(members[r[0]]), r[2]) for r in rows] + + +async def get_chat(db: Database, user_id: str, chat_id: str) -> Chat: + """The chat if the user is a member; a missing chat and a foreign chat are both 404.""" + async def work(conn: psycopg.AsyncConnection) -> Chat: + cur = await conn.execute( + "SELECT c.id, c.title, c.created_at FROM chats c " + "JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s WHERE c.id = %s", + (user_id, chat_id)) + row = await cur.fetchone() + if row is None: + raise NotFound("Чат не найден") + return (await _load_chats(conn, [row]))[0] + return await db.run(work) + + +async def _check_member(conn: psycopg.AsyncConnection, user_id: str, chat_id: str) -> None: + cur = await conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)) + if await cur.fetchone() is None: + raise NotFound("Чат не найден") + + +async def ensure_member(db: Database, user_id: str, chat_id: str) -> None: + async def work(conn: psycopg.AsyncConnection) -> None: + await _check_member(conn, user_id, chat_id) + await db.run(work) + + +async def list_chats(db: Database, user_id: str, after: SortKey | None, limit: int) -> tuple[list[Chat], bool]: + async def work(conn: psycopg.AsyncConnection) -> tuple[list[Chat], bool]: + if after is None: + cur = await conn.execute( + "SELECT c.id, c.title, c.created_at FROM chat_members m JOIN chats c ON c.id = m.chat_id " + "WHERE m.user_id = %s ORDER BY m.chat_created_at, m.chat_id LIMIT %s", + (user_id, limit + 1)) + else: + cur = await conn.execute( + "SELECT c.id, c.title, c.created_at FROM chat_members m JOIN chats c ON c.id = m.chat_id " + "WHERE m.user_id = %s AND (m.chat_created_at, m.chat_id) > (%s, %s) " + "ORDER BY m.chat_created_at, m.chat_id LIMIT %s", + (user_id, from_us(after[0]), after[1], limit + 1)) + rows = await cur.fetchall() + return await _load_chats(conn, rows[:limit]), len(rows) > limit + return await db.run(work) + + +# ------------------------------------------------------------------ messages +async def add_message(db: Database, user_id: str, chat_id: str, text: str) -> Message: + """Insert with a per-chat strictly increasing timestamp. + + `UPDATE chats ... RETURNING` locks the chat row until COMMIT, so writers of one + chat are serialised: a message with a smaller created_at can never commit after + a message with a bigger one, and a reader paging by cursor cannot skip it. + """ + message_id = uuid.uuid4() + + async def work(conn: psycopg.AsyncConnection) -> dt.datetime: + await _check_member(conn, user_id, chat_id) + cur = await conn.execute( + "UPDATE chats SET last_message_at = greatest(clock_timestamp(), " + "last_message_at + interval '1 microsecond') WHERE id = %s RETURNING last_message_at", + (chat_id,)) + (created_at,) = await cur.fetchone() + await conn.execute( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES (%s, %s, %s, %s, %s)", + (message_id, chat_id, user_id, _b(text), created_at)) + return created_at + created_at = await db.run(work) + return Message(str(message_id), chat_id, user_id, text, created_at) + + +# Two statements instead of one with "(%s IS NULL OR ...)": with a generic plan the OR +# would push the cursor into a Filter and late pages would scan the whole prefix. +HISTORY_FIRST = ( + "SELECT id, sender_id, text, created_at FROM messages " + "WHERE chat_id = %s ORDER BY created_at, id LIMIT %s") +HISTORY_AFTER = ( + "SELECT id, sender_id, text, created_at FROM messages " + "WHERE chat_id = %s AND (created_at, id) > (%s, %s) ORDER BY created_at, id LIMIT %s") + + +async def list_messages(db: Database, chat_id: str, after: SortKey | None, limit: int) -> tuple[list[Message], bool]: + async def work(conn: psycopg.AsyncConnection) -> list: + if after is None: + cur = await conn.execute(HISTORY_FIRST, (chat_id, limit + 1)) + else: + cur = await conn.execute(HISTORY_AFTER, (chat_id, from_us(after[0]), after[1], limit + 1)) + return await cur.fetchall() + rows = await db.run(work) + items = [Message(str(r[0]), chat_id, str(r[1]), _s(r[2]), r[3]) for r in rows[:limit]] + return items, len(rows) > limit diff --git a/src/messenger/sessions.py b/src/messenger/sessions.py new file mode 100644 index 00000000..53736e44 --- /dev/null +++ b/src/messenger/sessions.py @@ -0,0 +1,160 @@ +"""Server-side sessions behind an opaque Bearer token. + +* Token: `secrets.token_urlsafe(32)` = 256 random bits. Only SHA-256(token) is + stored, so a leaked database/AOF does not contain usable tokens. A fast hash is + enough for a 256-bit random value; passwords need a slow KDF (passwords.py). +* Expiry is absolute: `expires_at = login time + SESSION_TTL_SECONDS`. Every lookup + compares it with the current time, and a restart never extends it. + +Two interchangeable stores (SESSION_STORE): + +* `valkey` (compose default): the ONLY copy of a session is a Valkey key with + `PXAT expires_at`, persisted by AOF with `appendfsync always`. There is no second + copy (no cache over PostgreSQL), so a logout cannot be "forgotten" and a revoked + token cannot come back after Valkey fails and recovers. If Valkey is unreachable + a session cannot be checked: protected requests and logout get 503, never access. +* `postgres`: table `sessions` (migrations/0001_init.sql). +""" +from __future__ import annotations + +import asyncio +import datetime as dt +import hashlib +import json +import logging +import secrets +from typing import Protocol + +from redis import exceptions as redis_errors +from redis.asyncio import Redis +from redis.backoff import NoBackoff +from redis.retry import Retry + +from .config import Settings +from .db import Database +from .errors import Unavailable +from .timefmt import UTC, from_us, to_us + +log = logging.getLogger("messenger.sessions") + + +def new_token() -> str: + return secrets.token_urlsafe(32) + + +def token_hash(token: str) -> bytes: + return hashlib.sha256(token.encode("ascii")).digest() + + +def now() -> dt.datetime: + return dt.datetime.now(UTC) + + +class SessionStore(Protocol): + name: str + + async def create(self, user_id: str, ttl_seconds: int) -> tuple[str, dt.datetime]: ... + async def user_id_for(self, token: str) -> str | None: ... + async def revoke(self, token: str) -> bool: ... + async def ping(self) -> bool: ... + async def close(self) -> None: ... + + +class PostgresSessionStore: + name = "postgres" + + def __init__(self, db: Database): + self.db = db + + async def create(self, user_id: str, ttl_seconds: int) -> tuple[str, dt.datetime]: + token = new_token() + expires_at = now() + dt.timedelta(seconds=ttl_seconds) + + async def work(conn) -> None: + await conn.execute( + "INSERT INTO sessions (token_hash, user_id, expires_at) VALUES (%s, %s, %s)", + (token_hash(token), user_id, expires_at)) + # Housekeeping: drop this user's expired sessions (bounded by the user's own rows). + await conn.execute("DELETE FROM sessions WHERE user_id = %s AND expires_at <= %s", (user_id, now())) + await self.db.run(work) + return token, expires_at + + async def user_id_for(self, token: str) -> str | None: + async def work(conn): + cur = await conn.execute( + "SELECT user_id FROM sessions WHERE token_hash = %s AND expires_at > %s", (token_hash(token), now())) + return await cur.fetchone() + row = await self.db.run(work) + return str(row[0]) if row else None + + async def revoke(self, token: str) -> bool: + async def work(conn) -> bool: + cur = await conn.execute( + "DELETE FROM sessions WHERE token_hash = %s AND expires_at > %s", (token_hash(token), now())) + return cur.rowcount == 1 + return await self.db.run(work) + + async def ping(self) -> bool: + return True # covered by the database readiness check + + async def close(self) -> None: + return None + + +class ValkeySessionStore: + name = "valkey" + PREFIX = "session:" + + def __init__(self, settings: Settings): + self.timeout = settings.cache_timeout_seconds + self.client = Redis.from_url( + settings.cache_url, + socket_timeout=self.timeout, + socket_connect_timeout=self.timeout, + retry=Retry(NoBackoff(), 0), # no hidden retries: a failure is reported at once + decode_responses=False, + ) + + def _key(self, token: str) -> str: + return self.PREFIX + token_hash(token).hex() + + async def _call(self, coro): + try: + async with asyncio.timeout(self.timeout * 2): + return await coro + except (redis_errors.ConnectionError, redis_errors.TimeoutError, TimeoutError, OSError) as exc: + log.warning("session_store_unavailable", extra={"fields": {"error": type(exc).__name__}}) + raise Unavailable("Хранилище сессий временно недоступно") from None + + async def create(self, user_id: str, ttl_seconds: int) -> tuple[str, dt.datetime]: + token = new_token() + expires_at = now() + dt.timedelta(seconds=ttl_seconds) + value = json.dumps({"user_id": user_id, "expires_at_us": to_us(expires_at)}).encode() + # PXAT = absolute expiry time: survives restarts (AOF) without being extended. + await self._call(self.client.set(self._key(token), value, pxat=to_us(expires_at) // 1000)) + return token, expires_at + + async def user_id_for(self, token: str) -> str | None: + raw = await self._call(self.client.get(self._key(token))) + if raw is None: + return None + data = json.loads(raw) + if from_us(data["expires_at_us"]) <= now(): + return None # do not rely only on Valkey's lazy expiry + return data["user_id"] + + async def revoke(self, token: str) -> bool: + return await self._call(self.client.delete(self._key(token))) == 1 + + async def ping(self) -> bool: + try: + return bool(await self._call(self.client.ping())) + except Unavailable: + return False + + async def close(self) -> None: + await self.client.aclose() + + +def build_store(settings: Settings, db: Database) -> SessionStore: + return ValkeySessionStore(settings) if settings.session_store == "valkey" else PostgresSessionStore(db) diff --git a/src/messenger/store.py b/src/messenger/store.py deleted file mode 100644 index 881a8c84..00000000 --- a/src/messenger/store.py +++ /dev/null @@ -1,191 +0,0 @@ -"""In-memory state of the messenger: the single source of truth for lab 1. - -Concurrency model ------------------ -All data lives in ordinary dicts/lists of ONE process. Every public method -takes `self._lock` for its whole critical section, so each operation is atomic -and readers never see a half-built chat or message. - -The server runs coroutines on one asyncio event loop, and store methods never -`await`, so on the event loop they are already atomic. The lock additionally -protects the store when it is used from several threads (student-tests start -10 threads that write concurrently) and documents the invariant explicitly. - -Ordering invariant ------------------- -`created_at` is assigned INSIDE the same critical section that appends the -object, from a strictly increasing clock (`_next_ts`). Therefore the append -order of every list equals the contract order `(created_at, id)` even under -concurrent writes and even if the wall clock jumps backwards. -""" -from __future__ import annotations - -import bisect -import datetime as dt -import operator -import threading -import time -import uuid -from dataclasses import dataclass -from typing import Callable - -from .cursor import SortKey -from .errors import Conflict, InvalidRequest, NotFound - -_EPOCH = dt.datetime(1970, 1, 1, tzinfo=dt.timezone.utc) -# (created_at, id) of a Chat/Message as a C-level getter: cheap to call inside bisect. -_sort_key = operator.attrgetter("ts", "id") - - -def format_ts(ts_us: int) -> str: - """RFC 3339 UTC with fixed microsecond precision, e.g. 2026-09-25T12:00:00.000001Z.""" - return (_EPOCH + dt.timedelta(microseconds=ts_us)).strftime("%Y-%m-%dT%H:%M:%S.%fZ") - - -@dataclass(slots=True, frozen=True) -class User: - id: str - username: str - display_name: str - ts: int - created_at: str - - def to_json(self) -> dict: - return {"id": self.id, "username": self.username, "display_name": self.display_name, "created_at": self.created_at} - - -@dataclass(slots=True, frozen=True) -class Chat: - id: str - title: str - member_ids: tuple[str, ...] - members: frozenset[str] - ts: int - created_at: str - - @property - def key(self) -> SortKey: - return (self.ts, self.id) - - def to_json(self) -> dict: - return {"id": self.id, "title": self.title, "member_ids": list(self.member_ids), "created_at": self.created_at} - - -@dataclass(slots=True, frozen=True) -class Message: - id: str - chat_id: str - sender_id: str - text: str - ts: int - created_at: str - - @property - def key(self) -> SortKey: - return (self.ts, self.id) - - def to_json(self) -> dict: - return {"id": self.id, "chat_id": self.chat_id, "sender_id": self.sender_id, "text": self.text, "created_at": self.created_at} - - -def _page_after(items: list, after: SortKey | None, limit: int) -> tuple[list, bool]: - """Keyset page: up to `limit` items strictly after `after`, plus "has more". - - `items` is always sorted by (created_at, id) (see the ordering invariant), so - the page start is found by binary search in O(log n) instead of scanning the - history from the beginning (O(n)); only the page itself is copied. - """ - start = 0 if after is None else bisect.bisect_right(items, after, key=_sort_key) - page = items[start:start + limit + 1] - return page[:limit], len(page) > limit - - -class Store: - def __init__(self, clock_ns: Callable[[], int] = time.time_ns): - self._lock = threading.Lock() - self._clock_ns = clock_ns - self._last_ts = 0 - self._users: dict[str, User] = {} - self._user_ids_by_name: dict[str, str] = {} - self._chats: dict[str, Chat] = {} - self._chats_by_user: dict[str, list[Chat]] = {} - self._messages: dict[str, list[Message]] = {} - - # -- helpers (caller holds the lock) --------------------------------- - def _next_ts(self) -> tuple[int, str]: - """Strictly increasing server time in microseconds; must be called under the lock.""" - ts = max(self._clock_ns() // 1000, self._last_ts + 1) - self._last_ts = ts - return ts, format_ts(ts) - - def _chat_for_member(self, user_id: str, chat_id: str) -> Chat: - chat = self._chats.get(chat_id) - # A missing chat and a foreign chat are indistinguishable: both 404. - if chat is None or user_id not in chat.members: - raise NotFound("Чат не найден") - return chat - - # -- users ----------------------------------------------------------- - def create_user(self, username: str, display_name: str) -> User: - with self._lock: - if username in self._user_ids_by_name: - raise Conflict("Имя пользователя уже занято") - ts, created_at = self._next_ts() - user = User(str(uuid.uuid4()), username, display_name, ts, created_at) - self._users[user.id] = user - self._user_ids_by_name[username] = user.id - self._chats_by_user[user.id] = [] - return user - - def get_user(self, user_id: str) -> User | None: - with self._lock: - return self._users.get(user_id) - - # -- chats ----------------------------------------------------------- - def create_chat(self, creator_id: str, title: str, member_ids: list[str]) -> Chat: - with self._lock: - if creator_id not in member_ids: - raise InvalidRequest("member_ids должен включать текущего пользователя") - if any(member not in self._users for member in member_ids): - raise InvalidRequest("member_ids содержит несуществующих пользователей") - ts, created_at = self._next_ts() - chat = Chat(str(uuid.uuid4()), title, tuple(member_ids), frozenset(member_ids), ts, created_at) - # All indexes are updated in one critical section: the chat is created atomically. - self._chats[chat.id] = chat - self._messages[chat.id] = [] - for member in member_ids: - self._chats_by_user[member].append(chat) - return chat - - def get_chat(self, user_id: str, chat_id: str) -> Chat: - with self._lock: - return self._chat_for_member(user_id, chat_id) - - def list_chats(self, user_id: str, after: SortKey | None, limit: int) -> tuple[list[Chat], bool]: - """Page of the user's chats ordered by (created_at, id); returns (items, has_more).""" - with self._lock: - return _page_after(self._chats_by_user[user_id], after, limit) - - # -- messages -------------------------------------------------------- - def add_message(self, user_id: str, chat_id: str, text: str) -> Message: - with self._lock: - chat = self._chat_for_member(user_id, chat_id) - ts, created_at = self._next_ts() - message = Message(str(uuid.uuid4()), chat.id, user_id, text, ts, created_at) - self._messages[chat.id].append(message) - return message - - def list_messages(self, user_id: str, chat_id: str, after: SortKey | None, limit: int) -> tuple[list[Message], bool]: - """Page of history strictly after `after` in (created_at, id) order; returns (items, has_more).""" - with self._lock: - chat = self._chat_for_member(user_id, chat_id) - return _page_after(self._messages[chat.id], after, limit) - - # -- diagnostics ----------------------------------------------------- - def counts(self) -> dict[str, int]: - with self._lock: - return { - "users": len(self._users), - "chats": len(self._chats), - "messages": sum(len(h) for h in self._messages.values()), - } diff --git a/src/messenger/timefmt.py b/src/messenger/timefmt.py new file mode 100644 index 00000000..9c33b12f --- /dev/null +++ b/src/messenger/timefmt.py @@ -0,0 +1,22 @@ +"""Conversions between PostgreSQL timestamptz values, cursor integers and RFC 3339 strings.""" +from __future__ import annotations + +import datetime as dt + +UTC = dt.timezone.utc +_EPOCH = dt.datetime(1970, 1, 1, tzinfo=UTC) + + +def to_us(value: dt.datetime) -> int: + """Microseconds since the Unix epoch (exact: timestamptz has microsecond precision).""" + delta = value - _EPOCH + return (delta.days * 86_400 + delta.seconds) * 1_000_000 + delta.microseconds + + +def from_us(us: int) -> dt.datetime: + return _EPOCH + dt.timedelta(microseconds=us) + + +def rfc3339(value: dt.datetime) -> str: + """RFC 3339 UTC with fixed microsecond precision, e.g. 2026-10-12T12:00:00.000001Z.""" + return value.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%S.%fZ") diff --git a/src/messenger/validation.py b/src/messenger/validation.py index 6619324d..87670955 100644 --- a/src/messenger/validation.py +++ b/src/messenger/validation.py @@ -70,6 +70,20 @@ def username_field(data: dict[str, Any]) -> str: return value +def password_field(data: dict[str, Any]) -> str: + """12-128 Unicode code points, not whitespace-only; any other character (':' too) is allowed.""" + value = data["password"] + if not isinstance(value, str): + raise InvalidRequest("Поле password должно быть строкой") + if SURROGATES_RE.search(value): + raise InvalidRequest("Поле password содержит недопустимые символы") + if not 12 <= len(value) <= 128: + raise InvalidRequest("Длина пароля должна быть от 12 до 128 символов") + if value.strip() == "": + raise InvalidRequest("Пароль не может состоять только из пробелов") + return value + + def parse_uuid(value: Any, what: str = "UUID") -> str: if not isinstance(value, str) or UUID_RE.fullmatch(value) is None: raise InvalidRequest(f"Неверный {what}") -- 2.54.0 From a8c6af8c7d21359e5f952d74d3f27183af59fbe4 Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Mon, 12 Oct 2026 19:34:49 +0300 Subject: [PATCH 3/7] =?UTF-8?q?test:=20=D1=81=D0=BE=D0=B1=D1=81=D1=82?= =?UTF-8?q?=D0=B2=D0=B5=D0=BD=D0=BD=D1=8B=D0=B5=20=D1=82=D0=B5=D1=81=D1=82?= =?UTF-8?q?=D1=8B=20lab2=20(unit,=20API,=20=D0=91=D0=94,=20=D0=BE=D1=82?= =?UTF-8?q?=D0=BA=D0=B0=D0=B7=D1=8B,=20=D1=81=D0=B5=D1=81=D1=81=D0=B8?= =?UTF-8?q?=D0=B8,=20EXPLAIN)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Гонка регистрации (ровно 1x201 + 7x409, одна строка), rollback после первого INSERT, повтор миграций, 10x10 сообщений, отказ/пауза PostgreSQL и Valkey с действующим токеном (503 в пределах дедлайна, восстановление в finally), lock_timeout, logout при отказе Valkey, короткий TTL, SESSION_STORE=postgres, EXPLAIN поздней страницы при generic plan. Co-Authored-By: Claude Opus 5.5 --- Makefile | 35 ++++ scripts/explain_history.py | 114 ++++++++++++ student-tests/conftest.py | 199 ++++++++++++++++---- student-tests/http_concurrency.py | 134 -------------- student-tests/test_api.py | 201 +++++++++++++++++++++ student-tests/test_chats_and_messages.py | 219 ----------------------- student-tests/test_db.py | 114 ++++++++++++ student-tests/test_explain.py | 35 ++++ student-tests/test_failures.py | 99 ++++++++++ student-tests/test_sessions.py | 64 +++++++ student-tests/test_store_concurrency.py | 131 -------------- student-tests/test_users_and_errors.py | 139 -------------- student-tests/unit/test_unit.py | 134 ++++++++++++++ 13 files changed, 963 insertions(+), 655 deletions(-) create mode 100644 scripts/explain_history.py delete mode 100644 student-tests/http_concurrency.py create mode 100644 student-tests/test_api.py delete mode 100644 student-tests/test_chats_and_messages.py create mode 100644 student-tests/test_db.py create mode 100644 student-tests/test_explain.py create mode 100644 student-tests/test_failures.py create mode 100644 student-tests/test_sessions.py delete mode 100644 student-tests/test_store_concurrency.py delete mode 100644 student-tests/test_users_and_errors.py create mode 100644 student-tests/unit/test_unit.py diff --git a/Makefile b/Makefile index 9ecb223e..521949ac 100644 --- a/Makefile +++ b/Makefile @@ -24,3 +24,38 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# --------------------------------------------------------------------------- +# Student solution (lab 2, Python). On Windows without make run the commands from +# REPORT.md directly (public tests there need PYTHONUTF8=1; restart hook: scripts/restart.cmd). +.PHONY: secrets up down logs ps migrate student-test unit-test explain + +secrets: + $(PYTHON) scripts/init_secrets.py + +# Build, apply migrations (service migrate) and wait until every service is healthy. +up: secrets + docker compose up -d --build --wait + +# Safe stop: containers stop, named volumes (data) stay. +down: + docker compose down + +logs: + docker compose logs --tail 50 api + +ps: + docker compose ps + +migrate: + docker compose run --rm migrate + +# Own tests: unit + black-box against the running stand (needs requirements*.txt in a venv). +student-test: + $(PYTHON) -m pytest student-tests -v + +unit-test: + $(PYTHON) -m pytest student-tests -m "not stack" -q + +explain: + $(PYTHON) scripts/explain_history.py --output evidence/explain-history.txt diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..0a929edb --- /dev/null +++ b/scripts/explain_history.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +"""EXPLAIN (ANALYZE, BUFFERS) of the history query on >= 10 000 messages (level 4). + + python scripts/explain_history.py --output evidence/explain-history.txt + +Creates (once, idempotent) a synthetic chat with 20 000 messages plus 30 000 messages in +30 other chats, then explains the EXACT statements of src/messenger/repo.py: + 1. first page (HISTORY_FIRST) + 2. late page via cursor (HISTORY_AFTER) — generic plan forced, as a prepared statement + reused by the driver would get it + 3. the rejected variant `($2 IS NULL OR (created_at, id) > ...)` — generic plan + 4. the rejected OFFSET pagination for the same late page +Runs psql inside the postgres container; no database port is published. +""" +from __future__ import annotations + +import argparse +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "src")) +from messenger.repo import HISTORY_AFTER, HISTORY_FIRST # noqa: E402 (the app's real SQL) + +CHAT = "00000000-0000-4000-8000-00000000e002" +USER = "00000000-0000-4000-8000-00000000e001" +TARGET = 20_000 +LATE = 19_950 # cursor position: the 50 newest messages remain + +SEED = f""" +\\set ON_ERROR_STOP on +BEGIN; +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('{USER}', 'explain_seed', convert_to('Explain seed', 'UTF8'), 'not-a-login') ON CONFLICT DO NOTHING; +INSERT INTO chats (id, title, created_by, created_at) +SELECT ('00000000-0000-4000-8000-0000000' || lpad(to_hex(n), 5, '0'))::uuid, convert_to('explain ' || n, 'UTF8'), + '{USER}', timestamptz '2026-01-01 00:00:00+00' +FROM generate_series(57346::int, 57376::int) AS n -- e002 .. e020: target + 30 noise chats +ON CONFLICT DO NOTHING; +INSERT INTO chat_members (chat_id, user_id, position, chat_created_at) +SELECT id, '{USER}', 0, created_at FROM chats WHERE created_by = '{USER}' ON CONFLICT DO NOTHING; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), '{CHAT}', '{USER}', convert_to('synthetic message ' || g, 'UTF8'), + timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second' +FROM generate_series(1::int, {TARGET}::int) AS g +WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '{CHAT}'); +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), c.id, '{USER}', convert_to('noise ' || g, 'UTF8'), + timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second' +FROM chats c CROSS JOIN generate_series(1::int, 1000::int) AS g +WHERE c.created_by = '{USER}' AND c.id <> '{CHAT}' + AND NOT EXISTS (SELECT 1 FROM messages m WHERE m.chat_id = c.id); +COMMIT; +ANALYZE messages; +""" + + +def pg(sql_param: str) -> str: + """Turn psycopg %s placeholders into $1..$n for a PREPARE statement.""" + parts = sql_param.split("%s") + return "".join(p + (f"${i + 1}" if i < len(parts) - 1 else "") for i, p in enumerate(parts)) + + +EXPLAIN = f""" +\\set ON_ERROR_STOP on +\\pset pager off +SELECT count(*) AS messages_total, count(*) FILTER (WHERE chat_id = '{CHAT}') AS messages_in_target_chat FROM messages; +SELECT created_at AS cur_ts, id AS cur_id FROM messages WHERE chat_id = '{CHAT}' +ORDER BY created_at, id OFFSET {LATE - 1} LIMIT 1 \\gset +SET plan_cache_mode = force_generic_plan; +PREPARE first_page(uuid, int) AS {pg(HISTORY_FIRST)}; +PREPARE after_page(uuid, timestamptz, uuid, int) AS {pg(HISTORY_AFTER)}; +PREPARE or_page(uuid, timestamptz, uuid, int) AS + SELECT id, sender_id, text, created_at FROM messages + WHERE chat_id = $1 AND ($2 IS NULL OR (created_at, id) > ($2, $3)) ORDER BY created_at, id LIMIT $4; +PREPARE offset_page(uuid, int, int) AS + SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = $1 ORDER BY created_at, id OFFSET $2 LIMIT $3; +\\echo '=== 1. first page, app query HISTORY_FIRST, generic plan' +EXPLAIN (ANALYZE, BUFFERS, SUMMARY ON) EXECUTE first_page('{CHAT}', 51); +\\echo '=== 2. late page (cursor at {LATE}), app query HISTORY_AFTER, generic plan' +EXPLAIN (ANALYZE, BUFFERS, SUMMARY ON) EXECUTE after_page('{CHAT}', :'cur_ts', :'cur_id', 51); +\\echo '=== 3. REJECTED: one query with ($2 IS NULL OR ...), same late page, generic plan' +EXPLAIN (ANALYZE, BUFFERS, SUMMARY ON) EXECUTE or_page('{CHAT}', :'cur_ts', :'cur_id', 51); +\\echo '=== 4. REJECTED: OFFSET pagination, same late page' +EXPLAIN (ANALYZE, BUFFERS, SUMMARY ON) EXECUTE offset_page('{CHAT}', {LATE}, 51); +""" + + +def psql(script: str) -> str: + result = subprocess.run( + ["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-X", "-q", "-f", "-"], + cwd=ROOT, input=script, capture_output=True, text=True, encoding="utf-8", check=True) + return result.stdout + + +def run() -> str: + psql(SEED) + return psql(EXPLAIN) + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--output", default=None) + args = parser.parse_args() + text = run() + print(text) + if args.output: + Path(args.output).write_text(text, encoding="utf-8", newline="\n") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/student-tests/conftest.py b/student-tests/conftest.py index 14b02707..f09a6ad4 100644 --- a/student-tests/conftest.py +++ b/student-tests/conftest.py @@ -1,25 +1,40 @@ -"""Shared fixtures: an isolated in-process app per test + OpenAPI schema validation.""" +"""Shared helpers for the student tests. + +* `unit/` — pure functions (validation, cursor, auth headers, Argon2id); no services. +* `test_*` in this folder — marker `stack`: black-box HTTP against the running compose + stand (BASE_URL, default http://127.0.0.1:8080) plus `docker compose` for database + checks (psql inside the postgres container) and failure injection. Every failure + test restores the stopped/paused service in `finally`. + + python -m pytest student-tests # everything (stand must be up) + python -m pytest student-tests -m "not stack" # unit only +""" from __future__ import annotations +import base64 +import contextlib import json import os +import subprocess import sys +import time import uuid from pathlib import Path +import httpx2 as httpx import pytest from jsonschema import Draft202012Validator -from starlette.testclient import TestClient ROOT = Path(__file__).resolve().parents[1] -# MESSENGER_SRC lets scripts/race_mutation_check.py run the same tests against a patched copy. -sys.path.insert(0, os.environ.get("MESSENGER_SRC", str(ROOT / "src"))) - -from messenger.app import create_app # noqa: E402 -from messenger.config import Settings # noqa: E402 +sys.path.insert(0, str(ROOT / "src")) SPEC = json.loads((ROOT / "contracts" / "openapi.json").read_text(encoding="utf-8")) -SETTINGS = Settings(host="127.0.0.1", port=8080, env="test", log_level="warning", shutdown_timeout=1.0, max_body_bytes=64 * 1024) +BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/") +PASSWORD = "Test-password-Ω-12345" # synthetic; 12+ code points, non-ASCII on purpose + + +def pytest_configure(config): + config.addinivalue_line("markers", "stack: needs the running compose stand (docker compose up -d --wait)") def schema_errors(value, name: str) -> list[str]: @@ -29,63 +44,183 @@ def schema_errors(value, name: str) -> list[str]: return [e.message for e in validator.iter_errors(value)] +def basic(username: str, password: str) -> str: + return "Basic " + base64.b64encode(f"{username}:{password}".encode()).decode() + + +# ------------------------------------------------------------------ docker / psql +def compose(*args: str, check: bool = True, timeout: float = 120) -> subprocess.CompletedProcess: + return subprocess.run(["docker", "compose", *args], cwd=ROOT, capture_output=True, text=True, + encoding="utf-8", check=check, timeout=timeout) + + +def psql(sql: str) -> str: + """Run SQL inside the postgres container (no DB port is published) and return unaligned output.""" + result = compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", + "-At", "-v", "ON_ERROR_STOP=1", "-c", sql) + return result.stdout.strip() + + +def wait_ready(timeout: float = 90) -> None: + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + try: + if httpx.get(BASE_URL + "/health/ready", timeout=2).status_code == 200: + return + except httpx.HTTPError: + pass + time.sleep(0.3) + raise AssertionError("stand did not become ready") + + +def wait_healthy(*services: str, timeout: float = 120) -> None: + """Poll Docker health until every service is healthy again. `compose up --wait` is not used: + it gives up at once on a container that was marked unhealthy while paused.""" + deadline = time.monotonic() + timeout + pending = set(services) + while pending and time.monotonic() < deadline: + for service in list(pending): + ids = compose("ps", "-q", service, check=False).stdout.split() + if ids: + state = subprocess.run(["docker", "inspect", "-f", "{{.State.Health.Status}}", ids[0]], + capture_output=True, text=True).stdout.strip() + if state == "healthy": + pending.discard(service) + time.sleep(0.5) + assert not pending, f"not healthy: {pending}" + + +def restart_services(*services: str) -> None: + compose("restart", *services) + wait_healthy(*services) + wait_ready() + + +@contextlib.contextmanager +def service_down(service: str, how: str = "stop"): + """Stop or pause a compose service; ALWAYS bring it back and wait for readiness.""" + assert how in {"stop", "pause"} + compose(how, service) + try: + yield + finally: + compose("unpause" if how == "pause" else "start", service) + wait_healthy(service) + wait_ready() + + +@contextlib.contextmanager +def api_with_env(**overrides: str): + """Recreate the api container with environment overrides (e.g. SESSION_TTL_SECONDS=2), + then ALWAYS recreate it with the normal configuration.""" + env = {**os.environ, **overrides} + subprocess.run(["docker", "compose", "up", "-d", "--wait", "api"], cwd=ROOT, env=env, + capture_output=True, text=True, check=True, timeout=180) + wait_ready() + try: + yield + finally: + clean = {k: v for k, v in os.environ.items() if k not in overrides} + subprocess.run(["docker", "compose", "up", "-d", "--wait", "api"], cwd=ROOT, env=clean, + capture_output=True, text=True, check=True, timeout=180) + wait_ready() + + +def api_env(name: str) -> str: + """Current value of an environment variable inside the running api container.""" + return compose("exec", "-T", "api", "printenv", name).stdout.strip() + + +# ------------------------------------------------------------------ HTTP class Api: - """Thin helper over TestClient that checks the invariants every response must satisfy.""" + """HTTP helper that checks the invariants every response must satisfy.""" - def __init__(self, client: TestClient): - self.client = client + def __init__(self, base_url: str = BASE_URL): + self.client = httpx.Client(base_url=base_url, timeout=15) - def call(self, method: str, path: str, expected: int, *, user=None, json_body=None, raw=None, headers=None, schema=None): + def call(self, method: str, path: str, expected: int | tuple[int, ...], *, token: str | None = None, + json_body=None, raw: bytes | None = None, headers: dict | None = None, schema: str | None = None): h = dict(headers or {}) - if user is not None: - h["X-User-Id"] = user["id"] + if token is not None: + h["Authorization"] = "Bearer " + token if json_body is not None: raw = json.dumps(json_body, ensure_ascii=False).encode("utf-8") h.setdefault("Content-Type", "application/json") response = self.client.request(method, path, content=raw, headers=h) - assert response.status_code == expected, (method, path, response.status_code, response.text) + allowed = (expected,) if isinstance(expected, int) else expected + assert response.status_code in allowed, (method, path, response.status_code, response.text[:300]) request_id = response.headers.get("x-request-id") assert request_id, "every response must carry X-Request-Id" if response.status_code >= 400: body = response.json() - assert schema_errors(body, "Error") == [] + assert schema_errors(body, "Error") == [], response.text assert body["error"]["request_id"] == request_id - assert "Traceback" not in response.text + assert "Traceback" not in response.text and "psycopg" not in response.text + if response.status_code == 401: + challenge = "basic" if path == "/api/v1/auth/sessions" else "bearer" + assert response.headers.get("www-authenticate", "").lower().startswith(challenge) elif schema: assert schema_errors(response.json(), schema) == [], response.text return response - def user(self, label: str = "u", display_name: str | None = None) -> dict: - body = {"username": f"{label}_{uuid.uuid4().hex[:10]}", "display_name": display_name or f"Студент {label}"} - return self.call("POST", "/api/v1/users", 201, json_body=body, schema="User").json() + def register(self, label: str = "u", *, password: str = PASSWORD, display_name: str | None = None) -> dict: + username = f"{label}_{uuid.uuid4().hex[:12]}"[:32] + body = {"username": username, "display_name": display_name or f"Студент {label}", "password": password} + user = self.call("POST", "/api/v1/users", 201, json_body=body, schema="User").json() + return {"id": user["id"], "user": user, "username": username, "password": password} + + def login(self, actor: dict) -> str: + session = self.call("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(actor["username"], actor["password"])}, + schema="Session").json() + assert session["user"] == actor["user"] and session["token_type"] == "Bearer" + return session["token"] + + def user(self, label: str = "u", **kwargs) -> dict: + actor = self.register(label, **kwargs) + actor["token"] = self.login(actor) + return actor def chat(self, owner: dict, *members: dict, title: str = "Тестовый чат") -> dict: ids = [owner["id"], *(m["id"] for m in members)] - return self.call("POST", "/api/v1/chats", 201, user=owner, json_body={"title": title, "member_ids": ids}, schema="Chat").json() + return self.call("POST", "/api/v1/chats", 201, token=owner["token"], + json_body={"title": title, "member_ids": ids}, schema="Chat").json() - def send(self, user: dict, chat: dict, text: str) -> dict: - return self.call("POST", f"/api/v1/chats/{chat['id']}/messages", 201, user=user, json_body={"text": text}, schema="Message").json() + def send(self, actor: dict, chat: dict, text: str) -> dict: + return self.call("POST", f"/api/v1/chats/{chat['id']}/messages", 201, token=actor["token"], + json_body={"text": text}, schema="Message").json() - def history(self, user: dict, chat: dict, limit: int) -> tuple[list[dict], int]: + def history(self, actor: dict, chat: dict, limit: int) -> tuple[list[dict], int]: """Walk all pages; returns (items, number_of_pages).""" items, pages, cursor = [], 0, None while True: query = f"?limit={limit}" + (f"&cursor={cursor}" if cursor else "") - page = self.call("GET", f"/api/v1/chats/{chat['id']}/messages{query}", 200, user=user, schema="MessagePage").json() + page = self.call("GET", f"/api/v1/chats/{chat['id']}/messages{query}", 200, + token=actor["token"], schema="MessagePage").json() pages += 1 items.extend(page["items"]) cursor = page["next_cursor"] if cursor is None: return items, pages assert len(page["items"]) == limit, "a non-final page must be full" + assert len(items) < 100_000, "cursor loop" -@pytest.fixture -def app(): - return create_app(SETTINGS) +def _stand_is_up() -> bool: + try: + return httpx.get(BASE_URL + "/health/ready", timeout=3).status_code == 200 + except httpx.HTTPError: + return False -@pytest.fixture -def api(app) -> Api: - with TestClient(app, raise_server_exceptions=False) as client: - yield Api(client) +def pytest_collection_modifyitems(config, items): + if any("stack" in item.keywords for item in items) and not _stand_is_up(): + skip = pytest.mark.skip(reason=f"stand is not running at {BASE_URL}: docker compose up -d --wait") + for item in items: + if "stack" in item.keywords: + item.add_marker(skip) + + +@pytest.fixture(scope="session") +def api() -> Api: + return Api() diff --git a/student-tests/http_concurrency.py b/student-tests/http_concurrency.py deleted file mode 100644 index 19c3a214..00000000 --- a/student-tests/http_concurrency.py +++ /dev/null @@ -1,134 +0,0 @@ -#!/usr/bin/env python3 -"""Black-box race check against a RUNNING server (level 4 criterion). - -10 clients (10 different users, one thread each) send 10 messages each into one -chat at the same moment. Then the whole history is read page by page through -the cursor. PASS requires: 100 confirmed writes, exactly 100 unique messages, -nothing lost, strict (created_at, id) order and per-client order preserved. - - python student-tests/http_concurrency.py --base-url http://127.0.0.1:8080 \ - --output evidence/concurrency.json - -Standard library only (Python 3.9+). Creates synthetic users; run on a lab stand. -""" -from __future__ import annotations - -import argparse -import json -import sys -import threading -import time -import urllib.error -import urllib.request -import uuid -from pathlib import Path - - -def call(base: str, method: str, path: str, body=None, user_id=None, expected=200): - data = None if body is None else json.dumps(body, ensure_ascii=False).encode("utf-8") - headers = {"Accept": "application/json"} - if data is not None: - headers["Content-Type"] = "application/json" - if user_id: - headers["X-User-Id"] = user_id - request = urllib.request.Request(base + path, data=data, headers=headers, method=method) - try: - with urllib.request.urlopen(request, timeout=10) as response: - status, payload = response.status, response.read() - except urllib.error.HTTPError as error: - status, payload = error.code, error.read() - if status != expected: - raise AssertionError(f"{method} {path.split('?')[0]}: expected {expected}, got {status}") - return json.loads(payload) - - -def main() -> int: - parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) - parser.add_argument("--base-url", default="http://127.0.0.1:8080") - parser.add_argument("--clients", type=int, default=10) - parser.add_argument("--messages", type=int, default=10, help="messages per client") - parser.add_argument("--page-limit", type=int, default=7, help="small limit => many cursor pages") - parser.add_argument("--output", default=None, help="optional JSON summary (no secrets inside)") - args = parser.parse_args() - base = args.base_url.rstrip("/") - total = args.clients * args.messages - - run = uuid.uuid4().hex[:8] - users = [call(base, "POST", "/api/v1/users", {"username": f"race_{run}_{i}", "display_name": f"Клиент {i}"}, expected=201) - for i in range(args.clients)] - chat = call(base, "POST", "/api/v1/chats", {"title": f"race {run}", "member_ids": [u["id"] for u in users]}, - user_id=users[0]["id"], expected=201) - - barrier = threading.Barrier(args.clients) - confirmed: list[dict] = [] - errors: list[str] = [] - lock = threading.Lock() - - def client(index: int) -> None: - barrier.wait() # all clients start sending at the same moment - for j in range(args.messages): - try: - message = call(base, "POST", f"/api/v1/chats/{chat['id']}/messages", - {"text": f"c{index}-m{j} 🧵"}, user_id=users[index]["id"], expected=201) - with lock: - confirmed.append(message) - except Exception as exc: # noqa: BLE001 - reported below - with lock: - errors.append(f"client {index}: {exc}") - - started = time.monotonic() - threads = [threading.Thread(target=client, args=(i,)) for i in range(args.clients)] - for t in threads: - t.start() - for t in threads: - t.join() - elapsed = time.monotonic() - started - - history, pages, cursor = [], 0, None - while True: - query = f"?limit={args.page_limit}" + (f"&cursor={cursor}" if cursor else "") - page = call(base, "GET", f"/api/v1/chats/{chat['id']}/messages{query}", user_id=users[-1]["id"]) - pages += 1 - history.extend(page["items"]) - cursor = page["next_cursor"] - if cursor is None or len(history) > 10 * total: - break - - ids = [m["id"] for m in history] - keys = [(m["created_at"], uuid.UUID(m["id"]).int) for m in history] - per_client_ok = all( - [m["text"] for m in history if m["sender_id"] == u["id"]] == [f"c{i}-m{j} 🧵" for j in range(args.messages)] - for i, u in enumerate(users) - ) - checks = { - "all_writes_confirmed_201": len(confirmed) == total and not errors, - "history_count_equals_sent": len(history) == total, - "ids_unique": len(set(ids)) == len(ids), - "no_confirmed_message_lost": {m["id"] for m in confirmed} <= set(ids), - "strict_created_at_id_order": all(a < b for a, b in zip(keys, keys[1:])), - "per_client_order_preserved": per_client_ok, - } - summary = { - "clients": args.clients, - "messages_per_client": args.messages, - "sent": total, - "confirmed_201": len(confirmed), - "errors": errors[:5], - "history_items": len(history), - "unique_ids": len(set(ids)), - "pages_read": pages, - "page_limit": args.page_limit, - "write_phase_seconds": round(elapsed, 3), - "checks": checks, - "result": "PASS" if all(checks.values()) else "FAIL", - } - text = json.dumps(summary, ensure_ascii=False, indent=2) - print(text) - if args.output: - Path(args.output).parent.mkdir(parents=True, exist_ok=True) - Path(args.output).write_text(text + "\n", encoding="utf-8") - return 0 if summary["result"] == "PASS" else 1 - - -if __name__ == "__main__": - sys.exit(main()) diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..d99077ec --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,201 @@ +"""Contract behaviour over real HTTP (stand must be running). Lab 1 checks moved to Bearer + new lab 2 auth.""" +from __future__ import annotations + +import base64 +import uuid + +import pytest + +from conftest import PASSWORD, basic + +pytestmark = pytest.mark.stack + + +def key(item: dict) -> tuple[str, int]: + return item["created_at"], uuid.UUID(item["id"]).int + + +# ================================================================== registration & login +def test_register_never_returns_password_and_login_returns_bearer(api): + actor = api.register("alice", display_name="Алиса 👩‍💻") + assert set(actor["user"]) == {"id", "username", "display_name", "created_at"} + session = api.call("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(actor["username"], PASSWORD)}, schema="Session").json() + assert session["token_type"] == "Bearer" and len(session["token"]) >= 43 + assert actor["username"] not in session["token"] and actor["id"] not in session["token"] + assert api.call("GET", "/api/v1/users/me", 200, token=session["token"], schema="User").json() == actor["user"] + + +def test_duplicate_username_is_409(api): + actor = api.register("dup") + body = {"username": actor["username"], "display_name": "Другой", "password": PASSWORD} + assert api.call("POST", "/api/v1/users", 409, json_body=body).json()["error"]["code"] == "conflict" + + +@pytest.mark.parametrize("password", ["short-11ch", " " * 12, " \t \n " * 3, "я" * 129]) +def test_bad_password_on_registration_is_400(api, password): + body = {"username": "pw_" + uuid.uuid4().hex[:10], "display_name": "x", "password": password} + api.call("POST", "/api/v1/users", 400, json_body=body) + + +@pytest.mark.parametrize("password", ["я" * 128, "with:colons:inside", "Twelve chars"]) +def test_edge_passwords_register_and_login(api, password): + actor = api.user("edge", password=password) + api.call("GET", "/api/v1/users/me", 200, token=actor["token"]) + + +def test_wrong_password_and_unknown_user_give_the_same_401(api): + actor = api.register("victim") + wrong = api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": basic(actor["username"], "Wrong-password-1")}) + unknown = api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": basic("nobody_" + uuid.uuid4().hex[:8], PASSWORD)}) + assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"] + assert wrong.headers["www-authenticate"] == 'Basic realm="messenger", charset="UTF-8"' + + +@pytest.mark.parametrize("header", ["Basic é", "Basic !!!", "Basic " + base64.b64encode(b"no_colon").decode(), + "Basic " + base64.b64encode(b"\xff\xfe:x").decode(), "Bearer " + "a" * 43, ""]) +def test_malformed_basic_is_401_not_500(api, header): + # Raw UTF-8 bytes, as curl would send them (httpx refuses non-ASCII str headers). + api.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": header.encode("utf-8")} if header else {}) + + +def test_logout_revokes_only_this_token(api): + actor = api.user("logout") + second = api.login(actor) + api.call("DELETE", "/api/v1/auth/sessions/current", 204, token=actor["token"]) + api.call("GET", "/api/v1/users/me", 401, token=actor["token"]) + api.call("DELETE", "/api/v1/auth/sessions/current", 401, token=actor["token"]) + api.call("GET", "/api/v1/users/me", 200, token=second) # other session of the same user survives + + +def test_x_user_id_basic_and_garbage_do_not_authenticate(api): + actor = api.user("hdr") + for headers in ({"X-User-Id": actor["id"]}, + {"Authorization": basic(actor["username"], PASSWORD)}, + {"Authorization": "Bearer " + "A" * 43}, + {"Authorization": "Bearer"}): + api.call("GET", "/api/v1/users/me", 401, headers=headers) + me = api.call("GET", "/api/v1/users/me", 200, token=actor["token"], headers={"X-User-Id": str(uuid.uuid4())}) + assert me.json()["id"] == actor["id"] + + +# ================================================================== validation / errors (from lab 1) +@pytest.mark.parametrize("raw", [b"{", b"", b"[]", b"null", b'{"username": "abc_def", "display_name": NaN, "password": "Twelve-chars"}', + b'{"username": "abc_def", "display_name": "x", "password": "Twelve-chars"}{"a": 1}', + b'{"username": "abc_def", "display_name": "\\ud800", "password": "Twelve-chars"}']) +def test_malformed_json_is_400(api, raw): + api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"}) + + +@pytest.mark.parametrize("body", [ + {"username": "abc_def", "display_name": "x"}, # no password + {"username": "abc_def", "display_name": "x", "password": "Twelve-chars", "extra": 1}, + {"username": "Abc_def", "display_name": "x", "password": "Twelve-chars"}, + {"username": "abc_def", "display_name": " ", "password": "Twelve-chars"}, + {"username": "abc_def", "display_name": "x" * 101, "password": "Twelve-chars"}, + {"username": 5, "display_name": "x", "password": "Twelve-chars"}, +]) +def test_invalid_registration_fields_are_400(api, body): + api.call("POST", "/api/v1/users", 400, json_body=body) + + +def test_unicode_limits_are_code_points_and_nul_is_stored(api): + actor = api.user("uni", display_name="😀" * 100) + assert actor["user"]["display_name"] == "😀" * 100 + nul = api.user("nul", display_name="A\u0000B") + assert api.call("GET", "/api/v1/users/me", 200, token=nul["token"]).json()["display_name"] == "A\u0000B" + chat = api.chat(actor, title="T\u0000itle") + assert chat["title"] == "T\u0000itle" + assert api.send(actor, chat, "hello\u0000world")["text"] == "hello\u0000world" + assert api.send(actor, chat, "🙂" * 4000)["text"] == "🙂" * 4000 + api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, token=actor["token"], json_body={"text": "я" * 4001}) + texts = [m["text"] for m in api.history(actor, chat, 100)[0]] + assert texts == ["hello\u0000world", "🙂" * 4000] + + +def test_oversized_body_and_wrong_content_type(api): + api.call("POST", "/api/v1/users", 413, json_body={"username": "big_body", "display_name": "x" * 70_000, "password": PASSWORD}) + api.call("POST", "/api/v1/users", 400, raw=b'{"username":"abc_def"}', headers={"Content-Type": "text/plain"}) + + +# ================================================================== chats & membership +def test_chat_validation(api): + alice, bob = api.user("alice"), api.user("bob") + for body in ({"title": "x", "member_ids": [alice["id"], bob["id"], bob["id"]]}, + {"title": "x", "member_ids": [alice["id"], str(uuid.uuid4())]}, + {"title": "x", "member_ids": [bob["id"]]}, + {"title": " ", "member_ids": [alice["id"]]}, + {"title": "x", "member_ids": [alice["id"], "bob"]}): + api.call("POST", "/api/v1/chats", 400, token=alice["token"], json_body=body) + + +def test_foreign_chat_is_indistinguishable_from_missing(api): + alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve") + chat = api.chat(alice, bob) + for chat_id in (chat["id"], str(uuid.uuid4())): + base = f"/api/v1/chats/{chat_id}" + errors = [api.call("GET", base, 404, token=eve["token"]).json(), + api.call("GET", base + "/messages", 404, token=eve["token"]).json(), + api.call("POST", base + "/messages", 404, token=eve["token"], json_body={"text": "чужое"}).json(), + api.call("GET", base + "/messages?cursor=garbage", 404, token=eve["token"]).json()] + assert len({e["error"]["message"] for e in errors}) == 1 + api.call("GET", "/api/v1/chats/not-a-uuid", 401) + api.call("GET", "/api/v1/chats/not-a-uuid", 400, token=alice["token"]) + api.call("GET", "/api/v1/chats/NOT-A-UUID/messages", 400, token=alice["token"]) + + +def test_chat_list_order_pagination_and_isolation(api): + alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve") + created = [api.chat(alice, bob, title=f"Чат {i}") for i in range(5)] + api.chat(eve, title="Чат Евы") + walked, cursor = [], None + while True: + query = "?limit=2" + (f"&cursor={cursor}" if cursor else "") + page = api.call("GET", "/api/v1/chats" + query, 200, token=bob["token"], schema="ChatPage").json() + walked += page["items"] + cursor = page["next_cursor"] + if not cursor: + break + assert walked == created + first = api.call("GET", "/api/v1/chats?limit=1", 200, token=alice["token"]).json()["next_cursor"] + api.call("GET", f"/api/v1/chats?limit=1&cursor={first}", 400, token=bob["token"]) # cursor of another user + api.call("GET", "/api/v1/chats?limit=0", 400, token=bob["token"]) + + +# ================================================================== messages & keyset pagination +def test_history_pages_without_loss_or_duplicates(api): + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob) + sent = [api.send(alice if i % 2 else bob, chat, f"сообщение {i}") for i in range(25)] + items, pages = api.history(bob, chat, 7) + assert pages == 4 and items == sent and items == sorted(items, key=key) + assert sent[0]["sender_id"] == bob["id"] and sent[1]["sender_id"] == alice["id"] + + +@pytest.mark.parametrize("query", ["limit=0", "limit=101", "limit=abc", "limit=1&limit=2", "cursor=", "cursor=garbage", + "cursor=djF8bXx4fDF8Mg", "cursor=" + base64.urlsafe_b64encode(b"v1|m|x|99999999999999999999|y").decode()]) +def test_bad_limit_or_cursor_is_400(api, query): + alice = api.user("alice") + chat = api.chat(alice) + api.call("GET", f"/api/v1/chats/{chat['id']}/messages?{query}", 400, token=alice["token"]) + + +def test_cursor_bound_to_chat(api): + alice = api.user("alice") + a, b = api.chat(alice, title="A"), api.chat(alice, title="B") + for chat in (a, b): + api.send(alice, chat, "1") + api.send(alice, chat, "2") + cursor = api.call("GET", f"/api/v1/chats/{a['id']}/messages?limit=1", 200, token=alice["token"]).json()["next_cursor"] + api.call("GET", f"/api/v1/chats/{b['id']}/messages?cursor={cursor}", 400, token=alice["token"]) + empty = api.chat(alice, title="Empty") + api.call("GET", f"/api/v1/chats/{empty['id']}/messages?cursor=garbage", 400, token=alice["token"]) + + +def test_read_after_write(api): + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob) + for i in range(5): + message = api.send(alice, chat, f"m{i}") + last = api.call("GET", f"/api/v1/chats/{chat['id']}/messages?limit=100", 200, token=bob["token"]).json()["items"][-1] + assert last == message diff --git a/student-tests/test_chats_and_messages.py b/student-tests/test_chats_and_messages.py deleted file mode 100644 index 83e36dbd..00000000 --- a/student-tests/test_chats_and_messages.py +++ /dev/null @@ -1,219 +0,0 @@ -"""Chats, membership (foreign chat -> 404), messages and keyset pagination.""" -from __future__ import annotations - -import uuid - -import pytest - - -def key(item: dict) -> tuple[str, int]: - # Fixed-width RFC 3339 strings compare like timestamps; ids compare as UUID integers. - return item["created_at"], uuid.UUID(item["id"]).int - - -# ---------------------------------------------------------------- chats -def test_create_chat_and_read_it(api): - alice, bob = api.user("alice"), api.user("bob") - chat = api.chat(alice, bob, title="Проект по ВНП 🚀") - assert chat["member_ids"] == [alice["id"], bob["id"]] - assert chat["title"] == "Проект по ВНП 🚀" - assert api.call("GET", f"/api/v1/chats/{chat['id']}", 200, user=bob, schema="Chat").json() == chat - - -@pytest.mark.parametrize("case", ["duplicate", "unknown", "without_caller", "empty", "too_many", "not_uuid", "blank_title", "long_title", "extra_field", "ids_not_list"]) -def test_invalid_chat_is_400(api, case): - alice, bob = api.user("alice"), api.user("bob") - body = {"title": "Чат", "member_ids": [alice["id"], bob["id"]]} - if case == "duplicate": - body["member_ids"] = [alice["id"], bob["id"], bob["id"].upper()] - elif case == "unknown": - body["member_ids"] = [alice["id"], str(uuid.uuid4())] - elif case == "without_caller": - body["member_ids"] = [bob["id"]] - elif case == "empty": - body["member_ids"] = [] - elif case == "too_many": - body["member_ids"] = [alice["id"]] + [str(uuid.uuid4()) for _ in range(100)] - elif case == "not_uuid": - body["member_ids"] = [alice["id"], "bob"] - elif case == "blank_title": - body["title"] = " " - elif case == "long_title": - body["title"] = "т" * 101 - elif case == "extra_field": - body["owner_id"] = alice["id"] - elif case == "ids_not_list": - body["member_ids"] = alice["id"] - api.call("POST", "/api/v1/chats", 400, user=alice, json_body=body) - - -def test_chat_with_only_the_caller_is_allowed(api): - alice = api.user("alice") - assert api.chat(alice)["member_ids"] == [alice["id"]] - - -def test_chat_list_contains_only_own_chats_in_order(api): - alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve") - created = [api.chat(alice, bob, title=f"Чат {i}") for i in range(5)] - api.chat(eve, title="Чат Евы") - listed = api.call("GET", "/api/v1/chats?limit=100", 200, user=bob, schema="ChatPage").json() - assert listed == {"items": created, "next_cursor": None} - assert api.call("GET", "/api/v1/chats", 200, user=eve).json()["items"][0]["title"] == "Чат Евы" - assert len(api.call("GET", "/api/v1/chats", 200, user=eve).json()["items"]) == 1 - - -def test_chat_list_pagination(api): - alice = api.user("alice") - created = [api.chat(alice, title=f"Чат {i}") for i in range(5)] - first = api.call("GET", "/api/v1/chats?limit=2", 200, user=alice).json() - second = api.call("GET", f"/api/v1/chats?limit=2&cursor={first['next_cursor']}", 200, user=alice).json() - third = api.call("GET", f"/api/v1/chats?limit=2&cursor={second['next_cursor']}", 200, user=alice).json() - assert first["items"] + second["items"] + third["items"] == created - assert third["next_cursor"] is None - - -def test_chat_cursor_of_another_user_is_400(api): - alice, bob = api.user("alice"), api.user("bob") - for i in range(3): - api.chat(alice, bob, title=f"Чат {i}") - cursor = api.call("GET", "/api/v1/chats?limit=1", 200, user=alice).json()["next_cursor"] - api.call("GET", f"/api/v1/chats?limit=1&cursor={cursor}", 400, user=bob) - - -# ------------------------------------------------------ foreign chat -> 404 -def test_foreign_chat_is_indistinguishable_from_missing_chat(api): - alice, bob, eve = api.user("alice"), api.user("bob"), api.user("eve") - chat = api.chat(alice, bob) - api.send(alice, chat, "секрет") - missing = str(uuid.uuid4()) - for chat_id in (chat["id"], missing): - base = f"/api/v1/chats/{chat_id}" - errors = [ - api.call("GET", base, 404, user=eve).json(), - api.call("GET", base + "/messages", 404, user=eve).json(), - api.call("POST", base + "/messages", 404, user=eve, json_body={"text": "чужое"}).json(), - # Even an invalid body or cursor does not reveal that the chat exists. - api.call("POST", base + "/messages", 404, user=eve, json_body={"text": ""}).json(), - api.call("GET", base + "/messages?cursor=garbage", 404, user=eve).json(), - ] - assert all(e["error"]["code"] == "not_found" for e in errors) - assert all(e["error"]["message"] == errors[0]["error"]["message"] for e in errors) - - -def test_invalid_chat_id_is_400_after_authentication(api): - alice = api.user("alice") - api.call("GET", "/api/v1/chats/not-a-uuid", 401) - api.call("GET", "/api/v1/chats/not-a-uuid", 400, user=alice) - api.call("GET", "/api/v1/chats/not-a-uuid/messages", 400, user=alice) - - -# -------------------------------------------------------------- messages -def test_message_sender_is_derived_from_identity(api): - alice, bob = api.user("alice"), api.user("bob") - chat = api.chat(alice, bob) - first = api.send(alice, chat, "Привет, Боб! 👋") - second = api.send(bob, chat, "Привет, Алиса") - assert (first["sender_id"], second["sender_id"]) == (alice["id"], bob["id"]) - assert first["chat_id"] == second["chat_id"] == chat["id"] - assert first["text"] == "Привет, Боб! 👋" - assert key(first) < key(second) - - -@pytest.mark.parametrize("body", [ - {"text": ""}, - {"text": " \n\t "}, - {"text": "я" * 4001}, - {"text": None}, - {"text": 42}, - {}, - {"text": "ok", "sender_id": str(uuid.uuid4())}, # sender cannot be chosen by the client - {"text": "ok", "attachment_ids": []}, # attachments appear only in lab4 -]) -def test_invalid_message_is_400(api, body): - alice = api.user("alice") - chat = api.chat(alice) - error = api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 400, user=alice, json_body=body).json() - assert error["error"]["code"] == "invalid_request" - assert api.call("GET", f"/api/v1/chats/{chat['id']}/messages", 200, user=alice).json()["items"] == [] - - -def test_message_limit_is_4000_code_points(api): - alice = api.user("alice") - chat = api.chat(alice) - text = "🙂" * 4000 # 4000 code points, 16000 UTF-8 bytes - assert api.send(alice, chat, text)["text"] == text - assert api.send(alice, chat, " отступы и\nпереносы сохраняются ")["text"] == " отступы и\nпереносы сохраняются " - - -# ------------------------------------------------------------ pagination -def test_history_walks_several_pages_without_loss_or_duplicates(api): - alice, bob = api.user("alice"), api.user("bob") - chat = api.chat(alice, bob) - sent = [api.send(alice if i % 2 else bob, chat, f"сообщение {i}") for i in range(25)] - items, pages = api.history(bob, chat, limit=7) - assert pages == 4 # 7 + 7 + 7 + 4 - assert items == sent # same order, nothing lost or repeated - assert items == sorted(items, key=key) - assert len({m["id"] for m in items}) == 25 - - -def test_limit_may_change_between_pages_and_default_is_50(api): - alice = api.user("alice") - chat = api.chat(alice) - sent = [api.send(alice, chat, f"m{i}") for i in range(60)] - base = f"/api/v1/chats/{chat['id']}/messages" - first = api.call("GET", base, 200, user=alice).json() - assert len(first["items"]) == 50 and first["next_cursor"] - rest = api.call("GET", f"{base}?limit=100&cursor={first['next_cursor']}", 200, user=alice).json() - assert first["items"] + rest["items"] == sent and rest["next_cursor"] is None - - -def test_exact_page_boundary_has_null_cursor(api): - alice = api.user("alice") - chat = api.chat(alice) - for i in range(3): - api.send(alice, chat, f"m{i}") - page = api.call("GET", f"/api/v1/chats/{chat['id']}/messages?limit=3", 200, user=alice).json() - assert len(page["items"]) == 3 and page["next_cursor"] is None - - -def test_new_message_after_last_page_is_reachable_from_cursor(api): - alice = api.user("alice") - chat = api.chat(alice) - api.send(alice, chat, "m0") - api.send(alice, chat, "m1") - base = f"/api/v1/chats/{chat['id']}/messages" - page = api.call("GET", f"{base}?limit=1", 200, user=alice).json() - newer = api.send(alice, chat, "m2") - tail = api.call("GET", f"{base}?limit=10&cursor={page['next_cursor']}", 200, user=alice).json() - assert [m["text"] for m in tail["items"]] == ["m1", "m2"] and tail["items"][-1] == newer - - -@pytest.mark.parametrize("query", ["limit=0", "limit=101", "limit=-1", "limit=abc", "limit=1.5", "limit=", "limit=%D9%A3", - "limit=1&limit=2", "cursor=", "cursor=garbage", "cursor=%%%", "cursor=djF8bXx4fDF8Mg"]) -def test_invalid_limit_or_cursor_is_400(api, query): - alice = api.user("alice") - chat = api.chat(alice) - api.send(alice, chat, "m") - api.call("GET", f"/api/v1/chats/{chat['id']}/messages?{query}", 400, user=alice) - - -def test_cursor_from_another_chat_is_400(api): - alice = api.user("alice") - chat_a, chat_b = api.chat(alice, title="A"), api.chat(alice, title="B") - for chat in (chat_a, chat_b): - api.send(alice, chat, "1") - api.send(alice, chat, "2") - cursor = api.call("GET", f"/api/v1/chats/{chat_a['id']}/messages?limit=1", 200, user=alice).json()["next_cursor"] - api.call("GET", f"/api/v1/chats/{chat_b['id']}/messages?cursor={cursor}", 400, user=alice) - # A cursor of the chat list is not a message cursor either. - api.chat(alice, title="C") - chats_cursor = api.call("GET", "/api/v1/chats?limit=1", 200, user=alice).json()["next_cursor"] - api.call("GET", f"/api/v1/chats/{chat_a['id']}/messages?cursor={chats_cursor}", 400, user=alice) - - -def test_invalid_cursor_is_400_even_for_empty_history(api): - alice = api.user("alice") - chat = api.chat(alice) # no messages at all - api.call("GET", f"/api/v1/chats/{chat['id']}/messages?cursor=garbage", 400, user=alice) - api.call("GET", "/api/v1/chats?cursor=garbage", 400, user=api.user("bob")) # user without chats diff --git a/student-tests/test_db.py b/student-tests/test_db.py new file mode 100644 index 00000000..fd065e14 --- /dev/null +++ b/student-tests/test_db.py @@ -0,0 +1,114 @@ +"""Database-level guarantees, checked over HTTP and verified directly in PostgreSQL / Valkey.""" +from __future__ import annotations + +import threading +import time +import uuid + +import pytest + +from conftest import PASSWORD, Api, compose, psql + +pytestmark = pytest.mark.stack + + +def run_concurrently(workers: int, target) -> list: + barrier = threading.Barrier(workers) + results: list = [None] * workers + + def body(index: int) -> None: + local = Api() # one HTTP client (connection) per worker + barrier.wait() # all workers fire at the same moment + try: + results[index] = target(local, index) + except BaseException as exc: # noqa: BLE001 - reported by the test + results[index] = exc + + threads = [threading.Thread(target=body, args=(i,)) for i in range(workers)] + for t in threads: + t.start() + for t in threads: + t.join() + return results + + +def test_registration_race_exactly_one_201_and_seven_409(): + username = "race_" + uuid.uuid4().hex[:10] + + def register(client: Api, _index: int) -> int: + body = {"username": username, "display_name": "Гонка", "password": PASSWORD} + response = client.client.post("/api/v1/users", json=body) + return response.status_code + + statuses = run_concurrently(8, register) + # Real HTTP codes are compared: a timeout, 500 or exception fails the test instead of counting as 409. + assert sorted(statuses, key=str) == [201] + [409] * 7, statuses + assert psql(f"SELECT count(*) FROM users WHERE username = '{username}'") == "1" + + +def _ins_counter() -> int: + return int(psql("SELECT n_tup_ins FROM pg_stat_user_tables WHERE relname = 'chats'")) + + +def test_create_chat_rolls_back_after_the_chat_row_was_inserted(api): + """The chat INSERT runs first; the unknown member then breaks the membership INSERT (FK). + + Proof that the first INSERT really happened and was rolled back: PostgreSQL counts + attempted inserts in pg_stat_user_tables.n_tup_ins even for aborted transactions, + while the table contains no such chat and no new membership rows. + """ + alice = api.user("rollback") + title = "rollback-" + uuid.uuid4().hex + members_before = int(psql("SELECT count(*) FROM chat_members")) + attempts_before = _ins_counter() + error = api.call("POST", "/api/v1/chats", 400, token=alice["token"], + json_body={"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]}).json() + assert "несуществующих" in error["error"]["message"] + deadline = time.monotonic() + 20 # statistics are flushed by the API backend asynchronously + while _ins_counter() == attempts_before and time.monotonic() < deadline: + time.sleep(0.5) + assert _ins_counter() > attempts_before, "the chat INSERT was never attempted" + assert psql(f"SELECT count(*) FROM chats WHERE title = convert_to('{title}', 'UTF8')") == "0" + assert int(psql("SELECT count(*) FROM chat_members")) == members_before + + +def test_migrations_rerun_is_a_noop(): + users_before = psql("SELECT count(*) FROM users") + result = compose("run", "--rm", "--no-deps", "migrate") + assert "0001_init: already applied, skipped" in result.stdout + assert psql("SELECT count(*) FROM schema_migrations") == "1" + assert psql("SELECT count(*) FROM users") == users_before + + +def test_100_messages_from_10_clients_keep_order_and_cursor_walk(api): + clients = [api.user(f"w{i}") for i in range(10)] + chat = api.chat(clients[0], *clients[1:]) + + def writer(client: Api, index: int) -> list[dict]: + return [client.send(clients[index], chat, f"c{index}-m{j}") for j in range(10)] + + results = run_concurrently(10, writer) + assert all(isinstance(r, list) for r in results), results + confirmed = [m for batch in results for m in batch] + history, pages = api.history(clients[5], chat, 7) + ids = [m["id"] for m in history] + assert len(confirmed) == 100 and len(history) == 100 and len(set(ids)) == 100 and pages == 15 + assert set(ids) == {m["id"] for m in confirmed} + keys = [(m["created_at"], uuid.UUID(m["id"]).int) for m in history] + assert all(a < b for a, b in zip(keys, keys[1:])), "history is not strictly ordered" + stamps = [m["created_at"] for m in history] + assert len(set(stamps)) == 100, "per-chat clock must give unique timestamps" + for i, client in enumerate(clients): + own = [m["text"] for m in history if m["sender_id"] == client["id"]] + assert own == [f"c{i}-m{j}" for j in range(10)] + + +def test_secrets_are_not_stored_in_plain_text(api): + actor = api.user("store") + stored = psql(f"SELECT password_hash FROM users WHERE id = '{actor['id']}'") + assert stored.startswith("$argon2id$v=19$m=19456,t=2,p=1$") and PASSWORD not in stored + token_hex = actor["token"].encode().hex() + keys = compose("exec", "-T", "valkey", "sh", "-c", + 'REDISCLI_AUTH="$(cat /run/secrets/valkey_password)" valkey-cli --scan --pattern "session:*"').stdout.split() + assert keys and all(len(k) == len("session:") + 64 for k in keys) + assert not any(actor["token"] in k or token_hex in k for k in keys) diff --git a/student-tests/test_explain.py b/student-tests/test_explain.py new file mode 100644 index 00000000..a2503a5f --- /dev/null +++ b/student-tests/test_explain.py @@ -0,0 +1,35 @@ +"""The history index really bounds the work of a late page (>= 10 000 messages, generic plan).""" +from __future__ import annotations + +import re +import sys + +import pytest + +from conftest import ROOT + +pytestmark = pytest.mark.stack + +sys.path.insert(0, str(ROOT / "scripts")) +import explain_history # noqa: E402 + + +def section(text: str, number: int) -> str: + parts = re.split(r"^=== ", text, flags=re.M) + return next(p for p in parts if p.startswith(f"{number}.")) + + +def buffers(plan: str) -> int: + return int(re.search(r"Buffers: shared hit=(\d+)", plan).group(1)) + + +def test_late_page_uses_index_range_not_filter(): + text = explain_history.run() + assert "20000" in text # the target chat holds 20 000 messages + app_late = section(text, 2) + assert "Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3)))" in app_late + assert "Rows Removed by Filter" not in app_late and "Sort" not in app_late + rejected = section(text, 3) + assert "Rows Removed by Filter: 19950" in rejected + # The app query touches a handful of pages; the rejected variants touch the whole prefix. + assert buffers(app_late) <= 10 < buffers(rejected) and buffers(app_late) <= 10 < buffers(section(text, 4)) diff --git a/student-tests/test_failures.py b/student-tests/test_failures.py new file mode 100644 index 00000000..0dce65a6 --- /dev/null +++ b/student-tests/test_failures.py @@ -0,0 +1,99 @@ +"""Dependency failures with a VALID session: bounded 503, never anonymous access, recovery afterwards. + +Every test stops/pauses a real container and restores it in `finally` (service_down). +Timing bounds: DB_TIMEOUT_SECONDS=3 (client deadline), CACHE_TIMEOUT_SECONDS=0.5. +""" +from __future__ import annotations + +import subprocess +import time + +import pytest + +from conftest import ROOT, restart_services, service_down + +pytestmark = pytest.mark.stack + +DB_BOUND = 3.6 # DB_TIMEOUT_SECONDS + network/HTTP overhead +CACHE_BOUND = 1.6 # 2 x CACHE_TIMEOUT_SECONDS + overhead + + +def timed(api, *args, **kwargs): + started = time.monotonic() + response = api.call(*args, **kwargs) + return response, time.monotonic() - started + + +@pytest.fixture +def prepared(api): + alice, bob = api.user("alice"), api.user("bob") + chat = api.chat(alice, bob) + message = api.send(alice, chat, "до отказа") + return alice, bob, chat, message + + +def check_intact(api, alice, bob, chat, message): + """After recovery the SAME tokens work and confirmed data is unchanged.""" + assert api.call("GET", "/api/v1/users/me", 200, token=alice["token"]).json() == alice["user"] + items = api.call("GET", f"/api/v1/chats/{chat['id']}/messages", 200, token=bob["token"]).json()["items"] + assert items == [message] + + +@pytest.mark.parametrize("how", ["stop", "pause"]) +def test_valkey_failure(api, prepared, how): + alice, bob, chat, message = prepared + with service_down("valkey", how): + response, took = timed(api, "GET", "/api/v1/users/me", 503, token=alice["token"]) + assert response.json()["error"]["code"] == "unavailable" and took < CACHE_BOUND, took + api.call("GET", f"/api/v1/chats/{chat['id']}/messages", 503, token=bob["token"]) + api.call("GET", "/api/v1/users/me", 401) # anonymous is still rejected + api.call("GET", "/health/ready", 503) + api.call("GET", "/health/live", 200) + check_intact(api, alice, bob, chat, message) + + +@pytest.mark.parametrize("how", ["stop", "pause"]) +def test_postgres_failure(api, prepared, how): + alice, bob, chat, message = prepared + with service_down("postgres", how): + for path in ("/api/v1/users/me", f"/api/v1/chats/{chat['id']}/messages", "/api/v1/chats"): + response, took = timed(api, "GET", path, 503, token=alice["token"]) + assert response.json()["error"]["code"] == "unavailable", path + assert took < DB_BOUND, (path, took) # bounded even when PostgreSQL is frozen (pause) + api.call("GET", "/api/v1/users/me", 401) # anonymous is still rejected + api.call("GET", "/health/ready", 503) + api.call("GET", "/health/live", 200) + check_intact(api, alice, bob, chat, message) + + +def test_locked_table_gives_bounded_503(api, prepared): + """A statement stuck behind a lock is stopped by lock_timeout, not after minutes.""" + alice, bob, chat, message = prepared + locker = subprocess.Popen( + ["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-c", + "BEGIN; LOCK TABLE messages IN ACCESS EXCLUSIVE MODE; SELECT pg_sleep(6); COMMIT;"], + cwd=ROOT, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + try: + time.sleep(1.5) # let the lock be taken + response, took = timed(api, "GET", f"/api/v1/chats/{chat['id']}/messages", 503, token=bob["token"]) + assert response.json()["error"]["code"] == "unavailable" and took < DB_BOUND, took + finally: + locker.wait(timeout=30) + check_intact(api, alice, bob, chat, message) + + +def test_logout_during_valkey_outage_is_never_lost(api, prepared): + """Valkey is the single source of truth for sessions, so a logout cannot be 'forgotten': + during the outage logout answers 503 (nothing revoked, the client knows it failed); + after recovery logout works, and the revocation survives a Valkey and API restart (AOF).""" + alice, bob, chat, message = prepared + with service_down("valkey", "stop"): + api.call("DELETE", "/api/v1/auth/sessions/current", 503, token=alice["token"]) + api.call("GET", "/api/v1/users/me", 200, token=alice["token"]) # logout did not happen + api.call("DELETE", "/api/v1/auth/sessions/current", 204, token=alice["token"]) + api.call("GET", "/api/v1/users/me", 401, token=alice["token"]) + restart_services("valkey", "api") + for _ in range(10): # repeated checks: the revoked token must never come back + api.call("GET", "/api/v1/users/me", 401, token=alice["token"]) + api.call("POST", f"/api/v1/chats/{chat['id']}/messages", 401, token=alice["token"], json_body={"text": "x"}) + api.call("GET", "/api/v1/users/me", 200, token=bob["token"]) # other sessions survived the restart diff --git a/student-tests/test_sessions.py b/student-tests/test_sessions.py new file mode 100644 index 00000000..245db765 --- /dev/null +++ b/student-tests/test_sessions.py @@ -0,0 +1,64 @@ +"""Session lifetime: expiry with a short SESSION_TTL_SECONDS, no extension by restarts, +and the alternative SESSION_STORE=postgres. The api container is recreated with the +override and ALWAYS recreated back with the normal configuration (api_with_env).""" +from __future__ import annotations + +import datetime as dt +import time + +import pytest + +from conftest import api_env, api_with_env, restart_services, service_down + +pytestmark = pytest.mark.stack + + +def seconds_left(expires_at: str) -> float: + moment = dt.datetime.fromisoformat(expires_at.replace("Z", "+00:00")) + return (moment - dt.datetime.now(dt.timezone.utc)).total_seconds() + + +def login_session(api, actor) -> dict: + from conftest import basic + return api.call("POST", "/api/v1/auth/sessions", 201, + headers={"Authorization": basic(actor["username"], actor["password"])}, schema="Session").json() + + +@pytest.mark.parametrize("store", ["valkey", "postgres"]) +def test_short_ttl_expires(api, store): + with api_with_env(SESSION_TTL_SECONDS="2", SESSION_STORE=store): + assert api_env("SESSION_TTL_SECONDS") == "2" # the contract variable reaches the container + actor = api.register("ttl") + session = login_session(api, actor) + assert 1.0 < seconds_left(session["expires_at"]) <= 2.1 + api.call("GET", "/api/v1/users/me", 200, token=session["token"]) + time.sleep(max(0.0, seconds_left(session["expires_at"])) + 0.3) + api.call("GET", "/api/v1/users/me", 401, token=session["token"]) + api.call("DELETE", "/api/v1/auth/sessions/current", 401, token=session["token"]) + + +def test_restart_does_not_extend_ttl(api): + with api_with_env(SESSION_TTL_SECONDS="12"): + actor = api.register("ttlrestart") + session = login_session(api, actor) + restart_services("valkey", "api") + assert seconds_left(session["expires_at"]) > 0, "restart took longer than the TTL; increase it" + api.call("GET", "/api/v1/users/me", 200, token=session["token"]) + time.sleep(max(0.0, seconds_left(session["expires_at"])) + 0.3) + api.call("GET", "/api/v1/users/me", 401, token=session["token"]) + + +def test_postgres_session_store(api): + """SESSION_STORE=postgres: sessions survive an API restart, logout revokes, and a DB outage + is 503 for a valid token (not 401 and not anonymous access).""" + with api_with_env(SESSION_STORE="postgres"): + assert api_env("SESSION_STORE") == "postgres" + actor = api.user("pgstore") + restart_services("api") + api.call("GET", "/api/v1/users/me", 200, token=actor["token"]) + with service_down("postgres", "stop"): + assert api.call("GET", "/api/v1/users/me", 503, token=actor["token"]).json()["error"]["code"] == "unavailable" + api.call("GET", "/api/v1/users/me", 401) + api.call("GET", "/api/v1/users/me", 200, token=actor["token"]) + api.call("DELETE", "/api/v1/auth/sessions/current", 204, token=actor["token"]) + api.call("GET", "/api/v1/users/me", 401, token=actor["token"]) diff --git a/student-tests/test_store_concurrency.py b/student-tests/test_store_concurrency.py deleted file mode 100644 index 5b80795c..00000000 --- a/student-tests/test_store_concurrency.py +++ /dev/null @@ -1,131 +0,0 @@ -"""Race protection of the in-memory store with real OS threads. - -The HTTP server itself runs on one event loop; these tests hit the Store from -10 threads at once to prove the lock and the "timestamp under the lock" rule: -no lost/duplicated messages AND the history order equals (created_at, id). -""" -from __future__ import annotations - -import sys -import threading - -import pytest - -from messenger.errors import Conflict -from messenger.store import Store - -CLIENTS = 10 -PER_CLIENT = 10 - - -@pytest.fixture(autouse=True) -def frequent_thread_switches(): - """Force the interpreter to switch threads every 0.1 ms instead of every 5 ms. - - Without this the GIL rarely interrupts a short critical section and a race - such as "timestamp taken before the lock" would - pass unnoticed. With it the broken variant fails reliably. - """ - previous = sys.getswitchinterval() - sys.setswitchinterval(1e-4) - yield - sys.setswitchinterval(previous) - - -def run_concurrently(workers: int, target) -> list: - barrier = threading.Barrier(workers) - results: list = [None] * workers - errors: list[BaseException] = [] - - def body(index: int) -> None: - barrier.wait() # release all threads at the same moment - try: - results[index] = target(index) - except BaseException as exc: # noqa: BLE001 - collected and re-raised in the test - errors.append(exc) - - threads = [threading.Thread(target=body, args=(i,)) for i in range(workers)] - for t in threads: - t.start() - for t in threads: - t.join() - if errors: - raise errors[0] - return results - - -def walk(store: Store, user_id: str, chat_id: str, limit: int, max_items: int = 1000) -> list: - """Cursor traversal like a client does it. If the stored order were broken, - a cursor could point back to an already returned page and the walk would - never end, so the number of returned items is bounded.""" - items, after = [], None - while True: - page, has_more = store.list_messages(user_id, chat_id, after, limit) - items.extend(page) - assert len(items) <= max_items, "cursor traversal repeats messages (order is broken)" - if not has_more: - return items - after = page[-1].key - - -@pytest.mark.parametrize("round_", range(20)) -def test_100_messages_from_10_clients_are_unique_and_ordered(round_): - store = Store() - users = [store.create_user(f"client_{i}", f"Клиент {i}") for i in range(CLIENTS)] - chat = store.create_chat(users[0].id, "Нагрузка", [u.id for u in users]) - - def client(index: int): - return [store.add_message(users[index].id, chat.id, f"c{index}-m{j}") for j in range(PER_CLIENT)] - - confirmed = [m for batch in run_concurrently(CLIENTS, client) for m in batch] - history = walk(store, users[3].id, chat.id, limit=7) # multi-page cursor traversal - - # Compact messages on purpose: pytest's diff of 100 dataclasses is slow and unreadable. - assert len(confirmed) == 100, f"confirmed {len(confirmed)} writes" - ids = [m.id for m in history] - assert len(ids) == 100, f"history has {len(ids)} messages" - assert set(ids) == {m.id for m in confirmed}, "a confirmed message is missing" - assert len(set(ids)) == 100, "duplicated message in history" - keys = [m.key for m in history] - inversions = sum(1 for a, b in zip(keys, keys[1:]) if not a < b) - assert inversions == 0, f"{inversions} neighbours violate strict (created_at, id) order" - for i in range(CLIENTS): - own = [m.text for m in history if m.sender_id == users[i].id] - assert own == [f"c{i}-m{j}" for j in range(PER_CLIENT)], f"client {i} order changed" - - -def test_timestamps_increase_even_if_wall_clock_goes_back(): - ticks = iter([5_000_000_000, 4_000_000_000, 4_000_000_000, 1_000_000_000] + [0] * 10) - store = Store(clock_ns=lambda: next(ticks)) - user = store.create_user("clock_user", "Часы") - chat = store.create_chat(user.id, "Часы", [user.id]) - messages = [store.add_message(user.id, chat.id, str(i)) for i in range(5)] - stamps = [user.ts, chat.ts, *(m.ts for m in messages)] - assert stamps == sorted(stamps) and len(set(stamps)) == len(stamps) - assert [m.created_at for m in messages] == sorted(m.created_at for m in messages) - - -def test_concurrent_registration_of_same_username_creates_one_user(): - store = Store() - - def register(_index: int): - try: - return store.create_user("same_name", "Гонка") - except Conflict: - return None - - created = [u for u in run_concurrently(20, register) if u is not None] - assert len(created) == 1 - assert store.counts()["users"] == 1 - - -def test_concurrent_chat_creation_keeps_indexes_consistent(): - store = Store() - users = [store.create_user(f"member_{i}", "Участник") for i in range(CLIENTS)] - ids = [u.id for u in users] - chats = run_concurrently(CLIENTS, lambda i: store.create_chat(ids[i], f"Чат {i}", ids)) - for user in users: - listed, has_more = store.list_chats(user.id, None, 100) - assert not has_more - assert {c.id for c in listed} == {c.id for c in chats} - assert [c.key for c in listed] == sorted(c.key for c in listed) diff --git a/student-tests/test_users_and_errors.py b/student-tests/test_users_and_errors.py deleted file mode 100644 index b1550ba9..00000000 --- a/student-tests/test_users_and_errors.py +++ /dev/null @@ -1,139 +0,0 @@ -"""Registration, identification (X-User-Id), strict JSON validation and the error format.""" -from __future__ import annotations - -import datetime as dt -import uuid - -import pytest - - -def test_health_endpoints(api): - assert api.call("GET", "/health/live", 200, schema="Health").json() == {"status": "ok"} - assert api.call("GET", "/health/ready", 200, schema="Health").json() == {"status": "ok"} - - -def test_readiness_is_503_while_draining(api, app): - app.state.draining = True - body = api.call("GET", "/health/ready", 503).json() - assert body["error"]["code"] == "unavailable" - assert api.call("GET", "/health/live", 200).json() == {"status": "ok"} - - -def test_register_returns_user_with_server_fields_and_unicode(api): - user = api.user("alice", display_name="Алиса 👩‍💻 Ωμέγα") - assert user["display_name"] == "Алиса 👩‍💻 Ωμέγα" - assert uuid.UUID(user["id"]).version == 4 - assert user["created_at"].endswith("Z") - dt.datetime.fromisoformat(user["created_at"].replace("Z", "+00:00")) - assert set(user) == {"id", "username", "display_name", "created_at"} - - -def test_duplicate_username_is_409(api): - body = {"username": "dup_" + uuid.uuid4().hex[:8], "display_name": "Первый"} - api.call("POST", "/api/v1/users", 201, json_body=body) - error = api.call("POST", "/api/v1/users", 409, json_body={**body, "display_name": "Второй"}).json() - assert error["error"]["code"] == "conflict" - - -def test_display_name_limit_is_in_code_points(api): - api.call("POST", "/api/v1/users", 201, json_body={"username": "emoji_ok", "display_name": "😀" * 100}) - api.call("POST", "/api/v1/users", 400, json_body={"username": "emoji_bad", "display_name": "😀" * 101}) - - -@pytest.mark.parametrize("raw", [ - b"{", # malformed JSON - b"", # empty body - b"[]", # not an object - b'"alice"', - b"null", - b'{"username": "abc_def", "display_name": NaN}', # NaN is not JSON - b'{"username": "abc_def", "display_name": "\xff\xfe"}', # invalid UTF-8 - b'{"username": "abc_def", "display_name": "\\ud800"}', # lone surrogate - b'{"username": "abc_def", "display_name": "x"}{"a": 1}', # two objects glued together -]) -def test_malformed_json_is_400(api, raw): - error = api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": "application/json"}).json() - assert error["error"]["code"] == "invalid_request" - - -@pytest.mark.parametrize("body", [ - {"username": "abc_def"}, # missing field - {"username": "abc_def", "display_name": "x", "extra": 1}, # unknown field - {"username": "abc_def", "display_name": "x", "password": "p"}, # lab2 field is not accepted yet - {"username": 123, "display_name": "x"}, # wrong type - {"username": "abc_def", "display_name": None}, - {"username": "abc_def", "display_name": ["x"]}, - {"username": "abc_def", "display_name": ""}, - {"username": "abc_def", "display_name": " \t\n "}, # only whitespace - {"username": "ab", "display_name": "x"}, # too short - {"username": "a" * 33, "display_name": "x"}, # too long - {"username": "Alice", "display_name": "x"}, # upper case - {"username": "алиса", "display_name": "x"}, # non-ASCII - {"username": "abc-def", "display_name": "x"}, - {"username": "abc_def\n", "display_name": "x"}, # `$` trap in regex -]) -def test_invalid_user_fields_are_400(api, body): - api.call("POST", "/api/v1/users", 400, json_body=body) - - -@pytest.mark.parametrize("content_type", ["text/plain", "application/x-www-form-urlencoded", "application/json; charset=latin-1"]) -def test_wrong_content_type_is_400(api, content_type): - raw = b'{"username": "abc_def", "display_name": "x"}' - api.call("POST", "/api/v1/users", 400, raw=raw, headers={"Content-Type": content_type}) - - -def test_json_with_utf8_charset_is_accepted(api): - raw = '{"username": "charset_ok", "display_name": "Юникод"}'.encode() - api.call("POST", "/api/v1/users", 201, raw=raw, headers={"Content-Type": "application/json; charset=UTF-8"}) - - -def test_oversized_body_is_413(api): - body = {"username": "big_body", "display_name": "x" * 70_000} - assert api.call("POST", "/api/v1/users", 413, json_body=body).json()["error"]["code"] == "payload_too_large" - - -@pytest.mark.parametrize("header", [None, "", "not-a-uuid", str(uuid.uuid4()), "11111111-1111-4111-8111-11111111111"]) -def test_missing_or_unknown_identity_is_401(api, header): - headers = {} if header is None else {"X-User-Id": header} - for method, path in [("GET", "/api/v1/users/me"), ("GET", "/api/v1/chats"), ("GET", f"/api/v1/chats/{uuid.uuid4()}")]: - error = api.call(method, path, 401, headers=headers).json() - assert error["error"]["code"] == "unauthorized" - - -def test_me_returns_selected_user(api): - alice, bob = api.user("alice"), api.user("bob") - assert api.call("GET", "/api/v1/users/me", 200, user=alice, schema="User").json() == alice - assert api.call("GET", "/api/v1/users/me", 200, user=bob).json() == bob - upper = api.call("GET", "/api/v1/users/me", 200, headers={"X-User-Id": alice["id"].upper()}).json() - assert upper == alice - - -def test_unknown_route_and_method_use_error_format(api): - assert api.call("GET", "/api/v1/nope", 404).json()["error"]["code"] == "not_found" - api.call("DELETE", "/api/v1/users", 405) - - -def test_request_id_is_unique_and_propagated(api): - first = api.call("GET", "/health/live", 200).headers["x-request-id"] - second = api.call("GET", "/health/live", 200).headers["x-request-id"] - assert first != second - assert api.call("GET", "/health/live", 200, headers={"X-Request-Id": "trace-42"}).headers["x-request-id"] == "trace-42" - - -def test_unexpected_exception_is_500_without_details(api, app, monkeypatch): - def boom(*_args, **_kwargs): - raise RuntimeError("secret internal detail") - - monkeypatch.setattr(app.state.store, "get_user", boom) - response = api.call("GET", "/api/v1/users/me", 500, headers={"X-User-Id": str(uuid.uuid4())}) - assert response.json()["error"]["code"] == "internal_error" - assert "secret" not in response.text - - -def test_swagger_ui_and_contract_are_served(api): - page = api.call("GET", "/docs", 200) - assert "swagger-ui" in page.text - spec = api.call("GET", "/openapi.json", 200).json() - assert spec["info"]["title"].startswith("MTUSI Messenger") - assert spec["servers"] == [{"url": "/", "description": "этот сервер"}] - assert "/api/v1/chats/{chat_id}/messages" in spec["paths"] diff --git a/student-tests/unit/test_unit.py b/student-tests/unit/test_unit.py new file mode 100644 index 00000000..34612867 --- /dev/null +++ b/student-tests/unit/test_unit.py @@ -0,0 +1,134 @@ +"""Pure functions, no services: validation, cursor, Authorization parsing, Argon2id, config.""" +from __future__ import annotations + +import asyncio +import base64 +import datetime as dt + +import pytest + +from messenger import authhdr, cursor, passwords, validation +from messenger.config import ConfigError, Settings +from messenger.errors import InvalidRequest, Unauthorized +from messenger.timefmt import UTC, from_us, rfc3339, to_us + + +def b64(raw: bytes) -> str: + return base64.b64encode(raw).decode() + + +# ------------------------------------------------------------------ password rules +@pytest.mark.parametrize("password", ["Twelve-chars", "я" * 128, "пароль:с:двоеточиями", "😀" * 12, "a b c d e f g"]) +def test_valid_passwords(password): + assert validation.password_field({"password": password}) == password + + +@pytest.mark.parametrize("password", ["short-11ch", "я" * 129, " " * 12, "\t\n " * 5, "\ud800" * 12, None, 123456789012]) +def test_invalid_passwords(password): + with pytest.raises(InvalidRequest): + validation.password_field({"password": password}) + + +def test_text_may_contain_nul_but_not_lone_surrogates(): + assert validation.text_field({"t": "a\u0000b"}, "t", 10) == "a\u0000b" + with pytest.raises(InvalidRequest): + validation.text_field({"t": "a\ud800"}, "t", 10) + + +# ------------------------------------------------------------------ cursor +CHAT = "3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11" + + +def test_cursor_roundtrip_and_binding(): + key = (to_us(dt.datetime(2026, 10, 12, 12, 0, 0, 123456, tzinfo=UTC)), "11111111-1111-4111-8111-111111111111") + token = cursor.encode(cursor.MESSAGES, CHAT, key) + assert cursor.decode(token, cursor.MESSAGES, CHAT) == key + with pytest.raises(InvalidRequest): + cursor.decode(token, cursor.MESSAGES, "00000000-0000-4000-8000-000000000000") # other chat + with pytest.raises(InvalidRequest): + cursor.decode(token, cursor.CHATS, CHAT) # other resource + + +@pytest.mark.parametrize("payload", [ + b"v1|m|" + CHAT.encode() + b"|253402300800000000|11111111-1111-4111-8111-111111111111", # 1 us after 9999-12-31 + b"v1|m|" + CHAT.encode() + b"|9999999999999999999|11111111-1111-4111-8111-111111111111", # int64 edge + b"v1|m|" + CHAT.encode() + b"|-1|11111111-1111-4111-8111-111111111111", + b"v1|m|" + CHAT.encode() + b"|1|not-a-uuid", + b"v1|m|" + CHAT.encode() + b"|1|11111111-1111-4111-8111-11111111111G", + b"v2|m|" + CHAT.encode() + b"|1|11111111-1111-4111-8111-111111111111", +]) +def test_broken_cursors_are_400_not_500(payload): + token = base64.urlsafe_b64encode(payload).rstrip(b"=").decode() + with pytest.raises(InvalidRequest): + cursor.decode(token, cursor.MESSAGES, CHAT) + + +def test_time_helpers_are_exact(): + moment = dt.datetime(2026, 2, 28, 23, 59, 59, 999999, tzinfo=UTC) + assert from_us(to_us(moment)) == moment + assert rfc3339(moment) == "2026-02-28T23:59:59.999999Z" + assert from_us(cursor.MAX_TS_US).year == 9999 + + +# ------------------------------------------------------------------ Authorization header +def test_basic_is_parsed_and_password_may_contain_colons(): + assert authhdr.parse_basic("Basic " + b64("alice:pa:ss:wörd".encode())) == ("alice", "pa:ss:wörd") + assert authhdr.parse_basic("basic " + b64(b"bob_1:x" * 1)) == ("bob_1", "x") + + +@pytest.mark.parametrize("header", [ + None, "", "Basic", "Basic é", "Basic !!!!", "Basic " + b64(b"no-colon"), "Basic " + b64(b"\xff\xfe:pw"), + "Basic " + b64(b":password"), "Basic " + b64(b"alice:"), "Basic " + b64("Алиса:pw".encode()), + "Bearer " + "a" * 43, "Basic " + "A" * 2000, +]) +def test_bad_basic_is_401_with_basic_challenge(header): + with pytest.raises(Unauthorized) as info: + authhdr.parse_basic(header) + assert info.value.headers["WWW-Authenticate"].startswith("Basic realm=\"messenger\"") + + +@pytest.mark.parametrize("header", [None, "", "Bearer", "Bearer short", "Bearer " + "a" * 43 + "!", + "Basic " + b64(b"alice:password-123"), "Token " + "a" * 43, "Bearer " + "é" * 43]) +def test_bad_bearer_is_401_with_bearer_challenge(header): + with pytest.raises(Unauthorized) as info: + authhdr.parse_bearer(header) + assert info.value.headers["WWW-Authenticate"] == 'Bearer realm="messenger"' + + +def test_bearer_ok(): + token = "A_b-" + "x" * 39 + assert authhdr.parse_bearer("Bearer " + token) == token + + +# ------------------------------------------------------------------ Argon2id +def test_argon2id_hash_and_verify(): + async def scenario(): + stored = await passwords.hash_password("я" * 128) + assert stored.startswith("$argon2id$v=19$m=19456,t=2,p=1$") + assert await passwords.verify_password(stored, "я" * 128) + assert not await passwords.verify_password(stored, "я" * 127) + assert not await passwords.verify_password(None, "anything") # unknown user, dummy hash + assert not await passwords.verify_password("not-a-hash", "anything") + assert await passwords.hash_password("same password!") != await passwords.hash_password("same password!") # salt + asyncio.run(scenario()) + + +# ------------------------------------------------------------------ config +def test_settings_read_secret_files_and_contract_names(tmp_path, monkeypatch): + url_file = tmp_path / "database_url" + url_file.write_text("postgresql://u:p@db/x\n", encoding="utf-8") + monkeypatch.setenv("DATABASE_URL_FILE", str(url_file)) + monkeypatch.setenv("SESSION_STORE", "redis") + monkeypatch.setenv("CACHE_URL", "redis://:p@valkey:6379/0") + monkeypatch.setenv("SESSION_TTL_SECONDS", "2") + settings = Settings.from_env() + assert settings.database_url == "postgresql://u:p@db/x" + assert settings.session_store == "valkey" and settings.session_ttl_seconds == 2 + monkeypatch.setenv("SESSION_TTL_SECONDS", "0") + with pytest.raises(ConfigError): + Settings.from_env() + monkeypatch.setenv("SESSION_TTL_SECONDS", "2") + monkeypatch.setenv("DATABASE_URL_FILE", str(tmp_path / "missing")) + with pytest.raises(ConfigError) as info: + Settings.from_env() + assert "u:p" not in str(info.value) -- 2.54.0 From eb92e8e91e97359df001800c7148a0f76c6d304e Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Mon, 12 Oct 2026 20:08:13 +0300 Subject: [PATCH 4/7] =?UTF-8?q?bench:=20=D1=82=D1=80=D0=B5=D0=BA=202=20?= =?UTF-8?q?=E2=80=94=20=D0=BF=D0=BB=D0=B0=D0=BD=D1=8B=20=D0=B7=D0=B0=D0=BF?= =?UTF-8?q?=D1=80=D0=BE=D1=81=D0=BE=D0=B2,=20=D1=81=D1=82=D0=BE=D0=B8?= =?UTF-8?q?=D0=BC=D0=BE=D1=81=D1=82=D1=8C=20=D0=B7=D0=B0=D0=BF=D0=B8=D1=81?= =?UTF-8?q?=D0=B8,=20backup/restore=20=D1=81=D0=BE=20=D1=81=D0=B2=D0=B5?= =?UTF-8?q?=D1=80=D0=BA=D0=BE=D0=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit plans.py: 121 120 сообщений (60k/15k/2k/80), 3 индекса x keyset/OFFSET x 3 размера чата, pgbench в отдельном контейнере; WAL на вставку детерминированно. backup_restore.py: pg_dump живой БД во время записи через API, восстановление в новый контейнер и volume, сверка MD5 по чатам, API на восстановленной БД. Co-Authored-By: Claude Opus 5.5 --- bench/track2/backup_restore.py | 281 +++++++++++++++++ bench/track2/plans.py | 286 ++++++++++++++++++ bench/track2/summarize.py | 110 +++++++ docs/DEFENSE.md | 83 +++++ evidence/track2/backup.json | 155 ++++++++++ .../explain/chat_id_index-big-late-page.txt | 20 ++ .../chat_id_index-medium-late-page.txt | 20 ++ .../explain/chat_id_index-small-late-page.txt | 20 ++ .../explain/keyset_index-big-late-page.txt | 10 + .../explain/keyset_index-medium-late-page.txt | 10 + .../explain/keyset_index-small-late-page.txt | 10 + .../track2/explain/no_index-big-late-page.txt | 20 ++ .../explain/no_index-medium-late-page.txt | 20 ++ .../explain/no_index-small-late-page.txt | 20 ++ evidence/track2/plans-meta.json | 74 +++++ evidence/track2/plans.png | Bin 0 -> 117892 bytes evidence/track2/reads.csv | 55 ++++ evidence/track2/summary.md | 34 +++ evidence/track2/wal.csv | 10 + evidence/track2/writes.csv | 16 + requirements-bench.txt | 2 + 21 files changed, 1256 insertions(+) create mode 100644 bench/track2/backup_restore.py create mode 100644 bench/track2/plans.py create mode 100644 bench/track2/summarize.py create mode 100644 docs/DEFENSE.md create mode 100644 evidence/track2/backup.json create mode 100644 evidence/track2/explain/chat_id_index-big-late-page.txt create mode 100644 evidence/track2/explain/chat_id_index-medium-late-page.txt create mode 100644 evidence/track2/explain/chat_id_index-small-late-page.txt create mode 100644 evidence/track2/explain/keyset_index-big-late-page.txt create mode 100644 evidence/track2/explain/keyset_index-medium-late-page.txt create mode 100644 evidence/track2/explain/keyset_index-small-late-page.txt create mode 100644 evidence/track2/explain/no_index-big-late-page.txt create mode 100644 evidence/track2/explain/no_index-medium-late-page.txt create mode 100644 evidence/track2/explain/no_index-small-late-page.txt create mode 100644 evidence/track2/plans-meta.json create mode 100644 evidence/track2/plans.png create mode 100644 evidence/track2/reads.csv create mode 100644 evidence/track2/summary.md create mode 100644 evidence/track2/wal.csv create mode 100644 evidence/track2/writes.csv create mode 100644 requirements-bench.txt diff --git a/bench/track2/backup_restore.py b/bench/track2/backup_restore.py new file mode 100644 index 00000000..bb9a1965 --- /dev/null +++ b/bench/track2/backup_restore.py @@ -0,0 +1,281 @@ +#!/usr/bin/env python3 +"""Track 2, part 2: backup -> restore into NEW storage -> reconciliation, with RPO/RTO. + + python bench/track2/backup_restore.py --repeats 3 # stand must be running + +1. The live stand database gets (once) >= 100 000 synthetic messages with uneven chat sizes. +2. A writer sends messages through the real API (POST /messages) the whole time. +3. `pg_dump -Fc` of the live database (one consistent MVCC snapshot) to ./backups (git-ignored). +4. Restore into NEW storage: a fresh PostgreSQL container with a NEW volume (`pg_restore -j 2`). +5. Reconciliation source vs restored: row counts, per-chat MD5 of every message + (id, created_at, text), the first/last 50 messages of the biggest chat, schema_migrations. + Writer messages: the restored ones must be an exact PREFIX of the confirmed ones + (consistent snapshot, no torn state); the rest is the data-loss window (RPO). +6. The app itself is started against the restored database and reads the writer's chat + with a fresh login. +Results: evidence/track2/backup.json. No passwords or tokens are written. +""" +from __future__ import annotations + +import argparse +import base64 +import datetime as dt +import json +import secrets +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx2 as httpx + +ROOT = Path(__file__).resolve().parents[2] +IMAGE = "postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c" +APP_IMAGE = "mtusi-messenger:lab2" +RESTORE_PG, RESTORE_API, RESTORE_NET, RESTORE_VOL = "mtusi-restore-pg", "mtusi-restore-api", "mtusi-restore-net", "mtusi-restore-pgdata" +BASE = "http://127.0.0.1:8080" +SEED_USER = "00000000-0000-4000-8000-0000000c0001" + +SEED_LIVE = f""" +\\set ON_ERROR_STOP on +BEGIN; +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('{SEED_USER}', 'track2_live', convert_to('Track 2 live', 'UTF8'), 'not-a-login') ON CONFLICT DO NOTHING; +CREATE TEMP TABLE sizes AS +SELECT n, CASE WHEN n = 1 THEN 60000 WHEN n <= 3 THEN 15000 WHEN n <= 11 THEN 2000 ELSE 80 END AS size, + md5('track2-live-chat-' || n)::uuid AS chat_id +FROM generate_series(1::int, 200::int) AS n; +INSERT INTO chats (id, title, created_by, created_at) +SELECT chat_id, convert_to('track2 live ' || n, 'UTF8'), '{SEED_USER}', timestamptz '2026-02-01 00:00:00+00' +FROM sizes ON CONFLICT DO NOTHING; +INSERT INTO chat_members (chat_id, user_id, position, chat_created_at) +SELECT chat_id, '{SEED_USER}', 0, timestamptz '2026-02-01 00:00:00+00' FROM sizes ON CONFLICT DO NOTHING; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), s.chat_id, '{SEED_USER}', + convert_to(left(repeat('сообщение ', 40), 5 + (random() * 195)::int), 'UTF8'), + timestamptz '2026-02-01 00:00:00+00' + g * interval '1 second' +FROM sizes s CROSS JOIN LATERAL generate_series(1::int, s.size) AS g +WHERE NOT EXISTS (SELECT 1 FROM messages m WHERE m.chat_id = s.chat_id); +UPDATE chats c SET last_message_at = m.mx FROM (SELECT chat_id, max(created_at) mx FROM messages GROUP BY chat_id) m +WHERE m.chat_id = c.id AND c.created_by = '{SEED_USER}'; +COMMIT; +""" + +RECONCILE_SQL = """ +\\pset footer off +SELECT 'count:' || t || ':' || n FROM ( + SELECT 'users' t, count(*) n FROM users UNION ALL SELECT 'chats', count(*) FROM chats + UNION ALL SELECT 'chat_members', count(*) FROM chat_members UNION ALL SELECT 'messages', count(*) FROM messages + UNION ALL SELECT 'schema_migrations', count(*) FROM schema_migrations) x ORDER BY t; +SELECT 'chat:' || chat_id || ':' || count(*) || ':' || + md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), ',' ORDER BY created_at, id)) +FROM messages WHERE chat_id <> '{writer_chat}' GROUP BY chat_id ORDER BY chat_id; +SELECT 'big:' || md5(string_agg(x, ',')) FROM ( + (SELECT id::text || '|' || encode(text, 'hex') AS x FROM messages WHERE chat_id = md5('track2-live-chat-1')::uuid + ORDER BY created_at, id LIMIT 50) + UNION ALL + (SELECT * FROM (SELECT id::text || '|' || encode(text, 'hex') FROM messages WHERE chat_id = md5('track2-live-chat-1')::uuid + ORDER BY created_at DESC, id DESC LIMIT 50) y)) z; +SELECT 'mig:' || string_agg(version || '=' || checksum, ',' ORDER BY version) FROM schema_migrations; +SELECT 'idx:' || string_agg(indexname, ',' ORDER BY indexname) FROM pg_indexes WHERE schemaname = 'public'; +SELECT 'writer:' || string_agg(id::text, ',' ORDER BY created_at, id) FROM messages WHERE chat_id = '{writer_chat}'; +""" + + +def sh(args, *, input_bytes: bytes | None = None, check: bool = True, timeout: float = 600) -> subprocess.CompletedProcess: + result = subprocess.run(args, input=input_bytes, capture_output=True, timeout=timeout, cwd=ROOT) + if check and result.returncode != 0: + raise RuntimeError(f"{' '.join(map(str, args[:5]))}: {result.stderr.decode(errors='replace')[-1500:]}") + return result + + +def live_psql(sql: str) -> str: + return sh(["docker", "compose", "exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", + "-X", "-q", "-At", "-f", "-"], input_bytes=sql.encode()).stdout.decode().strip() + + +def restored_psql(sql: str) -> str: + return sh(["docker", "exec", "-i", RESTORE_PG, "psql", "-U", "messenger", "-d", "messenger", + "-X", "-q", "-At", "-f", "-"], input_bytes=sql.encode()).stdout.decode().strip() + + +def parse(text: str) -> dict: + out: dict = {"count": {}, "chat": {}} + for line in text.splitlines(): + kind, _, rest = line.partition(":") + if kind == "count": + name, _, value = rest.partition(":") + out["count"][name] = int(value) + elif kind == "chat": + chat, _, digest = rest.partition(":") + out["chat"][chat] = digest + else: + out[kind] = rest + return out + + +class Writer(threading.Thread): + """Real API traffic during the backup: one message every ~10 ms, confirmations recorded.""" + + def __init__(self): + super().__init__(daemon=True) + self.client = httpx.Client(base_url=BASE, timeout=10) + self.username = "writer_" + uuid.uuid4().hex[:10] + self.password = secrets.token_urlsafe(16) + user = self.client.post("/api/v1/users", json={"username": self.username, "display_name": "Writer", + "password": self.password}).json() + auth = base64.b64encode(f"{self.username}:{self.password}".encode()).decode() + token = self.client.post("/api/v1/auth/sessions", headers={"Authorization": "Basic " + auth}).json()["token"] + self.headers = {"Authorization": "Bearer " + token} + self.chat = self.client.post("/api/v1/chats", headers=self.headers, + json={"title": "writer", "member_ids": [user["id"]]}).json()["id"] + self.confirmed: list[tuple[str, str]] = [] + self.errors = 0 + self.stop = threading.Event() + + def run(self) -> None: + n = 0 + while not self.stop.is_set(): + r = self.client.post(f"/api/v1/chats/{self.chat}/messages", headers=self.headers, json={"text": f"w{n}"}) + if r.status_code == 201: + self.confirmed.append((r.json()["id"], r.json()["created_at"])) + else: + self.errors += 1 + n += 1 + time.sleep(0.01) + + +def new_storage() -> str: + for cmd in (["docker", "rm", "-f", "-v", RESTORE_API, RESTORE_PG], ["docker", "volume", "rm", "-f", RESTORE_VOL], + ["docker", "network", "rm", RESTORE_NET]): + sh(cmd, check=False) + sh(["docker", "network", "create", RESTORE_NET]) + password = secrets.token_urlsafe(18) + sh(["docker", "run", "-d", "--name", RESTORE_PG, "--network", RESTORE_NET, "--cpus", "2", "--memory", "2g", + "-e", f"POSTGRES_PASSWORD={password}", "-e", "POSTGRES_USER=messenger", "-e", "POSTGRES_DB=messenger", + "-v", f"{RESTORE_VOL}:/var/lib/postgresql", IMAGE]) + for _ in range(120): + if sh(["docker", "exec", RESTORE_PG, "pg_isready", "-U", "messenger", "-d", "messenger", "-q"], check=False).returncode == 0: + time.sleep(1) + return password + time.sleep(0.5) + raise RuntimeError("restore PostgreSQL did not start") + + +def app_on_restored(password: str, writer: Writer, expected_ids: list[str]) -> dict: + """Run our API image against the restored DB (sessions in PostgreSQL) and read the writer chat.""" + url = f"postgresql://messenger:{password}@{RESTORE_PG}:5432/messenger" + sh(["docker", "run", "-d", "--name", RESTORE_API, "--network", RESTORE_NET, "-p", "127.0.0.1:18090:8080", + "-e", "SESSION_STORE=postgres", "-e", f"DATABASE_URL={url}", "-e", "DATABASE_URL_FILE=", APP_IMAGE]) + client = httpx.Client(base_url="http://127.0.0.1:18090", timeout=10) + for _ in range(60): + try: + if client.get("/health/ready").status_code == 200: + break + except httpx.HTTPError: + pass + time.sleep(0.5) + auth = base64.b64encode(f"{writer.username}:{writer.password}".encode()).decode() + token = client.post("/api/v1/auth/sessions", headers={"Authorization": "Basic " + auth}).json()["token"] + seen, cursor = [], None + while True: + q = "?limit=100" + (f"&cursor={cursor}" if cursor else "") + page = client.get(f"/api/v1/chats/{writer.chat}/messages{q}", headers={"Authorization": "Bearer " + token}).json() + seen += [m["id"] for m in page["items"]] + cursor = page["next_cursor"] + if not cursor: + break + sh(["docker", "rm", "-f", RESTORE_API], check=False) + return {"login_ok": True, "history_via_api_equals_restored": seen == expected_ids, "messages_read": len(seen)} + + +def one_round(round_no: int, backups: Path) -> dict: + writer = Writer() + writer.start() + time.sleep(2) # writer is in steady state before the backup starts + dump_file = backups / f"messenger-round{round_no}.dump" + started_wall = dt.datetime.now(dt.timezone.utc) + started = time.monotonic() + with dump_file.open("wb") as f: + proc = subprocess.run(["docker", "compose", "exec", "-T", "postgres", "pg_dump", "-U", "messenger", "-d", "messenger", + "-Fc", "-Z", "6"], stdout=f, stderr=subprocess.PIPE, cwd=ROOT, timeout=600) + if proc.returncode != 0: + raise RuntimeError(proc.stderr.decode()[-1000:]) + dump_s = time.monotonic() - started + time.sleep(2) # keep writing after the dump: these confirmed messages are not in the backup + writer.stop.set() + writer.join() + source = parse(live_psql(RECONCILE_SQL.format(writer_chat=writer.chat))) + + password = new_storage() + started = time.monotonic() + sh(["docker", "exec", "-i", RESTORE_PG, "sh", "-c", "cat > /tmp/backup.dump"], input_bytes=dump_file.read_bytes()) + sh(["docker", "exec", RESTORE_PG, "pg_restore", "-U", "messenger", "-d", "messenger", "--no-owner", "-j", "2", + "--exit-on-error", "/tmp/backup.dump"]) + restore_s = time.monotonic() - started + started = time.monotonic() + restored_psql("ANALYZE;") + analyze_s = time.monotonic() - started + restored = parse(restored_psql(RECONCILE_SQL.format(writer_chat=writer.chat))) + + confirmed_ids = [m[0] for m in writer.confirmed] + restored_writer = restored.get("writer", "").split(",") if restored.get("writer") else [] + prefix_ok = restored_writer == confirmed_ids[:len(restored_writer)] + lost = confirmed_ids[len(restored_writer):] + last_in_backup = writer.confirmed[len(restored_writer) - 1][1] if restored_writer else None + first_lost = writer.confirmed[len(restored_writer)][1] if lost else None + other_counts_equal = {k: source["count"][k] == restored["count"][k] for k in source["count"] if k != "messages"} + api_check = app_on_restored(password, writer, restored_writer) + result = { + "round": round_no, "backup_started_utc": started_wall.isoformat(timespec="seconds"), + "dump_seconds": round(dump_s, 2), "dump_bytes": dump_file.stat().st_size, + "restore_seconds": round(restore_s, 2), "analyze_seconds": round(analyze_s, 2), + "rto_seconds_restore_plus_analyze": round(restore_s + analyze_s, 2), + "source_counts_after_writer_stopped": source["count"], "restored_counts": restored["count"], + "messages_in_restored": restored["count"]["messages"], + "per_chat_md5_equal": source["chat"] == restored["chat"], "chats_compared": len(source["chat"]), + "big_chat_first_last_50_equal": source["big"] == restored["big"], + "schema_migrations_equal": source["mig"] == restored["mig"], "indexes_equal": source["idx"] == restored["idx"], + "other_table_counts_equal": other_counts_equal, + "writer": {"confirmed": len(confirmed_ids), "errors": writer.errors, "in_backup": len(restored_writer), + "restored_is_exact_prefix": prefix_ok, "lost_confirmed_after_snapshot": len(lost), + "last_message_in_backup_at": last_in_backup, "first_lost_message_at": first_lost}, + "app_on_restored_db": api_check, + } + result["reconciled"] = bool(result["per_chat_md5_equal"] and result["big_chat_first_last_50_equal"] + and result["schema_migrations_equal"] and result["indexes_equal"] + and all(other_counts_equal.values()) and prefix_ok + and api_check["history_via_api_equals_restored"]) + return result + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--repeats", type=int, default=3) + parser.add_argument("--out", default=str(ROOT / "evidence/track2/backup.json")) + args = parser.parse_args() + backups = ROOT / "backups" + backups.mkdir(exist_ok=True) + live_psql(SEED_LIVE) + rounds = [] + try: + for i in range(1, args.repeats + 1): + r = one_round(i, backups) + rounds.append(r) + print(json.dumps({k: r[k] for k in ("round", "dump_seconds", "dump_bytes", "restore_seconds", "messages_in_restored", + "reconciled")} | {"writer": r["writer"]}, ensure_ascii=False), flush=True) + finally: + for cmd in (["docker", "rm", "-f", "-v", RESTORE_API, RESTORE_PG], ["docker", "volume", "rm", "-f", RESTORE_VOL], + ["docker", "network", "rm", RESTORE_NET]): + sh(cmd, check=False) + Path(args.out).parent.mkdir(parents=True, exist_ok=True) + Path(args.out).write_text(json.dumps({"image": IMAGE, "rounds": rounds}, ensure_ascii=False, indent=2) + "\n", + encoding="utf-8", newline="\n") + print("done:", args.out) + return 0 if all(r["reconciled"] for r in rounds) else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/bench/track2/plans.py b/bench/track2/plans.py new file mode 100644 index 00000000..b71f4fd1 --- /dev/null +++ b/bench/track2/plans.py @@ -0,0 +1,286 @@ +#!/usr/bin/env python3 +"""Track 2, part 1: query plans and write cost on >= 100 000 messages with uneven chat sizes. + + python bench/track2/plans.py # ~20 min, results in evidence/track2/ + +An ISOLATED PostgreSQL container (same pinned image as compose.yaml, --cpus 2 --memory 2g, +no published ports) gets the schema from migrations/*.sql and a deterministic synthetic +dataset: 1 chat x 60 000, 2 x 15 000, 8 x 2 000, 189 x 80 messages = 121 120 messages, +texts of 10..400 bytes. The live stand is not touched: indexes are dropped and created +here freely. + +For every index variant the script runs pgbench (prepared statements, like the driver): +* reads — one history page (LIMIT 51) after a RANDOM position of a big/medium/small chat, + keyset query (the app's SQL) vs OFFSET; 4 clients; +* writes — the app's message transaction (UPDATE chats ... RETURNING + INSERT); 8 clients; +and records TPS, p50/p95/p99 latency, WAL bytes per insert, index/table sizes, EXPLAIN. +""" +from __future__ import annotations + +import argparse +import csv +import json +import math +import platform +import secrets +import statistics +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(ROOT / "src")) +from messenger.repo import HISTORY_AFTER # noqa: E402 (the app's real statement) + +IMAGE = "postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c" +NAME = "mtusi-track2-pg" +CLIENT = "mtusi-track2-client" # pgbench runs here: it must not eat the server's CPU quota +PASSWORD = secrets.token_urlsafe(16) # throwaway, never printed +USER_ID = "00000000-0000-4000-8000-0000000b0001" + +VARIANTS = { + # name: (DDL of secondary indexes on messages, description) + "keyset_index": (["CREATE INDEX messages_chat_keyset ON messages (chat_id, created_at, id)"], + "(chat_id, created_at, id) — used by the app"), + "chat_id_index": (["CREATE INDEX messages_chat_only ON messages (chat_id)"], + "(chat_id) only"), + "no_index": ([], "primary key only"), + "keyset_plus_sender": (["CREATE INDEX messages_chat_keyset ON messages (chat_id, created_at, id)", + "CREATE INDEX messages_sender_time ON messages (sender_id, created_at)"], + "app index + a second index (sender_id, created_at)"), +} +READ_VARIANTS = ["keyset_index", "chat_id_index", "no_index"] +WRITE_VARIANTS = ["no_index", "keyset_index", "keyset_plus_sender"] +KINDS = {"big": 60_000, "medium": 15_000, "small": 80} + + +def sh(args: list[str], input_text: str | None = None, check: bool = True) -> str: + result = subprocess.run(args, input=input_text, capture_output=True, text=True, encoding="utf-8") + if check and result.returncode != 0: + raise RuntimeError(f"{' '.join(args[:4])}: {result.stderr.strip()[-1500:]}") + return result.stdout + + +def psql(sql: str) -> str: + return sh(["docker", "exec", "-i", NAME, "psql", "-U", "postgres", "-d", "bench", "-X", "-q", "-At", + "-v", "ON_ERROR_STOP=1", "-f", "-"], input_text=sql).strip() + + +def put(path: str, content: str) -> None: + sh(["docker", "exec", "-i", CLIENT, "sh", "-c", f"cat > {path}"], input_text=content) + + +def start_container(cpus: str, memory: str) -> None: + sh(["docker", "rm", "-f", "-v", CLIENT, NAME], check=False) + sh(["docker", "run", "-d", "--name", NAME, "--cpus", cpus, "--memory", memory, + "-e", f"POSTGRES_PASSWORD={PASSWORD}", "-e", "POSTGRES_DB=bench", IMAGE]) + # Load generator: separate container (own CPU quota) sharing the server's network namespace. + sh(["docker", "run", "-d", "--name", CLIENT, "--network", f"container:{NAME}", "--cpus", "2", + "-e", f"PGPASSWORD={PASSWORD}", "--entrypoint", "sleep", IMAGE, "infinity"]) + for _ in range(120): + if subprocess.run(["docker", "exec", NAME, "pg_isready", "-U", "postgres", "-d", "bench", "-q"]).returncode == 0: + time.sleep(1) + return + time.sleep(0.5) + raise RuntimeError("experiment PostgreSQL did not start") + + +SEED = f""" +SELECT setseed(0.42); +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('{USER_ID}', 'track2_bench', convert_to('Track 2', 'UTF8'), 'not-a-login'); +CREATE TABLE bench_sizes AS +SELECT n, CASE WHEN n = 1 THEN 60000 WHEN n <= 3 THEN 15000 WHEN n <= 11 THEN 2000 ELSE 80 END AS size, + md5('track2-chat-' || n)::uuid AS chat_id +FROM generate_series(1::int, 200::int) AS n; +INSERT INTO chats (id, title, created_by, created_at) +SELECT chat_id, convert_to('chat ' || n, 'UTF8'), '{USER_ID}', timestamptz '2026-01-01 00:00:00+00' FROM bench_sizes; +INSERT INTO chat_members (chat_id, user_id, position, chat_created_at) +SELECT chat_id, '{USER_ID}', 0, timestamptz '2026-01-01 00:00:00+00' FROM bench_sizes; +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), s.chat_id, '{USER_ID}', + convert_to(left(repeat('сообщение ', 40), 5 + (random() * 195)::int), 'UTF8'), + timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second' +FROM bench_sizes s CROSS JOIN LATERAL generate_series(1::int, s.size) AS g; +UPDATE chats c SET last_message_at = m.mx FROM (SELECT chat_id, max(created_at) mx FROM messages GROUP BY chat_id) m +WHERE m.chat_id = c.id; +CREATE TABLE bench_chats AS SELECT n, chat_id AS id FROM bench_sizes; +CREATE TABLE bench_cursors AS +SELECT kind, row_number() OVER (PARTITION BY kind ORDER BY rn)::int AS n, created_at AS ts, id AS mid, rn::int AS off +FROM (SELECT CASE s.n WHEN 1 THEN 'big' WHEN 2 THEN 'medium' ELSE 'small' END AS kind, m.created_at, m.id, + row_number() OVER (PARTITION BY m.chat_id ORDER BY m.created_at, m.id) AS rn, s.size + FROM messages m JOIN bench_sizes s ON s.chat_id = m.chat_id WHERE s.n IN (1, 2, 12)) x +WHERE rn % greatest(1, size / 200) = 0 AND rn < size; +CREATE INDEX ON bench_cursors (kind, n); +VACUUM ANALYZE; +""" + + +def pg_param(sql: str) -> str: + """psycopg %s placeholders -> pgbench :variables (passed as parameters in prepared mode).""" + names = iter([":chat", ":cts", ":cid", "51"]) + out = sql + while "%s" in out: + out = out.replace("%s", next(names), 1) + return out + + +READ_SCRIPTS = { + "keyset": "\\set k random(1, :ncur)\n" + "SELECT ts AS cts, mid AS cid FROM bench_cursors WHERE kind = :kind AND n = :k \\gset\n" + + pg_param(HISTORY_AFTER) + ";\n", + "offset": "\\set k random(1, :ncur)\n" + "SELECT off FROM bench_cursors WHERE kind = :kind AND n = :k \\gset\n" + "SELECT id, sender_id, text, created_at FROM messages WHERE chat_id = :chat " + "ORDER BY created_at, id OFFSET :off LIMIT 51;\n", +} +WRITE_SCRIPT = ( + "\\set c random(1, 200)\n" + "SELECT id AS chat FROM bench_chats WHERE n = :c \\gset\n" + "BEGIN;\n" + "UPDATE chats SET last_message_at = greatest(clock_timestamp(), last_message_at + interval '1 microsecond') " + "WHERE id = :chat RETURNING last_message_at AS ts \\gset\n" + f"INSERT INTO messages (id, chat_id, sender_id, text, created_at) VALUES " + f"(gen_random_uuid(), :chat, '{USER_ID}', convert_to(repeat('w', 120), 'UTF8'), :ts);\n" + "END;\n" +) + + +def pgbench(script_path: str, clients: int, seconds: int, defines: dict[str, str]) -> dict: + """Run pgbench with per-transaction logging; return TPS and latency percentiles (ms).""" + sh(["docker", "exec", CLIENT, "sh", "-c", "rm -f /tmp/pgblog*"]) + args = ["docker", "exec", CLIENT, "sh", "-c", + "cd /tmp && pgbench -h 127.0.0.1 -U postgres -n -M prepared -c {c} -j {c} -T {t} -l --log-prefix=pgblog {d} -f {f} bench".format( + c=clients, t=seconds, f=script_path, d=" ".join(f"-D {k}={v}" for k, v in defines.items()))] + out = sh(args) + tps = float(next(l for l in out.splitlines() if l.startswith("tps = ")).split()[2]) + failed = next((l for l in out.splitlines() if "number of failed transactions" in l), "0").split(":")[-1].split()[0] + lat = sorted(int(line.split()[2]) / 1000 for line in sh(["docker", "exec", CLIENT, "sh", "-c", "cat /tmp/pgblog*"]).splitlines()) + + def pct(p: float) -> float: + return round(lat[max(0, math.ceil(p * len(lat)) - 1)], 3) + return {"tps": round(tps, 1), "transactions": len(lat), "failed": int(failed), + "p50_ms": pct(.50), "p95_ms": pct(.95), "p99_ms": pct(.99), "mean_ms": round(statistics.mean(lat), 3)} + + +def use_variant(name: str) -> dict: + psql("DROP INDEX IF EXISTS messages_chat_keyset; DROP INDEX IF EXISTS messages_chat_only; " + "DROP INDEX IF EXISTS messages_sender_time;") + started = time.monotonic() + for ddl in VARIANTS[name][0]: + psql(ddl + ";") + build_s = round(time.monotonic() - started, 2) + psql("VACUUM ANALYZE messages;") + sizes = psql("SELECT indexrelname || '=' || pg_relation_size(indexrelid) FROM pg_stat_user_indexes " + "WHERE relname = 'messages' ORDER BY 1;").split() + return {"index_build_s": build_s, "index_bytes": dict(s.split("=") for s in sizes), + "table_bytes": int(psql("SELECT pg_relation_size('messages');"))} + + +def explain_late(kind: str) -> str: + chat = psql(f"SELECT chat_id FROM bench_sizes WHERE n = {dict(big=1, medium=2, small=12)[kind]};") + return psql(f""" +SET plan_cache_mode = force_generic_plan; +PREPARE p(uuid, timestamptz, uuid, int) AS {HISTORY_AFTER.replace('%s', '$1', 1).replace('%s', '$2', 1).replace('%s', '$3', 1).replace('%s', '$4', 1)}; +SELECT ts, mid FROM bench_cursors WHERE kind = '{kind}' ORDER BY n DESC LIMIT 1 \\gset +EXPLAIN (ANALYZE, BUFFERS) EXECUTE p('{chat}', :'ts', :'mid', 51); +""") + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) + parser.add_argument("--seconds", type=int, default=10) + parser.add_argument("--warmup", type=int, default=3) + parser.add_argument("--repeats", type=int, default=3) + parser.add_argument("--out", default=str(ROOT / "evidence/track2")) + parser.add_argument("--writes-only", action="store_true", help="re-measure writes, keep reads.csv") + parser.add_argument("--write-repeats", type=int, default=5) + args = parser.parse_args() + out = Path(args.out) + (out / "explain").mkdir(parents=True, exist_ok=True) + + start_container("2", "2g") + schema = "".join(p.read_text(encoding="utf-8") for p in sorted((ROOT / "migrations").glob("*.sql"))) + psql(schema) + seed_started = time.monotonic() + psql(SEED) + seed_s = round(time.monotonic() - seed_started, 1) + stats = psql("SELECT count(*), count(DISTINCT chat_id), min(octet_length(text)), max(octet_length(text)) FROM messages;") + sizes = psql("SELECT size || 'x' || count(*) FROM bench_sizes GROUP BY size ORDER BY size DESC;").split() + for name, script in READ_SCRIPTS.items(): + put(f"/tmp/read_{name}.sql", script) + put("/tmp/write.sql", WRITE_SCRIPT) + chats = {k: psql(f"SELECT chat_id FROM bench_sizes WHERE n = {dict(big=1, medium=2, small=12)[k]};") for k in KINDS} + ncur = {k: int(psql(f"SELECT count(*) FROM bench_cursors WHERE kind = '{k}';")) for k in KINDS} + meta = {"image": IMAGE, "limits": {"server_cpus": 2, "server_memory": "2g", "pgbench_client_cpus": 2}, "pg_settings": "image defaults", + "dataset": {"messages_chats_minbytes_maxbytes": stats, "chat_sizes": sizes, "seed_seconds": seed_s}, + "pgbench": {"mode": "prepared", "seconds": args.seconds, "warmup": args.warmup, "repeats": args.repeats, + "read_clients": 4, "write_clients": 8, "page": "LIMIT 51 after a random position"}, + "host": {"platform": platform.platform(), "docker": sh(["docker", "version", "-f", "{{.Server.Version}}"]).strip()}, + "variants": {k: v[1] for k, v in VARIANTS.items()}, "sizes": {}} + print("dataset:", stats, sizes, flush=True) + + reads, writes = [], [] + if args.writes_only: + old = json.loads((out / "plans-meta.json").read_text(encoding="utf-8")) + meta["sizes"] = old.get("sizes", {}) + for variant in ([] if args.writes_only else READ_VARIANTS): + meta["sizes"][variant] = use_variant(variant) + for kind in KINDS: + (out / "explain" / f"{variant}-{kind}-late-page.txt").write_text(explain_late(kind), encoding="utf-8", newline="\n") + for rep in range(1, args.repeats + 1): + for query in READ_SCRIPTS: + for kind in KINDS: + defines = {"chat": chats[kind], "kind": kind, "ncur": str(ncur[kind])} + pgbench(f"/tmp/read_{query}.sql", 4, args.warmup, defines) # warm-up, discarded + row = {"variant": variant, "query": query, "chat": kind, "chat_size": KINDS[kind], "repeat": rep, + **pgbench(f"/tmp/read_{query}.sql", 4, args.seconds, defines)} + reads.append(row) + print("read ", row, flush=True) + wal_rows = [] + for variant in WRITE_VARIANTS: + meta["sizes"][variant] = use_variant(variant) + # (a) throughput/latency under concurrency: 8 clients, time-based, autovacuum as in production + for rep in range(1, args.write_repeats + 1): + pgbench("/tmp/write.sql", 8, args.warmup, {}) + row = {"variant": variant, "repeat": rep, **pgbench("/tmp/write.sql", 8, args.seconds, {})} + writes.append(row) + print("write", row, flush=True) + # (b) WAL volume per insert, deterministic: the same 5 000 app transactions (1 client), + # autovacuum off for the table and a CHECKPOINT right before, so every run starts from + # the same state and only the index set differs. + psql("ALTER TABLE messages SET (autovacuum_enabled = off);") + for rep in range(1, 4): + psql("CHECKPOINT;") + lsn0 = psql("SELECT pg_current_wal_lsn();") + sh(["docker", "exec", CLIENT, "pgbench", "-h", "127.0.0.1", "-U", "postgres", "-n", "-M", "prepared", + "-c", "1", "-t", "5000", "-f", "/tmp/write.sql", "bench"]) + wal = int(psql(f"SELECT pg_current_wal_lsn() - '{lsn0}'::pg_lsn;")) + wal_row = {"variant": variant, "repeat": rep, "inserts": 5000, "wal_bytes": wal, + "wal_bytes_per_insert": round(wal / 5000)} + wal_rows.append(wal_row) + print("wal ", wal_row, flush=True) + psql("ALTER TABLE messages RESET (autovacuum_enabled);") + sh(["docker", "rm", "-f", "-v", CLIENT, NAME], check=False) + with (out / "wal.csv").open("w", newline="", encoding="utf-8") as f: + writer = csv.DictWriter(f, fieldnames=list(wal_rows[0])) + writer.writeheader() + writer.writerows(wal_rows) + + meta["pgbench"]["write_repeats"] = args.write_repeats + meta["pgbench"]["wal_method"] = "5000 app transactions, 1 client, autovacuum off, CHECKPOINT before; 3 repeats" + for name, rows in (("reads", reads), ("writes", writes)): + if not rows: + continue + with (out / f"{name}.csv").open("w", newline="", encoding="utf-8") as f: + writer = csv.DictWriter(f, fieldnames=list(rows[0])) + writer.writeheader() + writer.writerows(rows) + (out / "plans-meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print("done:", out) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/bench/track2/summarize.py b/bench/track2/summarize.py new file mode 100644 index 00000000..64876d5c --- /dev/null +++ b/bench/track2/summarize.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python3 +"""Aggregate track 2 raw data into tables (summary.md) and charts (plans.png). + + python bench/track2/summarize.py # matplotlib from requirements-bench.txt for the chart +""" +from __future__ import annotations + +import csv +import json +import statistics +import sys +from collections import defaultdict +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +OUT = ROOT / "evidence/track2" +SIZE_ORDER = {"big": 0, "medium": 1, "small": 2} + + +def load(name: str) -> list[dict]: + with (OUT / name).open(encoding="utf-8") as f: + return list(csv.DictReader(f)) + + +def agg(rows: list[dict], keys: tuple[str, ...], fields: tuple[str, ...]) -> dict: + groups: dict = defaultdict(list) + for r in rows: + groups[tuple(r[k] for k in keys)].append(r) + out = {} + for k, g in groups.items(): + out[k] = {f: statistics.median(float(r[f]) for r in g) for f in fields} + out[k]["tps_min"] = min(float(r["tps"]) for r in g) + out[k]["tps_max"] = max(float(r["tps"]) for r in g) + out[k]["n"] = len(g) + return out + + +def fmt(x: float) -> str: + return f"{x:,.0f}".replace(",", " ") if x >= 100 else (f"{x:.1f}" if x >= 10 else f"{x:.2f}") + + +def main() -> int: + sys.stdout.reconfigure(encoding="utf-8") + reads, writes, wal = load("reads.csv"), load("writes.csv"), load("wal.csv") + meta = json.loads((OUT / "plans-meta.json").read_text(encoding="utf-8")) + r = agg(reads, ("variant", "query", "chat"), ("tps", "p50_ms", "p95_ms", "p99_ms")) + w = agg(writes, ("variant",), ("tps", "p50_ms", "p95_ms", "p99_ms")) + wal_by = {v: [int(r["wal_bytes_per_insert"]) for r in wal if r["variant"] == v] for v in {r["variant"] for r in wal}} + for v, values in wal_by.items(): + w[(v,)]["wal_bytes_per_insert"] = statistics.median(values) + w[(v,)]["wal_min"], w[(v,)]["wal_max"] = min(values), max(values) + sizes = {"big": 60000, "medium": 15000, "small": 80} + md = ["## Чтение: одна страница (LIMIT 51) со случайной позиции чата", "", + "Медиана 3 повторов по 10 с, 4 клиента pgbench, prepared statements. TPS min–max — разброс повторов.", "", + "| Индекс | Запрос | Чат (сообщений) | TPS (min–max) | p50, мс | p95, мс | p99, мс |", + "| --- | --- | ---: | ---: | ---: | ---: | ---: |"] + for (variant, query, chat), v in sorted(r.items(), key=lambda kv: (kv[0][0] != "keyset_index", kv[0][0], kv[0][1], SIZE_ORDER[kv[0][2]])): + md.append(f"| {variant} | {query} | {chat} ({sizes[chat]:,}) | {fmt(v['tps'])} ({fmt(v['tps_min'])}–{fmt(v['tps_max'])}) " + f"| {fmt(v['p50_ms'])} | {fmt(v['p95_ms'])} | {fmt(v['p99_ms'])} |".replace(",", " ", 1)) + md += ["", "## Запись: транзакция сообщения приложения (UPDATE chats … RETURNING + INSERT)", "", + "TPS и задержка — медиана 5 повторов по 10 с, 8 клиентов. WAL — медиана 3 детерминированных прогонов: " + "5 000 транзакций, 1 клиент, autovacuum выключен, CHECKPOINT перед прогоном.", "", + "| Индексы messages | TPS (min–max) | p50, мс | p95, мс | p99, мс | WAL, байт/вставку (min–max) | Размер индексов, МиБ |", + "| --- | ---: | ---: | ---: | ---: | ---: | ---: |"] + for variant in ("no_index", "keyset_index", "keyset_plus_sender"): + v = w[(variant,)] + idx = meta["sizes"][variant]["index_bytes"] + idx_mib = sum(int(b) for b in idx.values()) / 2**20 + md.append(f"| {variant} | {fmt(v['tps'])} ({fmt(v['tps_min'])}–{fmt(v['tps_max'])}) | {fmt(v['p50_ms'])} | {fmt(v['p95_ms'])} " + f"| {fmt(v['p99_ms'])} | {v['wal_bytes_per_insert']:.0f} ({v['wal_min']}–{v['wal_max']}) | {idx_mib:.1f} |") + (OUT / "summary.md").write_text("\n".join(md) + "\n", encoding="utf-8", newline="\n") + print("\n".join(md)) + + try: + import matplotlib + matplotlib.use("Agg") + import matplotlib.pyplot as plt + except ImportError: + print("matplotlib is not installed: skipping plans.png") + return 0 + fig, axes = plt.subplots(1, 2, figsize=(15, 5)) + chats = ["small", "medium", "big"] + x = [sizes[c] for c in chats] + styles = {("keyset_index", "keyset"): ("#12a150", "-o"), ("keyset_index", "offset"): ("#12a150", "--s"), + ("chat_id_index", "keyset"): ("#e07b00", "-o"), ("chat_id_index", "offset"): ("#e07b00", "--s"), + ("no_index", "keyset"): ("#b03060", "-o"), ("no_index", "offset"): ("#b03060", "--s")} + for (variant, query), (color, style) in styles.items(): + axes[0].plot(x, [r[(variant, query, c)]["p95_ms"] for c in chats], style, color=color, label=f"{variant}, {query}") + axes[0].set_xscale("log") + axes[0].set_yscale("log") + axes[0].set_xlabel("messages in the chat") + axes[0].set_ylabel("p95 latency of one page, ms (log)") + axes[0].set_title("Read: random page of a chat") + axes[0].grid(True, which="both", alpha=0.3) + axes[0].legend(fontsize=8) + names = ["no_index", "keyset_index", "keyset_plus_sender"] + axes[1].bar([n.replace("_", "\n") for n in names], [w[(n,)]["wal_bytes_per_insert"] for n in names], color="#2a6fdb") + for i, n in enumerate(names): + axes[1].text(i, w[(n,)]["wal_bytes_per_insert"], f"{w[(n,)]['tps']:.0f} TPS", ha="center", va="bottom") + axes[1].set_ylabel("WAL bytes per inserted message") + axes[1].set_title("Write cost of indexes (WAL: 5000 inserts; TPS: 8 clients)") + fig.suptitle("Track 2: 121 120 messages, chats of 60 000 / 15 000 / 2 000 / 80; PostgreSQL 18.6, 2 CPU / 2 GiB") + fig.tight_layout() + fig.savefig(OUT / "plans.png", dpi=120) + print("chart:", OUT / "plans.png") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/docs/DEFENSE.md b/docs/DEFENSE.md new file mode 100644 index 00000000..ed6091b5 --- /dev/null +++ b/docs/DEFENSE.md @@ -0,0 +1,83 @@ +# Шпаргалка к защите ЛР 2 + +Отчёт с доказательствами — [REPORT.md](../REPORT.md), модель данных — [DATA_MODEL.md](DATA_MODEL.md). + +## Что изменилось по сравнению с lab1 + +| Было в lab1 | Стало в lab2 | Где | +| --- | --- | --- | +| словари в памяти (`store.py`) | PostgreSQL 18, данные переживают рестарт | [repo.py](../src/messenger/repo.py), [migrations/0001_init.sql](../migrations/0001_init.sql) | +| `X-User-Id` | вход по `Basic` → opaque `Bearer` с expiry, logout | [authhdr.py](../src/messenger/authhdr.py), [sessions.py](../src/messenger/sessions.py), [app.py](../src/messenger/app.py) | +| нет паролей | Argon2id (m=19 MiB, t=2, p=1) в отдельном потоке | [passwords.py](../src/messenger/passwords.py) | +| `threading.Lock` + свой счётчик времени | блокировка строки чата `UPDATE chats … RETURNING` в транзакции | `add_message` в repo.py | +| `bisect` по списку | индекс `(chat_id, created_at, id)` и row-comparison в `Index Cond` | `HISTORY_AFTER` в repo.py | +| один контейнер | `compose.yaml`: postgres, valkey, migrate, api; secrets-файлы; named volumes | [compose.yaml](../compose.yaml) | + +Что осталось из lab1: формат ошибок и `X-Request-Id`, строгая валидация, cursor (теперь с проверкой диапазона времени), JSON-логи, graceful SIGTERM, healthcheck, Swagger на `/docs`. + +## Путь запроса `GET /chats/{id}/messages?cursor=…` в lab2 + +1. `parse_bearer`: в заголовке ровно `Bearer <43 символа>`, иначе 401 с `WWW-Authenticate: Bearer`. +2. `sessions.user_id_for`: в Valkey ключ `session:`, проверка `expires_at`. Valkey недоступен — 503, нет ключа — 401. +3. `path_uuid` → 400; `ensure_member` (`SELECT 1 FROM chat_members …`) → 404 для чужого чата. +4. `cursor.decode` → `(время в мкс, id)`, привязка к чату → иначе 400. +5. `HISTORY_AFTER`: `WHERE chat_id=$1 AND (created_at, id) > ($2,$3) ORDER BY … LIMIT 51` — индекс начинает чтение прямо с cursor. +6. Каждая работа с БД — `db.run(...)`: отдельная задача, транзакция, дедлайн 3 с. Отказ или зависание БД → 503 ровно через дедлайн. + +## Вопросы из README + +**Что подтверждает COMMIT и какие гарантии зависят от настройки durability?** +COMMIT возвращается клиенту, когда запись транзакции в WAL сброшена на диск (`fsync=on`, `synchronous_commit=on`, это значения по умолчанию). Транзакция переживёт падение процесса PostgreSQL или ОС: при старте PostgreSQL проиграет WAL. От настроек зависит: +- `synchronous_commit=off` — ответ приходит раньше сброса, и последние ~0,6 с подтверждённых транзакций могут пропасть (база при этом останется целой); +- `fsync=off` — после сбоя возможна порча данных; +- кэш записи диска, который «врёт» о сбросе, ломает и то, и другое. + +COMMIT на одном узле не защищает от потери самого диска или хоста: для этого нужны реплики (`synchronous_standby_names`) или резервные копии с архивом WAL (трек 2). + +У Valkey свой аналог — `appendfsync`: +- у нас `always`: fsync до ответа, ничего не теряется; +- `everysec`: можно потерять до 1 с записей; +- `no`: когда сбросить на диск, решает ОС. + +**Где хранятся сессии и что будет после flush/restart Redis (Valkey)?** +По умолчанию (`SESSION_STORE=valkey`) сессия существует **только** в Valkey: ключ `session:`, значение `{user_id, expires_at}` и абсолютный срок `PXAT`. +- **Restart:** Valkey перечитывает AOF с volume, сессии на месте (тест `make test-persistence`). TTL не продлевается. +- **FLUSHALL** или потеря volume: все сессии исчезают, все пользователи получают 401 и входят заново. Отказ безопасный: доступ не выдаётся никому. +- **Valkey недоступен:** 503 на защищённые запросы и на logout. Анонимный доступ не открывается. + +Почему не кэш над PostgreSQL: у одной копии нечему расходиться. У студентов с кэшем отозванный токен «оживал» после восстановления Redis, у нас такой ситуации быть не может (тест `test_logout_during_valkey_outage_is_never_lost`). Альтернатива `SESSION_STORE=postgres` хранит сессии в таблице `sessions`. + +**Чем аутентификация отличается от доступа к конкретному чату?** +- **Аутентификация** — кто ты: действительная Bearer-сессия → `user_id`. Нет или недействительна → 401. +- **Авторизация доступа** — можно ли этому пользователю этот чат: есть ли строка в `chat_members`. Нет → 404, а не 403, чтобы не раскрывать существование чужого чата. + +Сначала всегда аутентификация, потом доступ. Отправитель сообщения берётся из сессии, а БД сама проверяет `FOREIGN KEY (chat_id, sender_id) → chat_members`. + +**Почему hash пароля и быстрый checksum имеют разные задачи?** +- **Checksum или быстрый хеш (SHA-256)** — контроль целостности и быстрый поиск. Он должен быть быстрым. +- **Хеш пароля** — защита низкоэнтропийного секрета на случай утечки базы. Он должен быть медленным, с солью и memory-hard (Argon2id), чтобы перебор словаря стоил дорого и не ускорялся на GPU. + +Токен сессии — 256 бит случайности, перебрать его невозможно. Поэтому для токена хватает SHA-256: храним хеш, чтобы утечка базы не дала готовых токенов. Для пароля SHA-256 нельзя: миллиарды попыток в секунду на GPU. + +## Частые ловушки (на чём преподаватель ловил других) и наш ответ + +| Проверка преподавателя | У нас | Тест | +| --- | --- | --- | +| logout при упавшем Redis → после восстановления токен снова 200 | logout при упавшем Valkey = 503 (ничего не отозвано); после восстановления logout → 401, и после рестарта Valkey и API тоже 401 | `test_logout_during_valkey_outage_is_never_lost` | +| истёкшая сессия живёт в кэше | expiry проверяется при каждом чтении, ключ живёт до абсолютного `PXAT` | `test_short_ttl_expires[valkey/postgres]` | +| `docker pause postgres` → запрос висит 8+ с | клиентский дедлайн в отдельной задаче: 503 через 3,0 с | `test_postgres_failure[pause]` | +| БД упала → 401 вместо 503 | 503 `unavailable`, анонимный — 401 | `test_postgres_failure`, `test_postgres_session_store` | +| cursor в `Filter` при generic plan | два запроса без `IS NULL OR`, cursor в `Index Cond` | `test_explain.py`, `evidence/explain-history.txt` | +| `\u0000` → 500 | текст в `bytea`, NUL сохраняется | `test_unicode_limits_are_code_points_and_nul_is_stored` | +| пароль из пробелов, `Basic é` → 500 | 400 и 401 | `test_bad_password_on_registration_is_400`, `test_malformed_basic_is_401_not_500` | +| гонка регистрации считает любые ошибки за 409 | проверяются коды: ровно `[201] + [409]*7`, в БД 1 строка | `test_registration_race_exactly_one_201_and_seven_409` | +| rollback «до первого INSERT» | чат вставляется первым, FK участника падает после; `n_tup_ins` вырос, строк нет | `test_create_chat_rolls_back_after_the_chat_row_was_inserted` | +| `SESSION_TTL_SECONDS` не доходит до контейнера | compose передаёт его из `.env`, тест читает `printenv` внутри контейнера | `test_short_ttl_expires` | +| нет команды создания secrets | `python scripts/init_secrets.py` (идемпотентно) | раздел «Запуск из чистого clone» | + +## Трек 2 — коротко + +- **Гипотеза.** С индексом `(chat_id, created_at, id)` и keyset-запросом стоимость страницы не зависит от размера чата и позиции. С индексом только по `chat_id` нужна сортировка всего чата, с OFFSET — чтение всего префикса. Каждый индекс удорожает запись. +- **Методика.** Отдельный PostgreSQL (2 CPU / 2 GiB), 121 120 сообщений, чаты 60 000 / 15 000 / 2 000 / 80. pgbench с prepared statements; генератор нагрузки — в своём контейнере. 3 повтора. Плюс EXPLAIN для поздней страницы. +- **Backup.** `pg_dump -Fc` живой БД во время записи через API → новый контейнер и новый volume → `pg_restore` → сверка MD5 по каждому чату и по первым/последним сообщениям → наше же API на восстановленной БД читает чат после нового входа. +- **RPO и RTO.** `pg_dump` — снимок на момент старта. Всё подтверждённое после старта дампа в копию не попадает; это и есть граница потери данных (на практике — время с последнего дампа). RTO — время `pg_restore` с перестройкой индексов плюс переключение приложения. Чтобы уменьшить RPO до секунд, нужен архив WAL и PITR или реплика. diff --git a/evidence/track2/backup.json b/evidence/track2/backup.json new file mode 100644 index 00000000..3a06af52 --- /dev/null +++ b/evidence/track2/backup.json @@ -0,0 +1,155 @@ +{ + "image": "postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c", + "rounds": [ + { + "round": 1, + "backup_started_utc": "2026-10-12T17:06:57+00:00", + "dump_seconds": 1.47, + "dump_bytes": 5349383, + "restore_seconds": 2.21, + "analyze_seconds": 0.57, + "rto_seconds_restore_plus_analyze": 2.79, + "source_counts_after_writer_stopped": { + "chat_members": 330, + "chats": 290, + "messages": 171546, + "schema_migrations": 1, + "users": 117 + }, + "restored_counts": { + "chat_members": 330, + "chats": 290, + "messages": 171410, + "schema_migrations": 1, + "users": 117 + }, + "messages_in_restored": 171410, + "per_chat_md5_equal": true, + "chats_compared": 257, + "big_chat_first_last_50_equal": true, + "schema_migrations_equal": true, + "indexes_equal": true, + "other_table_counts_equal": { + "chat_members": true, + "chats": true, + "schema_migrations": true, + "users": true + }, + "writer": { + "confirmed": 237, + "errors": 0, + "in_backup": 101, + "restored_is_exact_prefix": true, + "lost_confirmed_after_snapshot": 136, + "last_message_in_backup_at": "2026-10-12T17:06:57.831240Z", + "first_lost_message_at": "2026-10-12T17:06:57.856678Z" + }, + "app_on_restored_db": { + "login_ok": true, + "history_via_api_equals_restored": true, + "messages_read": 101 + }, + "reconciled": true + }, + { + "round": 2, + "backup_started_utc": "2026-10-12T17:07:13+00:00", + "dump_seconds": 1.7, + "dump_bytes": 5362829, + "restore_seconds": 1.9, + "analyze_seconds": 0.49, + "rto_seconds_restore_plus_analyze": 2.39, + "source_counts_after_writer_stopped": { + "chat_members": 331, + "chats": 291, + "messages": 171788, + "schema_migrations": 1, + "users": 118 + }, + "restored_counts": { + "chat_members": 331, + "chats": 291, + "messages": 171655, + "schema_migrations": 1, + "users": 118 + }, + "messages_in_restored": 171655, + "per_chat_md5_equal": true, + "chats_compared": 258, + "big_chat_first_last_50_equal": true, + "schema_migrations_equal": true, + "indexes_equal": true, + "other_table_counts_equal": { + "chat_members": true, + "chats": true, + "schema_migrations": true, + "users": true + }, + "writer": { + "confirmed": 242, + "errors": 0, + "in_backup": 109, + "restored_is_exact_prefix": true, + "lost_confirmed_after_snapshot": 133, + "last_message_in_backup_at": "2026-10-12T17:07:14.212768Z", + "first_lost_message_at": "2026-10-12T17:07:14.237207Z" + }, + "app_on_restored_db": { + "login_ok": true, + "history_via_api_equals_restored": true, + "messages_read": 109 + }, + "reconciled": true + }, + { + "round": 3, + "backup_started_utc": "2026-10-12T17:07:30+00:00", + "dump_seconds": 1.4, + "dump_bytes": 5371057, + "restore_seconds": 1.76, + "analyze_seconds": 0.49, + "rto_seconds_restore_plus_analyze": 2.25, + "source_counts_after_writer_stopped": { + "chat_members": 332, + "chats": 292, + "messages": 172038, + "schema_migrations": 1, + "users": 119 + }, + "restored_counts": { + "chat_members": 332, + "chats": 292, + "messages": 171898, + "schema_migrations": 1, + "users": 119 + }, + "messages_in_restored": 171898, + "per_chat_md5_equal": true, + "chats_compared": 259, + "big_chat_first_last_50_equal": true, + "schema_migrations_equal": true, + "indexes_equal": true, + "other_table_counts_equal": { + "chat_members": true, + "chats": true, + "schema_migrations": true, + "users": true + }, + "writer": { + "confirmed": 250, + "errors": 0, + "in_backup": 110, + "restored_is_exact_prefix": true, + "lost_confirmed_after_snapshot": 140, + "last_message_in_backup_at": "2026-10-12T17:07:31.075846Z", + "first_lost_message_at": "2026-10-12T17:07:31.095982Z" + }, + "app_on_restored_db": { + "login_ok": true, + "history_via_api_equals_restored": true, + "messages_read": 110 + }, + "reconciled": true + } + ] +} diff --git a/evidence/track2/explain/chat_id_index-big-late-page.txt b/evidence/track2/explain/chat_id_index-big-late-page.txt new file mode 100644 index 00000000..934f248d --- /dev/null +++ b/evidence/track2/explain/chat_id_index-big-late-page.txt @@ -0,0 +1,20 @@ +Limit (cost=1673.53..1673.58 rows=20 width=238) (actual time=14.400..14.407 rows=51.00 loops=1) + Buffers: shared hit=2124 read=53 + -> Sort (cost=1673.53..1674.03 rows=202 width=238) (actual time=14.398..14.402 rows=51.00 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 44kB + Buffers: shared hit=2124 read=53 + -> Bitmap Heap Scan on messages (cost=8.89..1665.79 rows=202 width=238) (actual time=13.229..14.305 rows=300.00 loops=1) + Recheck Cond: (chat_id = $1) + Filter: (ROW(created_at, id) > ROW($2, $3)) + Rows Removed by Filter: 59700 + Heap Blocks: exact=2118 + Buffers: shared hit=2118 read=53 + -> Bitmap Index Scan on messages_chat_only (cost=0.00..8.84 rows=606 width=0) (actual time=1.829..1.829 rows=60000.00 loops=1) + Index Cond: (chat_id = $1) + Index Searches: 1 + Buffers: shared read=53 +Planning: + Buffers: shared hit=97 +Planning Time: 0.456 ms +Execution Time: 14.511 ms \ No newline at end of file diff --git a/evidence/track2/explain/chat_id_index-medium-late-page.txt b/evidence/track2/explain/chat_id_index-medium-late-page.txt new file mode 100644 index 00000000..58ce1e4e --- /dev/null +++ b/evidence/track2/explain/chat_id_index-medium-late-page.txt @@ -0,0 +1,20 @@ +Limit (cost=1673.53..1673.58 rows=20 width=238) (actual time=4.411..4.418 rows=51.00 loops=1) + Buffers: shared hit=571 read=14 + -> Sort (cost=1673.53..1674.03 rows=202 width=238) (actual time=4.410..4.413 rows=51.00 loops=1) + Sort Key: created_at, id + Sort Method: quicksort Memory: 52kB + Buffers: shared hit=571 read=14 + -> Bitmap Heap Scan on messages (cost=8.89..1665.79 rows=202 width=238) (actual time=4.306..4.361 rows=75.00 loops=1) + Recheck Cond: (chat_id = $1) + Filter: (ROW(created_at, id) > ROW($2, $3)) + Rows Removed by Filter: 14925 + Heap Blocks: exact=564 + Buffers: shared hit=565 read=14 + -> Bitmap Index Scan on messages_chat_only (cost=0.00..8.84 rows=606 width=0) (actual time=0.764..0.765 rows=15000.00 loops=1) + Index Cond: (chat_id = $1) + Index Searches: 1 + Buffers: shared hit=1 read=14 +Planning: + Buffers: shared hit=97 +Planning Time: 0.339 ms +Execution Time: 4.475 ms \ No newline at end of file diff --git a/evidence/track2/explain/chat_id_index-small-late-page.txt b/evidence/track2/explain/chat_id_index-small-late-page.txt new file mode 100644 index 00000000..49c99ea8 --- /dev/null +++ b/evidence/track2/explain/chat_id_index-small-late-page.txt @@ -0,0 +1,20 @@ +Limit (cost=1673.53..1673.58 rows=20 width=238) (actual time=0.129..0.130 rows=1.00 loops=1) + Buffers: shared hit=11 read=1 + -> Sort (cost=1673.53..1674.03 rows=202 width=238) (actual time=0.127..0.128 rows=1.00 loops=1) + Sort Key: created_at, id + Sort Method: quicksort Memory: 25kB + Buffers: shared hit=11 read=1 + -> Bitmap Heap Scan on messages (cost=8.89..1665.79 rows=202 width=238) (actual time=0.104..0.104 rows=1.00 loops=1) + Recheck Cond: (chat_id = $1) + Filter: (ROW(created_at, id) > ROW($2, $3)) + Rows Removed by Filter: 79 + Heap Blocks: exact=4 + Buffers: shared hit=5 read=1 + -> Bitmap Index Scan on messages_chat_only (cost=0.00..8.84 rows=606 width=0) (actual time=0.064..0.064 rows=80.00 loops=1) + Index Cond: (chat_id = $1) + Index Searches: 1 + Buffers: shared hit=1 read=1 +Planning: + Buffers: shared hit=97 +Planning Time: 0.368 ms +Execution Time: 0.207 ms \ No newline at end of file diff --git a/evidence/track2/explain/keyset_index-big-late-page.txt b/evidence/track2/explain/keyset_index-big-late-page.txt new file mode 100644 index 00000000..66092278 --- /dev/null +++ b/evidence/track2/explain/keyset_index-big-late-page.txt @@ -0,0 +1,10 @@ +Limit (cost=0.42..77.92 rows=20 width=237) (actual time=0.456..0.514 rows=51.00 loops=1) + Buffers: shared hit=6 read=4 + -> Index Scan using messages_chat_keyset on messages (cost=0.42..783.20 rows=202 width=237) (actual time=0.451..0.504 rows=51.00 loops=1) + Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Index Searches: 1 + Buffers: shared hit=6 read=4 +Planning: + Buffers: shared hit=120 +Planning Time: 0.921 ms +Execution Time: 0.636 ms \ No newline at end of file diff --git a/evidence/track2/explain/keyset_index-medium-late-page.txt b/evidence/track2/explain/keyset_index-medium-late-page.txt new file mode 100644 index 00000000..4160d79c --- /dev/null +++ b/evidence/track2/explain/keyset_index-medium-late-page.txt @@ -0,0 +1,10 @@ +Limit (cost=0.42..77.92 rows=20 width=237) (actual time=0.087..0.114 rows=51.00 loops=1) + Buffers: shared hit=5 read=2 + -> Index Scan using messages_chat_keyset on messages (cost=0.42..783.20 rows=202 width=237) (actual time=0.084..0.108 rows=51.00 loops=1) + Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Index Searches: 1 + Buffers: shared hit=5 read=2 +Planning: + Buffers: shared hit=110 +Planning Time: 0.551 ms +Execution Time: 0.156 ms \ No newline at end of file diff --git a/evidence/track2/explain/keyset_index-small-late-page.txt b/evidence/track2/explain/keyset_index-small-late-page.txt new file mode 100644 index 00000000..19a5a68f --- /dev/null +++ b/evidence/track2/explain/keyset_index-small-late-page.txt @@ -0,0 +1,10 @@ +Limit (cost=0.42..77.92 rows=20 width=237) (actual time=0.071..0.072 rows=1.00 loops=1) + Buffers: shared hit=2 read=2 + -> Index Scan using messages_chat_keyset on messages (cost=0.42..783.20 rows=202 width=237) (actual time=0.069..0.070 rows=1.00 loops=1) + Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Index Searches: 1 + Buffers: shared hit=2 read=2 +Planning: + Buffers: shared hit=110 +Planning Time: 0.373 ms +Execution Time: 0.112 ms \ No newline at end of file diff --git a/evidence/track2/explain/no_index-big-late-page.txt b/evidence/track2/explain/no_index-big-late-page.txt new file mode 100644 index 00000000..ff6edd57 --- /dev/null +++ b/evidence/track2/explain/no_index-big-late-page.txt @@ -0,0 +1,20 @@ +Limit (cost=6162.88..6165.20 rows=20 width=238) (actual time=12.084..15.940 rows=51.00 loops=1) + Buffers: shared hit=4307 + -> Gather Merge (cost=6162.88..6186.40 rows=202 width=238) (actual time=12.082..15.934 rows=51.00 loops=1) + Workers Planned: 2 + Workers Launched: 2 + Buffers: shared hit=4307 + -> Sort (cost=5162.85..5163.06 rows=84 width=238) (actual time=8.686..8.690 rows=44.33 loops=3) + Sort Key: created_at, id + Sort Method: quicksort Memory: 57kB + Buffers: shared hit=4307 + Worker 0: Sort Method: top-N heapsort Memory: 41kB + Worker 1: Sort Method: quicksort Memory: 58kB + -> Parallel Seq Scan on messages (cost=0.00..5160.17 rows=84 width=238) (actual time=1.775..8.612 rows=100.00 loops=3) + Filter: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Rows Removed by Filter: 40273 + Buffers: shared hit=4277 +Planning: + Buffers: shared hit=89 +Planning Time: 0.335 ms +Execution Time: 16.001 ms \ No newline at end of file diff --git a/evidence/track2/explain/no_index-medium-late-page.txt b/evidence/track2/explain/no_index-medium-late-page.txt new file mode 100644 index 00000000..b6482fff --- /dev/null +++ b/evidence/track2/explain/no_index-medium-late-page.txt @@ -0,0 +1,20 @@ +Limit (cost=6162.88..6165.20 rows=20 width=238) (actual time=19.403..27.573 rows=51.00 loops=1) + Buffers: shared hit=4307 + -> Gather Merge (cost=6162.88..6186.40 rows=202 width=238) (actual time=19.400..27.552 rows=51.00 loops=1) + Workers Planned: 2 + Workers Launched: 2 + Buffers: shared hit=4307 + -> Sort (cost=5162.85..5163.06 rows=84 width=238) (actual time=12.274..12.277 rows=21.00 loops=3) + Sort Key: created_at, id + Sort Method: quicksort Memory: 44kB + Buffers: shared hit=4307 + Worker 0: Sort Method: quicksort Memory: 27kB + Worker 1: Sort Method: quicksort Memory: 30kB + -> Parallel Seq Scan on messages (cost=0.00..5160.17 rows=84 width=238) (actual time=5.204..12.212 rows=25.00 loops=3) + Filter: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Rows Removed by Filter: 40348 + Buffers: shared hit=4277 +Planning: + Buffers: shared hit=85 +Planning Time: 0.565 ms +Execution Time: 27.653 ms \ No newline at end of file diff --git a/evidence/track2/explain/no_index-small-late-page.txt b/evidence/track2/explain/no_index-small-late-page.txt new file mode 100644 index 00000000..391c96c6 --- /dev/null +++ b/evidence/track2/explain/no_index-small-late-page.txt @@ -0,0 +1,20 @@ +Limit (cost=6162.88..6165.20 rows=20 width=238) (actual time=12.515..16.342 rows=1.00 loops=1) + Buffers: shared hit=4307 + -> Gather Merge (cost=6162.88..6186.40 rows=202 width=238) (actual time=12.513..16.339 rows=1.00 loops=1) + Workers Planned: 2 + Workers Launched: 2 + Buffers: shared hit=4307 + -> Sort (cost=5162.85..5163.06 rows=84 width=238) (actual time=8.455..8.456 rows=0.33 loops=3) + Sort Key: created_at, id + Sort Method: quicksort Memory: 25kB + Buffers: shared hit=4307 + Worker 0: Sort Method: quicksort Memory: 25kB + Worker 1: Sort Method: quicksort Memory: 25kB + -> Parallel Seq Scan on messages (cost=0.00..5160.17 rows=84 width=238) (actual time=7.451..8.415 rows=0.33 loops=3) + Filter: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Rows Removed by Filter: 40373 + Buffers: shared hit=4277 +Planning: + Buffers: shared hit=85 +Planning Time: 0.289 ms +Execution Time: 16.395 ms \ No newline at end of file diff --git a/evidence/track2/plans-meta.json b/evidence/track2/plans-meta.json new file mode 100644 index 00000000..ef6a739a --- /dev/null +++ b/evidence/track2/plans-meta.json @@ -0,0 +1,74 @@ +{ + "image": "postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c", + "limits": { + "server_cpus": 2, + "server_memory": "2g", + "pgbench_client_cpus": 2 + }, + "pg_settings": "image defaults", + "dataset": { + "messages_chats_minbytes_maxbytes": "121120|200|10|380", + "chat_sizes": [ + "60000x1", + "15000x2", + "2000x8", + "80x189" + ], + "seed_seconds": 3.3 + }, + "pgbench": { + "mode": "prepared", + "seconds": 10, + "warmup": 3, + "repeats": 3, + "read_clients": 4, + "write_clients": 8, + "page": "LIMIT 51 after a random position", + "write_repeats": 5, + "wal_method": "5000 app transactions, 1 client, autovacuum off, CHECKPOINT before; 3 repeats" + }, + "host": { + "platform": "Windows-10-10.0.19045-SP0", + "docker": "29.8.0" + }, + "variants": { + "keyset_index": "(chat_id, created_at, id) — used by the app", + "chat_id_index": "(chat_id) only", + "no_index": "primary key only", + "keyset_plus_sender": "app index + a second index (sender_id, created_at)" + }, + "sizes": { + "keyset_index": { + "index_build_s": 0.64, + "index_bytes": { + "messages_chat_keyset": "15097856", + "messages_pkey": "10051584" + }, + "table_bytes": 64290816 + }, + "chat_id_index": { + "index_build_s": 0.25, + "index_bytes": { + "messages_chat_only": "876544", + "messages_pkey": "4775936" + }, + "table_bytes": 35037184 + }, + "no_index": { + "index_build_s": 0.0, + "index_bytes": { + "messages_pkey": "4849664" + }, + "table_bytes": 35037184 + }, + "keyset_plus_sender": { + "index_build_s": 1.67, + "index_bytes": { + "messages_chat_keyset": "21102592", + "messages_pkey": "15286272", + "messages_sender_time": "12468224" + }, + "table_bytes": 86335488 + } + } +} diff --git a/evidence/track2/plans.png b/evidence/track2/plans.png new file mode 100644 index 0000000000000000000000000000000000000000..271af9feba6220a36d9981ee07af5f94289d433b GIT binary patch literal 117892 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 Date: Mon, 12 Oct 2026 20:20:00 +0300 Subject: [PATCH 5/7] =?UTF-8?q?docs:=20REPORT=20lab2,=20=D0=B4=D0=BE=D0=BA?= =?UTF-8?q?=D0=B0=D0=B7=D0=B0=D1=82=D0=B5=D0=BB=D1=8C=D1=81=D1=82=D0=B2?= =?UTF-8?q?=D0=B0=20=D1=81=D0=BE=20=D1=81=D1=82=D0=B5=D0=BD=D0=B4=D0=B0=20?= =?UTF-8?q?=D0=B8=D0=B7=20=D1=87=D0=B8=D1=81=D1=82=D0=BE=D0=B3=D0=BE=20clo?= =?UTF-8?q?ne,=20=D1=80=D0=B0=D0=B7=D0=BC=D0=B5=D1=80=D1=8B=20=D0=B8=D0=BD?= =?UTF-8?q?=D0=B4=D0=B5=D0=BA=D1=81=D0=BE=D0=B2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- REPORT.md | 258 +++++++++++++++++++++++-- bench/track2/index_sizes.py | 42 ++++ bench/track2/summarize.py | 9 +- evidence/clean-clone.txt | 40 ++++ evidence/explain-history.txt | 63 ++++++ evidence/logs-check.txt | 22 +++ evidence/make-check-validate.txt | 4 + evidence/make-test.txt | 2 + evidence/restart-hook-output.txt | 20 ++ evidence/sigterm.txt | 8 + evidence/student-tests.txt | 117 +++++++++++ evidence/test-persistence-postgres.txt | 24 +++ evidence/test-persistence-valkey.txt | 14 ++ evidence/track2/index-sizes.csv | 5 + evidence/track2/summary.md | 10 +- 15 files changed, 613 insertions(+), 25 deletions(-) create mode 100644 bench/track2/index_sizes.py create mode 100644 evidence/clean-clone.txt create mode 100644 evidence/explain-history.txt create mode 100644 evidence/logs-check.txt create mode 100644 evidence/make-check-validate.txt create mode 100644 evidence/make-test.txt create mode 100644 evidence/restart-hook-output.txt create mode 100644 evidence/sigterm.txt create mode 100644 evidence/student-tests.txt create mode 100644 evidence/test-persistence-postgres.txt create mode 100644 evidence/test-persistence-valkey.txt create mode 100644 evidence/track2/index-sizes.csv diff --git a/REPORT.md b/REPORT.md index e42f2b05..d6f0b8df 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,259 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Боданюк Алексей, БВТ2302 +- Целевая оценка: **5**, трек 2 «План запроса и восстановление» +- Ветка: `solution/bvt2302-bodanyuk`. Форк: ``. PR: «ЛР 2 — БВТ2302 — Боданюк — на 5» в mtusi2026/mtusi2026lab2 +- Стек: Python 3.13.16, Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.3.6 + psycopg-pool 3.3.3, redis-py 8.1.0 (протокол Valkey), argon2-cffi 25.1.0; PostgreSQL 18.6, Valkey 8.1.3. Все образы закреплены по тегу и digest, все Python-пакеты — по хешам ([requirements.txt](requirements.txt)) +- Источники: README, COURSE, контракт ([openapi.json](contracts/openapi.json), [семантика](contracts/README.md)), документация PostgreSQL (transactions, EXPLAIN, pg_dump/pg_restore, pgbench), Valkey persistence, RFC 7617, OWASP Password Storage Cheat Sheet (параметры Argon2id). Учтены замечания преподавателя к PR других студентов этого репозитория (см. раздел «Проверки, на которых ловили другие работы») +- Помощь ИИ: код, тесты, скрипты эксперимента и черновик отчёта написаны с помощью ИИ-ассистента Claude Code (Anthropic). Все команды и замеры реально выполнены на стенде ниже, их вывод лежит в [evidence/](evidence/). Пояснения для защиты — [docs/DEFENSE.md](docs/DEFENSE.md) ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Git, Docker с Compose v2 (проверено: Docker 29.8.0, Compose 5.5.1) и Python 3.9+ (secrets, публичные тесты). Для своих тестов нужен venv. Учётные данные не хранятся в Git: их создаёт скрипт. + +```sh +git clone mtusi2026lab2 && cd mtusi2026lab2 && git checkout solution/bvt2302-bodanyuk +python3 scripts/init_secrets.py # случайные локальные пароли -> ./secrets (git-ignored), идемпотентно +cp .env.example .env # необязательно: значения по умолчанию заданы в compose.yaml +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait # postgres+valkey healthy -> migrate -> api healthy +curl -i http://127.0.0.1:8080/health/ready # 200 {"status":"ok"}; Swagger: http://127.0.0.1:8080/docs +make check && make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +- **Миграции:** выполняет одноразовый сервис `migrate` (`python -m messenger.migrate`) перед стартом `api`. Повторный запуск: `docker compose run --rm migrate` → `0001_init: already applied, skipped`. +- **Свои тесты:** `python3 -m venv .venv`, затем `pip install --require-hashes --no-deps -r requirements.txt` и `pip install -r requirements-test.txt`, затем `make student-test`. Все тесты — около 3,5 мин. Те, что не требуют стенда: `make unit-test`. +- **Windows без make:** цели Makefile — однострочные команды. Перед публичными тестами нужно `$env:PYTHONUTF8=1`. Hook сохранности на Windows — `scripts/restart.cmd`: он запускает тот же `restart.sh` через Git Bash, потому что Windows не исполняет `.sh` напрямую. +- **Остановка:** безопасно — `docker compose down` (volumes сохраняются). Намеренное удаление учебных данных — `docker compose down -v` и `rm -rf secrets`. После этого стенд поднимается с нуля той же последовательностью. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +клиент ──HTTP──> api (uvicorn+Starlette, 1 процесс, пользователь app, PID 1) + ├─ PostgreSQL 18.6 — источник истины: users, chats, chat_members, messages (volume pgdata) + └─ Valkey 8.1.3 — единственное хранилище сессий, AOF appendfsync always (volume valkeydata) +migrate (одноразовый) ──> PostgreSQL: версионированные SQL-миграции, advisory lock, checksum +``` + +| Роль | Service | Образ | Health / readiness | Volume | Сеть / порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| API | `api` | `mtusi-messenger:lab2` (собирается из исходников) | `HEALTHCHECK` → `/health/ready` | — | `127.0.0.1:8080→8080` | secrets `database_url`, `cache_url` | +| БД | `postgres` | `postgres:18.6-bookworm@sha256:afc7e2d4…` | `pg_isready` | `pgdata` | только внутренняя | secret `postgres_password` | +| Сессии | `valkey` | `valkey/valkey:8.1.3-bookworm@sha256:fea8b3e6…` | `valkey-cli ping` | `valkeydata` | только внутренняя | secret `valkey_password` → include-файл конфига (не в аргументах процесса) | +| Миграции | `migrate` | тот же образ API | завершение с кодом 0 | — | внутренняя | secret `database_url` | + +- **Модель данных и транзакции** — [docs/DATA_MODEL.md](docs/DATA_MODEL.md), схема — [migrations/0001_init.sql](migrations/0001_init.sql). + - PK, FK (в том числе `messages (chat_id, sender_id) → chat_members`: отправитель обязан быть участником), `UNIQUE (username)`, CHECK. + - Свободный текст хранится в `bytea`, потому что контракт разрешает U+0000, а `text` в PostgreSQL его не хранит. +- **Создание чата** — одна транзакция: `INSERT chats` → `INSERT chat_members` из `unnest(member_ids)`. Неизвестный участник ломает второй INSERT по FK, и откатывается всё, включая уже вставленный чат. +- **Порядок сообщений.** `UPDATE chats SET last_message_at = greatest(clock_timestamp(), last_message_at + 1 мкс) … RETURNING` блокирует строку чата до COMMIT. Поэтому писатели одного чата идут по очереди, а время строго растёт в порядке коммитов. Это перенос инварианта lab1 («время назначается под замком») в БД. +- **Пагинация** — тот же keyset-cursor, что в lab1, но в SQL: `(created_at, id) > ($2,$3)` по индексу `(chat_id, created_at, id)`. Запросов два — первая страница и после cursor, без `IS NULL OR`. Cursor проверяет диапазон времени (до 9999 года): дата вне диапазона даёт 400, а не 500. +- **Аутентификация** ([authhdr.py](src/messenger/authhdr.py), [sessions.py](src/messenger/sessions.py), [passwords.py](src/messenger/passwords.py)): + - `Basic` принимается только на `POST /auth/sessions`. Любой битый заголовок (не base64, не UTF-8, без `:`) даёт 401, пароль может содержать `:`; + - пароль: 12–128 code points, не из одних пробелов; Argon2id (m=19 MiB, t=2, p=1) считается в отдельном потоке с ограничением параллельности 2; + - неизвестный пользователь проверяется против фиктивного хеша: время и ответ такие же, как при неверном пароле; + - токен — `token_urlsafe(32)` (256 бит), хранится только SHA-256 токена; + - `X-User-Id` и `Basic` на бизнес-endpoint дают 401 с `WWW-Authenticate: Bearer realm="messenger"`. +- **Сессии — роль Valkey (уровень 4).** Источник истины для сессий — Valkey, и это **не** кэш над PostgreSQL. Значение ключа — `{user_id, expires_at}`, срок — абсолютный `PXAT`. + - **Expiry:** `expires_at` проверяется при каждом чтении; рестарт срок не продлевает. + - **Инвалидация:** logout = `DEL`. + - **Persistence:** `appendonly yes`, `appendfsync always`, `maxmemory-policy noeviction` — подтверждённые вход и logout переживают рестарт и падение, а сессии не вытесняются молча. + - **Отказ Valkey:** проверить сессию нельзя → 503 на защищённые запросы и на logout; анонимный доступ никогда не открывается. + + Копия одна, поэтому нет сценария «logout потерялся в кэше и токен ожил». Переменная `SESSION_STORE=postgres` переключает сессии на таблицу `sessions` (проверено тестами и hook сохранности). +- **Ограничения ресурсов** ([db.py](src/messenger/db.py)): + - пул psycopg: min 1, max 10, ожидание соединения ≤ 3 с; + - сервер: `statement_timeout` = 2,5 с, `lock_timeout` = 1,25 с, `idle_in_transaction_session_timeout` = 10 с; + - клиентский дедлайн 3 с. Он работает в отдельной задаче: при замороженном PostgreSQL (`docker pause`) psycopg после отмены ещё до 10 с ждёт ответа на cancel. Без этого ответ приходил через 13 с, с этим — через 3,0 с; + - Valkey: таймауты сокета 0,5 с, без скрытых повторов; + - все отказы зависимостей → 503 `unavailable`. +- **Readiness** — 200, только если отвечают PostgreSQL и Valkey (обе зависимости критичны для обязательного пути). Liveness — только жизнь процесса. +- **Из lab1 перенесено** без изменений: формат ошибок и `X-Request-Id`, строгая валидация JSON (лишние поля, типы, NaN, суррогаты, склеенные объекты), JSON-логи без тел и текстов, graceful SIGTERM (≤ 8 с, readiness 503), Swagger. **Изменено:** хранилище, идентификация, cursor — с проверкой диапазона. Перенос сделан отдельным коммитом `893beaa`. + +Соответствие `.env.example` реальной конфигурации ([config.py](src/messenger/config.py), [compose.yaml](compose.yaml)): + +| Переменная | Значение | Где используется | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT`, `APP_ENV` | `0.0.0.0`, `8080`, `lab` | bind uvicorn, стартовый лог | +| `SESSION_TTL_SECONDS` | `3600` | срок сессии; compose передаёт его в контейнер (проверено `printenv` в тесте TTL=2) | +| `DATABASE_URL_FILE` | `/run/secrets/database_url` | строка подключения из secret-файла | +| `SESSION_STORE` | `valkey` (или `postgres`; `redis` — синоним `valkey`) | выбор хранилища сессий | +| `CACHE_URL_FILE` | `/run/secrets/cache_url` | адрес и пароль Valkey из secret-файла | +| `DB_POOL_MIN/MAX`, `DB_TIMEOUT_SECONDS`, `CACHE_TIMEOUT_SECONDS`, `PASSWORD_HASH_CONCURRENCY` | 1/10, 3, 0.5, 2 | пул и таймауты, параллельность Argon2id | +| `LOG_LEVEL`, `DOCS_ENABLED`, `APP_PUBLISH_PORT` | `info`, `true`, `8080` | логи, Swagger, порт на хосте (только `127.0.0.1`) | ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Стенд: Windows 10 22H2, AMD Ryzen 5 3400G (4 ядра / 8 потоков), 16 ГБ RAM, Docker Desktop 29.8.0 (WSL2), дата 2026-10-12. Все проверки уровней 3 и 4 ниже выполнены на стенде, поднятом **из чистого clone** с пустыми volumes (отдельный compose-проект на порту 8081). -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Критерий README | Команда / сценарий | Наблюдаемый результат | Файл | +| --- | --- | --- | --- | +| Чистый clone, secrets, миграции с нуля | `init_secrets.py`, `compose up --build --wait`, `compose logs migrate`, повтор `run migrate` | все сервисы healthy; `0001_init: applied`, повтор — `already applied, skipped`; uid 10001, PID 1; `secrets/` и `.env` игнорируются Git | [clean-clone.txt](evidence/clean-clone.txt) | +| Контракт | `make check`, `make validate` | PASS, PASS | [make-check-validate.txt](evidence/make-check-validate.txt) | +| **3:** публичный smoke | `make test` | `PASS: lab2 public API scenario` | [make-test.txt](evidence/make-test.txt) | +| **3:** данные и сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; `StartedAt` api, postgres, valkey изменились, volumes те же | [test-persistence-valkey.txt](evidence/test-persistence-valkey.txt), [restart-hook-output.txt](evidence/restart-hook-output.txt) | +| то же для `SESSION_STORE=postgres` | тот же тест после `SESSION_STORE=postgres compose up -d api` | PASS, сессии в таблице `sessions` | [test-persistence-postgres.txt](evidence/test-persistence-postgres.txt) | +| **3:** PK/FK, unique username, миграции с нуля | [0001_init.sql](migrations/0001_init.sql), `test_migrations_rerun_is_a_noop` | схема применяется к пустому volume; повтор ничего не меняет | [student-tests.txt](evidence/student-tests.txt) | +| **3:** атомарное создание чата | `test_create_chat_rolls_back_after_the_chat_row_was_inserted` | `n_tup_ins` таблицы `chats` вырос (INSERT был), строки нет, членство не изменилось | там же | +| **3:** Basic только на входе, Bearer, expiry, отзыв, `X-User-Id` не даёт доступ, KDF | `test_api.py` (18 проверок аутентификации), `test_short_ttl_expires`, `test_secrets_are_not_stored_in_plain_text` | 401 с нужным challenge; logout → 401; TTL=2 → 401; хеш `$argon2id$v=19$m=19456,t=2,p=1$`; в Valkey только `session:` | там же | +| **3:** secrets и volumes не в Git | `git check-ignore secrets/database_url .env` | оба игнорируются; в отчёте и evidence нет паролей и токенов | [clean-clone.txt](evidence/clean-clone.txt), [logs-check.txt](evidence/logs-check.txt) | +| **4:** Valkey реально хранит сессии с TTL и persistence | `test_logout_during_valkey_outage_is_never_lost`, `test_restart_does_not_extend_ttl`, persistence-тест | сессии переживают рестарт Valkey; TTL не продлевается; отозванный токен остаётся 401 после рестарта Valkey и API (10 проверок GET и POST) | [student-tests.txt](evidence/student-tests.txt) | +| **4:** параметризованные запросы, ограниченный пул, таймауты | [repo.py](src/messenger/repo.py) (`%s`), [db.py](src/messenger/db.py) | max 10 соединений; пауза PostgreSQL → 503 за 3,0 с; Valkey → 0,5 с | `test_postgres_failure[pause]`, `test_valkey_failure[pause]` | +| **4:** гонка регистрации | `test_registration_race_exactly_one_201_and_seven_409` | 8 одновременных → ровно `[201] + [409]×7` (сравниваются HTTP-коды), в БД 1 строка | [student-tests.txt](evidence/student-tests.txt) | +| **4:** rollback составной операции | см. «атомарное создание чата» | откат **после** первого INSERT | там же | +| **4:** индекс истории и EXPLAIN на ≥ 10 000 | `make explain`, `test_late_page_uses_index_range_not_filter` | 50 189 сообщений, 20 000 в чате; поздняя страница при generic plan: `Index Cond: … ROW(created_at, id) > ROW($2, $3)`, 5 буферов, 0,11 мс; вариант с `IS NULL OR` — `Rows Removed by Filter: 19950`, 526 буферов, 3,3 мс; OFFSET — 526 буферов, 4,4 мс | [explain-history.txt](evidence/explain-history.txt) | +| **4:** expiry, logout, неверный пароль | `test_short_ttl_expires[valkey/postgres]`, `test_logout_revokes_only_this_token`, `test_wrong_password_and_unknown_user_give_the_same_401` | 401 после `expires_at`; logout отзывает только этот токен; неверный пароль и неизвестный пользователь — одинаковый 401 | [student-tests.txt](evidence/student-tests.txt) | +| **4:** недоступность Redis/БД, аноним не доверенный | `test_failures.py`: stop/pause Valkey и PostgreSQL с **действующим** токеном, `LOCK TABLE`, восстановление в `finally` | 503 в пределах дедлайна; аноним — 401; readiness 503; после восстановления тот же токен и данные на месте | там же | +| Логи без секретов и текстов | grep по логу api после трафика | 0 текстов сообщений, паролей, токенов, паролей БД; события `login_failed`, `session_store_unavailable`, access-строки | [logs-check.txt](evidence/logs-check.txt) | +| SIGTERM сохранён из lab1 | `docker compose stop api` × 3 | 1,1–1,2 с, exit 0, без OOM | [sigterm.txt](evidence/sigterm.txt) | +| **5:** трек 2 | `bench/track2/*.py` | см. ниже | [evidence/track2/](evidence/track2/) | + +Итог своих тестов на стенде из чистого clone: **108 passed** (45 unit + 63 против стенда), 3 мин 28 с ([student-tests.txt](evidence/student-tests.txt)). + +### Проверки, на которых ловили другие работы, и наш результат + +| Замечание к чужим PR | У нас | Где проверено | +| --- | --- | --- | +| logout при упавшем Redis → после восстановления токен снова 200 | logout при упавшем Valkey = 503 (ничего не отозвано, клиент это видит). После восстановления logout → 401, и 401 сохраняется после рестарта Valkey и API | `test_logout_during_valkey_outage_is_never_lost` | +| истёкшая сессия принимается из кэша | expiry проверяется при каждом чтении; ключ живёт до абсолютного `PXAT` | `test_short_ttl_expires` | +| пауза PostgreSQL → запрос висит 8+ с; ограничено ожидание пула, но не SQL | клиентский дедлайн в отдельной задаче + `statement_timeout` / `lock_timeout` | `test_postgres_failure[pause]`, `test_locked_table_gives_bounded_503` | +| отказ БД маскируется под 401 | 503 `unavailable` для действующего токена, в обоих режимах сессий | `test_postgres_failure`, `test_postgres_session_store` | +| cursor в `Filter` при generic plan | два отдельных запроса | `test_explain.py` | +| `{"text":"hello\u0000world"}` → 500 | 201, текст сохраняется и читается побайтно | `test_unicode_limits_are_code_points_and_nul_is_stored` | +| пароль из 12 пробелов принимается; `Basic é` → 500 | 400; 401 | `test_bad_password_on_registration_is_400`, `test_malformed_basic_is_401_not_500` | +| bcrypt и пароли длиной 73–128 символов → 500 | Argon2id без ограничения длины; 128 кириллических символов работают | `test_edge_passwords_register_and_login` | +| дата в cursor вне диапазона → 500 | 400 | `test_broken_cursors_are_400_not_500` | +| `SESSION_TTL_SECONDS` не доходит до контейнера | compose передаёт его, тест читает `printenv` в контейнере | `test_short_ttl_expires` | +| в инструкции нет создания secrets | `scripts/init_secrets.py` в первой команде | [clean-clone.txt](evidence/clean-clone.txt) | +| нет executable bit у `restart.sh` | `100755` в Git | `git ls-files -s scripts/restart.sh` | +| тесты отказов засчитывают любую ошибку | сравниваются конкретные коды и время, восстановление в `finally` | `test_failures.py` | + +## Трек 2. План запроса и восстановление + +### Гипотезы + +1. С индексом `(chat_id, created_at, id)` и keyset-запросом стоимость страницы почти не зависит от размера чата и позиции страницы. С индексом только по `(chat_id)` keyset-запросу приходится сортировать весь чат. OFFSET читает весь префикс до позиции. Без индекса читается вся таблица. +2. Каждый вторичный индекс удорожает запись: больше WAL и места, ниже пропускная способность. +3. `pg_dump` даёт согласованный снимок. Восстановление 100 000+ сообщений в новое хранилище занимает секунды, сверка сходится полностью, а граница потери данных — момент снимка. + +### Методика + +- **Изолированная БД** ([plans.py](bench/track2/plans.py)): отдельный контейнер `postgres:18.6` (тот же digest), `--cpus 2 --memory 2g`, настройки по умолчанию, без опубликованных портов. Схема — наши миграции. +- **Данные** — детерминированный seed: **121 120 сообщений в 200 чатах** неравномерно — 1 × 60 000, 2 × 15 000, 8 × 2 000, 189 × 80. Текст 10–380 байт. +- **Генератор:** pgbench (`-M prepared`, как у драйвера) в отдельном контейнере со своими 2 CPU. +- **Чтение:** одна страница `LIMIT 51` после **случайной** позиции чата (200 позиций по всей длине). Запрос keyset — это SQL приложения (`HISTORY_AFTER`), OFFSET — для сравнения. 4 клиента, прогрев 3 с, замер 10 с, 3 повтора. Индексы: `keyset_index` (наш), `chat_id_index`, `no_index` (только PK). +- **Запись:** транзакция сообщения приложения (`UPDATE chats … RETURNING` + `INSERT`) в случайный из 200 чатов. + - TPS и задержки: 8 клиентов, 5 повторов по 10 с. + - WAL: детерминированно — 5 000 транзакций в 1 клиент, autovacuum таблицы выключен, `CHECKPOINT` перед прогоном, 3 повтора. Первые замеры WAL под 8 клиентами давали разброс в 2 раза из-за checkpoint и autovacuum посреди прогона, поэтому методика заменена. + - Индексы: без вторичных, наш, наш + `(sender_id, created_at)`. +- **Размер индексов** — отдельно на одинаковых 121 120 строках ([index_sizes.py](bench/track2/index_sizes.py)). +- **Backup/restore** ([backup_restore.py](bench/track2/backup_restore.py)) на **живой БД стенда**: к данным стенда добавлены те же 121 120 сообщений, всего 171 410–171 898. Во время дампа писатель отправляет сообщения через API (~40/с). + - `pg_dump -Fc -Z 6` → новый контейнер PostgreSQL с **новым volume** → `pg_restore -j 2` → `ANALYZE` → сверка. + - Сверка: количество строк по таблицам, MD5 всех сообщений (`id | created_at | text`) **каждого** чата, первые и последние 50 сообщений самого большого чата, `schema_migrations`, список индексов. Сообщения писателя в копии должны быть **точным префиксом** подтверждённых. + - Затем наш образ API запускается на восстановленной БД: вход по старому паролю и чтение чата писателя через API. + - 3 раунда. + +```sh +python bench/track2/plans.py # чтение и запись (~25 мин) +python bench/track2/plans.py --writes-only # только запись (~6 мин) +python bench/track2/index_sizes.py # размеры индексов +python bench/track2/backup_restore.py --repeats 3 +pip install -r requirements-bench.txt && python bench/track2/summarize.py # summary.md + plans.png +``` + +### Результаты: чтение одной страницы + +Медиана 3 повторов; в скобках — min–max TPS между повторами. Полная таблица — [summary.md](evidence/track2/summary.md), сырые данные — [reads.csv](evidence/track2/reads.csv). + +| Индекс | Запрос | Чат | TPS | p50, мс | p95, мс | p99, мс | +| --- | --- | ---: | ---: | ---: | ---: | ---: | +| **(chat_id, created_at, id)** | **keyset** | 60 000 | **2 655** (2 402–3 486) | **0,81** | **2,28** | 32,8 | +| (chat_id, created_at, id) | keyset | 15 000 | 2 991 | 0,76 | 1,68 | 32,8 | +| (chat_id, created_at, id) | keyset | 80 | 4 018 | 0,58 | 1,69 | 11,9 | +| (chat_id, created_at, id) | OFFSET | 60 000 | 180 | 11,6 | 69,2 | 81,0 | +| (chat_id, created_at, id) | OFFSET | 15 000 | 791 | 2,53 | 43,9 | 52,6 | +| (chat_id) | keyset | 60 000 | 89,5 | 27,0 | 80,9 | 99,0 | +| (chat_id) | keyset | 15 000 | 362 | 5,64 | 55,7 | 59,4 | +| (chat_id) | OFFSET | 60 000 | 28,3 | 120 | 278 | 389 | +| только PK | keyset | 60 000 | 29,0 | 112 | 197 | 293 | +| только PK | keyset | 80 | 36,3 | 102 | 182 | 193 | + +![Трек 2](evidence/track2/plans.png) + +- **Наш индекс + keyset:** p50 и p95 почти не зависят от размера чата (0,6–0,8 мс и 1,7–2,3 мс от 80 до 60 000 сообщений). Узел плана `Index Scan … Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3)))` читает ровно 51 строку ([explain/keyset_index-big-late-page.txt](evidence/track2/explain/keyset_index-big-late-page.txt)). +- **OFFSET с тем же индексом:** стоимость растёт с позицией. На чате в 60 000 TPS в 15 раз ниже, p95 в 30 раз выше: индекс читается с начала чата до смещения. +- **Индекс только по `chat_id`:** keyset-запрос вынужден взять все строки чата и сделать top-N sort. На 60 000 TPS в 30 раз ниже (89,5 против 2 655). На маленьких чатах (80) разницы нет — сортировать почти нечего. +- **Без индекса:** около 30 TPS на любом чате, потому что каждый запрос сканирует всю таблицу. Размер чата почти не влияет, влияет размер таблицы. +- **Почему p99 нашего варианта ~33 мс при p50 < 1 мс.** Это хвост стенда, а не плана: Docker Desktop в VM на Windows, CFS-квота `--cpus 2` и общий CPU с генератором. Тот же хвост виден на маленьком чате, где работы почти нет. В плане такого хвоста нет (`Execution Time` 0,1 мс). + +### Результаты: стоимость записи + +| Вторичные индексы messages | TPS (8 клиентов, min–max) | p50, мс | p95, мс | WAL на вставку, байт (min–max) | Размер вторичных индексов на 121 120 строк | +| --- | ---: | ---: | ---: | ---: | ---: | +| нет | 1 954 (1 540–2 055) | 3,55 | 7,14 | 1 930 (1 884–1 940) | 0 | +| (chat_id, created_at, id) — наш | 1 577 (1 002–1 630) | 4,73 | 8,50 | 2 910 (2 800–2 926) | 6,8 МиБ (59 байт/строку) | +| наш + (sender_id, created_at) | 1 223 (896–1 607) | 6,25 | 9,30 | 3 318 (3 310–3 414) | 9,8 МиБ (85 байт/строку) | + +- **WAL** — самая надёжная метрика (разброс 1–3%). Наш индекс добавляет **+51%** WAL на вставку, второй индекс — ещё +14%. WAL — это и запись на диск, и трафик репликации, и объём архива для PITR. +- **TPS** падает примерно на 19% и 37% (медианы), но разброс повторов большой (до ±30%), поэтому это тенденция, а не точная цифра. Транзакция также упирается в блокировку строки чата и fsync COMMIT, общие для всех вариантов. +- Индекс только по `chat_id` занимает 0,9 МиБ против 6,8 МиБ у нашего: B-tree PostgreSQL ≥ 13 дедуплицирует одинаковые ключи. Ради поздних страниц мы сознательно платим местом и записью. +- **Вывод:** наш единственный вторичный индекс окупается — чтение страницы большого чата в 30 раз дешевле альтернатив, а запись дорожает умеренно. Второй индекс без запроса, который им пользуется, — чистая потеря. + +### Результаты: backup → восстановление в новое хранилище → сверка + +| Раунд | Сообщений | Дамп, с | Размер дампа | Восстановление, с | ANALYZE, с | Сверка | Писатель: подтверждено / в копии / после снимка | API на восстановленной БД | +| ---: | ---: | ---: | ---: | ---: | ---: | --- | --- | --- | +| 1 | 171 410 | 1,47 | 5,1 МиБ | 2,21 | 0,57 | всё совпало (257 чатов) | 237 / 101 / 136 | вход ✓, история = копия ✓ | +| 2 | 171 655 | 1,70 | 5,1 МиБ | 1,90 | 0,49 | всё совпало (258 чатов) | 242 / 109 / 133 | ✓ | +| 3 | 171 898 | 1,40 | 5,1 МиБ | 1,76 | 0,49 | всё совпало (259 чатов) | 250 / 110 / 140 | ✓ | + +Данные — [backup.json](evidence/track2/backup.json). «Всё совпало» означает, что одновременно выполнено: +- MD5 сообщений каждого чата; +- первые и последние 50 сообщений чата в 60 000; +- число пользователей, чатов и участников; +- `schema_migrations` и список индексов; +- сообщения писателя в копии — **точный префикс** подтверждённых. + +### Время восстановления и границы потери данных + +- **Согласованность.** `pg_dump` работает в одной транзакции REPEATABLE READ, то есть это MVCC-снимок на момент старта дампа. В копии нет «рваного» состояния: сообщения писателя — непрерывный префикс без пропусков. Например, в раунде 1 последнее сообщение копии — 17:06:57.831, первое потерянное — 17:06:57.857, а записи шли всё время дампа. +- **RPO.** Теряется всё, что подтверждено **после старта снимка**: в эксперименте 133–140 сообщений за ~3,5 с (дамп плюс 2 с после него). В эксплуатации RPO равен интервалу между дампами: при ночном дампе — до 24 часов подтверждённых сообщений. Сессии в Valkey в этот бэкап не входят: после восстановления пользователи входят заново, что безопасно. +- **RTO на этих данных:** около 2,3–2,8 с = `pg_restore` (1,8–2,2 с, включая перестройку индексов) + `ANALYZE` (0,5 с), плюс переключение `DATABASE_URL` и старт API (~2 с). Время восстановления растёт линейно с объёмом данных и индексов. Дамп 5,1 МиБ на 172 000 сообщений — около 31 байта на сообщение после сжатия. +- **Как уменьшить RPO/RTO:** непрерывный архив WAL и PITR (pgBackRest или WAL-G) сокращают RPO до секунд и позволяют восстановить состояние на любой момент. Потоковая реплика сокращает RTO до времени переключения. Синхронная реплика — RPO≈0 ценой задержки COMMIT. Проверять восстановление нужно регулярно, как этот скрипт: копия, которую не восстанавливали, — ещё не копия. + +### Ограничения эксперимента + +- Данные синтетические: равномерное время сообщений, один отправитель на чат в seed. На реальном распределении селективность индексов другая. +- Настройки PostgreSQL по умолчанию; данные помещаются в `shared_buffers` и кэш ОС, поэтому замерено «тёплое» чтение. На холодном диске разница между вариантами будет больше. +- pgbench в режиме closed loop; один хост с Docker Desktop (VM WSL2) — хвосты p99 и TPS записи шумные (разброс указан). Повторов 3 и 5, без статистических тестов. +- Backup — логический (`pg_dump`) на небольшом объёме. Для больших баз нужны физические бэкапы с WAL. Valkey не входит в эксперимент восстановления: сессии одноразовые. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| Воздействие | Что ожидаем | Что наблюдали | Восстановление / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `restart.sh`: stop api → restart postgres, valkey → start api | данные и тот же токен работают | PASS (оба режима сессий), все три `StartedAt` новые | ~11 с до готовности; потерь нет | +| `docker compose stop postgres` с действующим токеном | 503, аноним 401, readiness 503 | 503 < 3,6 с на `/users/me`, `/chats`, историю | после старта тот же токен и сообщение на месте | +| `docker pause postgres` | ограниченное время ответа | 503 через 3,0 с (до исправления — 13 с) | после unpause всё работает | +| `LOCK TABLE messages` на 6 с | быстрый отказ, а не ожидание | 503 < 3,6 с (`lock_timeout`) | после снятия блокировки 200 | +| stop или pause Valkey | 503, аноним 401 | 503 за 0,5 с | после старта прежние сессии действуют (AOF) | +| logout во время отказа Valkey | отзыв не теряется | 503 (не отозван) → после восстановления logout 204 → 401 и после рестарта Valkey и API | токен не «оживает» | +| `SESSION_TTL_SECONDS=2` | 401 после `expires_at` | 401 (Valkey и PostgreSQL) | — | +| TTL 12 с + рестарт Valkey и API | срок не продлевается | 200 до `expires_at`, 401 после | — | +| 8 одновременных регистраций одного имени | 1 × 201, 7 × 409 | ровно так, одна строка в БД | — | +| 10 клиентов × 10 сообщений | 100 уникальных, строгий порядок | 100, 15 страниц по 7, уникальное время | — | +| backup во время записи → restore в новое хранилище | согласованный снимок | префикс без пропусков, сверка 100% | RPO = момент снимка; RTO ≈ 2,5 с на 172 000 сообщений | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Выдерживается:** + - рестарт API и обоих хранилищ без потери подтверждённых данных и сессий; + - отказ или зависание PostgreSQL или Valkey без зависаний и без анонимного доступа; + - гонки регистрации и записи в один чат. +- **Не выдерживается:** + - потеря хоста или диска (один узел, нет реплик и архива WAL); + - отказ Valkey означает отказ всех защищённых запросов: это сознательная плата за отсутствие второй копии сессий. Повысить доступность можно репликой Valkey или `SESSION_STORE=postgres`. +- **Учебные упрощения:** HTTP без TLS (только локальный стенд с синтетическими данными); secret-файлы читаемы на хосте (0644, чтобы их могли прочитать пользователи контейнеров); один экземпляр API (реплики и балансировщик — lab3). +- **Список чатов при одновременном создании.** Он сортируется по `created_at` без глобального замка. Чат, закоммиченный «задним числом», может не попасть в уже идущий обход, но виден при новом. Для сообщений эта проблема закрыта блокировкой строки чата. +- **Подтверждено замерами:** выигрыш индекса и keyset, стоимость WAL, восстановление и сверка. **Гипотезы** (не проверялись): поведение на холодном диске и на данных в десятки ГБ; выигрыш PITR. diff --git a/bench/track2/index_sizes.py b/bench/track2/index_sizes.py new file mode 100644 index 00000000..5e2c0a02 --- /dev/null +++ b/bench/track2/index_sizes.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""Index sizes of every variant on the SAME 121 120-row dataset (no writes in between). + + python bench/track2/index_sizes.py # ~2 min, writes evidence/track2/index-sizes.csv +""" +from __future__ import annotations + +import csv +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).parent)) +import plans # noqa: E402 (same image, limits, schema and deterministic seed) + + +def main() -> int: + plans.start_container("2", "2g") + try: + plans.psql("".join(p.read_text(encoding="utf-8") for p in sorted((plans.ROOT / "migrations").glob("*.sql")))) + plans.psql(plans.SEED) + rows = int(plans.psql("SELECT count(*) FROM messages;")) + out = [] + for variant in plans.VARIANTS: + info = plans.use_variant(variant) + secondary = sum(int(b) for name, b in info["index_bytes"].items() if name != "messages_pkey") + out.append({"variant": variant, "rows": rows, "table_bytes": info["table_bytes"], + "pkey_bytes": int(info["index_bytes"]["messages_pkey"]), "secondary_index_bytes": secondary, + "secondary_bytes_per_row": round(secondary / rows, 1), "index_build_seconds": info["index_build_s"]}) + print(out[-1], flush=True) + finally: + plans.sh(["docker", "rm", "-f", "-v", plans.CLIENT, plans.NAME], check=False) + path = plans.ROOT / "evidence/track2/index-sizes.csv" + with path.open("w", newline="", encoding="utf-8") as f: + writer = csv.DictWriter(f, fieldnames=list(out[0])) + writer.writeheader() + writer.writerows(out) + print("done:", path) + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/bench/track2/summarize.py b/bench/track2/summarize.py index 64876d5c..cfb8a515 100644 --- a/bench/track2/summarize.py +++ b/bench/track2/summarize.py @@ -42,6 +42,7 @@ def fmt(x: float) -> str: def main() -> int: sys.stdout.reconfigure(encoding="utf-8") reads, writes, wal = load("reads.csv"), load("writes.csv"), load("wal.csv") + sizes_rows = {r["variant"]: r for r in load("index-sizes.csv")} meta = json.loads((OUT / "plans-meta.json").read_text(encoding="utf-8")) r = agg(reads, ("variant", "query", "chat"), ("tps", "p50_ms", "p95_ms", "p99_ms")) w = agg(writes, ("variant",), ("tps", "p50_ms", "p95_ms", "p99_ms")) @@ -60,14 +61,16 @@ def main() -> int: md += ["", "## Запись: транзакция сообщения приложения (UPDATE chats … RETURNING + INSERT)", "", "TPS и задержка — медиана 5 повторов по 10 с, 8 клиентов. WAL — медиана 3 детерминированных прогонов: " "5 000 транзакций, 1 клиент, autovacuum выключен, CHECKPOINT перед прогоном.", "", - "| Индексы messages | TPS (min–max) | p50, мс | p95, мс | p99, мс | WAL, байт/вставку (min–max) | Размер индексов, МиБ |", + "| Индексы messages | TPS (min–max) | p50, мс | p95, мс | p99, мс | WAL, байт/вставку (min–max) | Доп. индексы на 121 120 строк, МиБ |", "| --- | ---: | ---: | ---: | ---: | ---: | ---: |"] for variant in ("no_index", "keyset_index", "keyset_plus_sender"): v = w[(variant,)] - idx = meta["sizes"][variant]["index_bytes"] - idx_mib = sum(int(b) for b in idx.values()) / 2**20 + idx_mib = int(sizes_rows[variant]["secondary_index_bytes"]) / 2**20 # same dataset for every variant md.append(f"| {variant} | {fmt(v['tps'])} ({fmt(v['tps_min'])}–{fmt(v['tps_max'])}) | {fmt(v['p50_ms'])} | {fmt(v['p95_ms'])} " f"| {fmt(v['p99_ms'])} | {v['wal_bytes_per_insert']:.0f} ({v['wal_min']}–{v['wal_max']}) | {idx_mib:.1f} |") + md += ["", "Размеры индексов измерены отдельно на одинаковых 121 120 строках (bench/track2/index_sizes.py); " + "первичный ключ во всех вариантах — " + f"{int(sizes_rows['no_index']['pkey_bytes']) / 2**20:.1f} МиБ, таблица — " + f"{int(sizes_rows['no_index']['table_bytes']) / 2**20:.1f} МиБ."] (OUT / "summary.md").write_text("\n".join(md) + "\n", encoding="utf-8", newline="\n") print("\n".join(md)) diff --git a/evidence/clean-clone.txt b/evidence/clean-clone.txt new file mode 100644 index 00000000..76222563 --- /dev/null +++ b/evidence/clean-clone.txt @@ -0,0 +1,40 @@ +# Clean clone -> build -> fresh volumes -> migrations from zero, 2026-10-12T17:08:32Z +$ git clone --branch solution/bvt2302-bodanyuk mtusi2026lab2 && cd mtusi2026lab2 +eb92e8e bench: трек 2 — планы запросов, стоимость записи, backup/restore со сверкой +$ python scripts/init_secrets.py +created secrets/postgres_password +created secrets/valkey_password +created secrets/database_url +created secrets/cache_url +$ cp .env.example .env # + COMPOSE_PROJECT_NAME/APP_PUBLISH_PORT only to run beside the main stand +$ docker compose --env-file .env config --quiet +config OK +$ docker compose --env-file .env up -d --build --wait + Container mtusi-lab2-clean-api-1 Healthy + Container mtusi-lab2-clean-migrate-1 Exited + Container mtusi-lab2-clean-postgres-1 Healthy + Container mtusi-lab2-clean-valkey-1 Healthy +$ docker compose ps +SERVICE IMAGE STATUS +api mtusi-messenger:lab2 Up 6 seconds (healthy) +postgres postgres:18.6-bookworm@sha256:afc7e2d441324c0388fa80c3d24f733b4194a4eb7f47dd8ee2b08eb1a24a647c Up 13 seconds (healthy) +valkey valkey/valkey:8.1.3-bookworm@sha256:fea8b3e67b15729d4bb70589eb03367bab9ad1ee89c876f54327fc7c6e618571 Up 13 seconds (healthy) +$ docker compose logs migrate +migrate: 0001_init: applied +migrate: done, 1 migration file(s) checked +$ docker compose volume ls +mtusi-lab2-clean_pgdata +mtusi-lab2-clean_valkeydata +$ curl -i http://127.0.0.1:8081/health/ready +HTTP/1.1 200 OK +x-request-id: 38be4c9665124450b66c5d9218c596d9 +{"status":"ok"} +$ docker compose exec api id; PID 1 +uid=10001(app) gid=10001(app) groups=10001(app) +PID 1: python -m messenger +$ docker compose run --rm migrate # second run: idempotent +migrate: 0001_init: already applied, skipped +migrate: done, 1 migration file(s) checked +$ git status --short # secrets/.env must not be tracked +secrets/database_url +.env diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..a031ecc5 --- /dev/null +++ b/evidence/explain-history.txt @@ -0,0 +1,63 @@ +$ python scripts/explain_history.py --output evidence/explain-history.txt + messages_total | messages_in_target_chat +----------------+------------------------- + 50146 | 20000 +(1 row) + +=== 1. first page, app query HISTORY_FIRST, generic plan + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=0.41..122.63 rows=119 width=55) (actual time=0.019..0.030 rows=51.00 loops=1) + Buffers: shared hit=4 + -> Index Scan using messages_chat_keyset on messages (cost=0.41..1226.64 rows=1194 width=55) (actual time=0.017..0.025 rows=51.00 loops=1) + Index Cond: (chat_id = $1) + Index Searches: 1 + Buffers: shared hit=4 + Planning: + Buffers: shared hit=10 + Planning Time: 0.157 ms + Execution Time: 0.067 ms +(10 rows) + +=== 2. late page (cursor at 19950), app query HISTORY_AFTER, generic plan + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..59.95 rows=40 width=55) (actual time=0.022..0.036 rows=50.00 loops=1) + Buffers: shared hit=5 + -> Index Scan using messages_chat_keyset on messages (cost=0.41..592.75 rows=398 width=55) (actual time=0.020..0.030 rows=50.00 loops=1) + Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) + Index Searches: 1 + Buffers: shared hit=5 + Planning Time: 0.163 ms + Execution Time: 0.112 ms +(8 rows) + +=== 3. REJECTED: one query with ($2 IS NULL OR ...), same late page, generic plan + QUERY PLAN +----------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..123.02 rows=40 width=55) (actual time=3.242..3.257 rows=50.00 loops=1) + Buffers: shared hit=526 + -> Index Scan using messages_chat_keyset on messages (cost=0.41..1232.61 rows=402 width=55) (actual time=3.239..3.251 rows=50.00 loops=1) + Index Cond: (chat_id = $1) + Filter: (($2 IS NULL) OR (ROW(created_at, id) > ROW($2, $3))) + Rows Removed by Filter: 19950 + Index Searches: 1 + Buffers: shared hit=526 + Planning Time: 0.125 ms + Execution Time: 3.282 ms +(10 rows) + +=== 4. REJECTED: OFFSET pagination, same late page + QUERY PLAN +--------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=122.63..244.84 rows=119 width=55) (actual time=4.404..4.418 rows=50.00 loops=1) + Buffers: shared hit=526 + -> Index Scan using messages_chat_keyset on messages (cost=0.41..1226.64 rows=1194 width=55) (actual time=0.015..3.790 rows=20000.00 loops=1) + Index Cond: (chat_id = $1) + Index Searches: 1 + Buffers: shared hit=526 + Planning Time: 0.091 ms + Execution Time: 4.438 ms +(8 rows) + + diff --git a/evidence/logs-check.txt b/evidence/logs-check.txt new file mode 100644 index 00000000..09870969 --- /dev/null +++ b/evidence/logs-check.txt @@ -0,0 +1,22 @@ +# api log checks after smoke + valkey pause + unicode/NUL + wrong password tests, 2026-10-12T17:15:19Z +lines in api log: 93 +message texts sent by tests ('Привет, мир', 'Сообщение Боба', 'до отказа', 'hello', 'чужое') found: 0 +test passwords ('Test-password', 'T3st-') found: 0 +Authorization values (Bearer/Basic + credential) found: 0 +postgres/valkey passwords found: 0 +event types: + 62 "event": "request" + 8 "event": "user_created" + 7 "event": "session_created" + 3 "event": "session_store_unavailable" + 3 "event": "login_failed" + 3 "event": "chat_created" + 1 "event": "starting" + 1 "event": "session_revoked" + 1 "event": "dependencies_configured" +sample lines: +{"ts": "2026-10-12T17:15:10.934Z", "level": "info", "logger": "messenger", "event": "login_failed", "request_id": "350860a9d9ef4ad4b7fd6a9be0964981"} +{"ts": "2026-10-12T17:15:10.963Z", "level": "info", "logger": "messenger", "event": "session_revoked", "request_id": "5e8711e330724ed2a09f734947793877"} +{"ts": "2026-10-12T17:15:13.849Z", "level": "warning", "logger": "messenger.sessions", "event": "session_store_unavailable", "error": "TimeoutError"} +{"ts": "2026-10-12T17:15:13.850Z", "level": "info", "logger": "messenger.access", "event": "request", "request_id": "14fd3d975da3447e855d860eec8b1832", "method": "GET", "path": "/api/v1/users/me", "status": 503, "duration_ms": 501.281} +{"ts": "2026-10-12T17:15:14.354Z", "level": "info", "logger": "messenger.access", "event": "request", "request_id": "e2ddf53f97a1403fbb635d94d52ea9ad", "method": "GET", "path": "/api/v1/chats/3d96c3ee-a9c8-46eb-b8fe-7f12ba8ec2f0/messages", "status": 503, "duration_ms": 503.088} diff --git a/evidence/make-check-validate.txt b/evidence/make-check-validate.txt new file mode 100644 index 00000000..4c0fea82 --- /dev/null +++ b/evidence/make-check-validate.txt @@ -0,0 +1,4 @@ +$ make check # python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +$ make validate # (venv with requirements-dev.txt) +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. diff --git a/evidence/make-test.txt b/evidence/make-test.txt new file mode 100644 index 00000000..c780a46d --- /dev/null +++ b/evidence/make-test.txt @@ -0,0 +1,2 @@ +$ make test BASE_URL=http://127.0.0.1:8081 +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/restart-hook-output.txt b/evidence/restart-hook-output.txt new file mode 100644 index 00000000..64c69c61 --- /dev/null +++ b/evidence/restart-hook-output.txt @@ -0,0 +1,20 @@ +$ sh scripts/restart.sh # what the hook does (run by hand to see its output) + Container mtusi-lab2-clean-api-1 Stopping + Container mtusi-lab2-clean-api-1 Stopped + Container mtusi-lab2-clean-postgres-1 Restarting + Container mtusi-lab2-clean-valkey-1 Restarting + Container mtusi-lab2-clean-valkey-1 Started + Container mtusi-lab2-clean-postgres-1 Started + Container mtusi-lab2-clean-postgres-1 Waiting + Container mtusi-lab2-clean-postgres-1 Healthy + Container mtusi-lab2-clean-migrate-1 Starting + Container mtusi-lab2-clean-migrate-1 Started + Container mtusi-lab2-clean-postgres-1 Waiting + Container mtusi-lab2-clean-valkey-1 Waiting + Container mtusi-lab2-clean-migrate-1 Waiting + Container mtusi-lab2-clean-valkey-1 Healthy + Container mtusi-lab2-clean-postgres-1 Healthy + Container mtusi-lab2-clean-migrate-1 Exited + Container mtusi-lab2-clean-api-1 Starting + Container mtusi-lab2-clean-api-1 Started +restart.sh: api, postgres and valkey restarted with volumes preserved diff --git a/evidence/sigterm.txt b/evidence/sigterm.txt new file mode 100644 index 00000000..a31bcba5 --- /dev/null +++ b/evidence/sigterm.txt @@ -0,0 +1,8 @@ +# SIGTERM (docker compose stop = SIGTERM, then SIGKILL after stop_grace_period 10s) +run 1: docker compose stop api -> 1195 ms, exit code 0, OOMKilled=false +run 2: docker compose stop api -> 1089 ms, exit code 0, OOMKilled=false +run 3: docker compose stop api -> 1098 ms, exit code 0, OOMKilled=false +last shutdown log lines: +{"ts": "2026-10-12T17:16:17.419Z", "level": "info", "logger": "messenger", "event": "shutdown_requested", "signal": 15, "timeout_s": 8.0} +{"ts": "2026-10-12T17:16:17.541Z", "level": "info", "logger": "uvicorn.error", "event": "Finished server process [1]"} +{"ts": "2026-10-12T17:16:17.542Z", "level": "info", "logger": "messenger", "event": "stopped"} diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..af8055a3 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,117 @@ +$ BASE_URL=http://127.0.0.1:8081 python -m pytest student-tests -v # stand from the clean clone +============================= test session starts ============================= +platform win32 -- Python 3.14.6, pytest-9.1.1, pluggy-1.6.0 -- /.venv/Scripts/python.exe +rootdir: +plugins: anyio-4.15.1 +collecting ... collected 108 items + +student-tests/test_api.py::test_register_never_returns_password_and_login_returns_bearer PASSED +student-tests/test_api.py::test_duplicate_username_is_409 PASSED +student-tests/test_api.py::test_bad_password_on_registration_is_400[short-11ch] PASSED +student-tests/test_api.py::test_bad_password_on_registration_is_400[ ] PASSED +student-tests/test_api.py::test_bad_password_on_registration_is_400[ \t \n \t \n \t \n ] PASSED +student-tests/test_api.py::test_bad_password_on_registration_is_400[\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f] PASSED +student-tests/test_api.py::test_edge_passwords_register_and_login[\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f] PASSED +student-tests/test_api.py::test_edge_passwords_register_and_login[with:colons:inside] PASSED +student-tests/test_api.py::test_edge_passwords_register_and_login[Twelve chars] PASSED +student-tests/test_api.py::test_wrong_password_and_unknown_user_give_the_same_401 PASSED +student-tests/test_api.py::test_malformed_basic_is_401_not_500[Basic \xe9] PASSED +student-tests/test_api.py::test_malformed_basic_is_401_not_500[Basic !!!] PASSED +student-tests/test_api.py::test_malformed_basic_is_401_not_500[Basic bm9fY29sb24=] PASSED +student-tests/test_api.py::test_malformed_basic_is_401_not_500[Basic //46eA==] PASSED +student-tests/test_api.py::test_malformed_basic_is_401_not_500[Bearer aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED +student-tests/test_api.py::test_malformed_basic_is_401_not_500[] PASSED +student-tests/test_api.py::test_logout_revokes_only_this_token PASSED +student-tests/test_api.py::test_x_user_id_basic_and_garbage_do_not_authenticate PASSED +student-tests/test_api.py::test_malformed_json_is_400[{] PASSED +student-tests/test_api.py::test_malformed_json_is_400[] PASSED +student-tests/test_api.py::test_malformed_json_is_400[[]] PASSED +student-tests/test_api.py::test_malformed_json_is_400[null] PASSED +student-tests/test_api.py::test_malformed_json_is_400[{"username": "abc_def", "display_name": NaN, "password": "Twelve-chars"}] PASSED +student-tests/test_api.py::test_malformed_json_is_400[{"username": "abc_def", "display_name": "x", "password": "Twelve-chars"}{"a": 1}] PASSED +student-tests/test_api.py::test_malformed_json_is_400[{"username": "abc_def", "display_name": "\ud800", "password": "Twelve-chars"}] PASSED +student-tests/test_api.py::test_invalid_registration_fields_are_400[body0] PASSED +student-tests/test_api.py::test_invalid_registration_fields_are_400[body1] PASSED +student-tests/test_api.py::test_invalid_registration_fields_are_400[body2] PASSED +student-tests/test_api.py::test_invalid_registration_fields_are_400[body3] PASSED +student-tests/test_api.py::test_invalid_registration_fields_are_400[body4] PASSED +student-tests/test_api.py::test_invalid_registration_fields_are_400[body5] PASSED +student-tests/test_api.py::test_unicode_limits_are_code_points_and_nul_is_stored PASSED +student-tests/test_api.py::test_oversized_body_and_wrong_content_type PASSED +student-tests/test_api.py::test_chat_validation PASSED +student-tests/test_api.py::test_foreign_chat_is_indistinguishable_from_missing PASSED +student-tests/test_api.py::test_chat_list_order_pagination_and_isolation PASSED +student-tests/test_api.py::test_history_pages_without_loss_or_duplicates PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[limit=0] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[limit=101] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[limit=abc] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[limit=1&limit=2] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[cursor=] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[cursor=garbage] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[cursor=djF8bXx4fDF8Mg] PASSED +student-tests/test_api.py::test_bad_limit_or_cursor_is_400[cursor=djF8bXx4fDk5OTk5OTk5OTk5OTk5OTk5OTk5fHk=] PASSED +student-tests/test_api.py::test_cursor_bound_to_chat PASSED +student-tests/test_api.py::test_read_after_write PASSED +student-tests/test_db.py::test_registration_race_exactly_one_201_and_seven_409 PASSED +student-tests/test_db.py::test_create_chat_rolls_back_after_the_chat_row_was_inserted PASSED +student-tests/test_db.py::test_migrations_rerun_is_a_noop PASSED +student-tests/test_db.py::test_100_messages_from_10_clients_keep_order_and_cursor_walk PASSED +student-tests/test_db.py::test_secrets_are_not_stored_in_plain_text PASSED +student-tests/test_explain.py::test_late_page_uses_index_range_not_filter PASSED +student-tests/test_failures.py::test_valkey_failure[stop] PASSED +student-tests/test_failures.py::test_valkey_failure[pause] PASSED +student-tests/test_failures.py::test_postgres_failure[stop] PASSED +student-tests/test_failures.py::test_postgres_failure[pause] PASSED +student-tests/test_failures.py::test_locked_table_gives_bounded_503 PASSED +student-tests/test_failures.py::test_logout_during_valkey_outage_is_never_lost PASSED +student-tests/test_sessions.py::test_short_ttl_expires[valkey] PASSED +student-tests/test_sessions.py::test_short_ttl_expires[postgres] PASSED +student-tests/test_sessions.py::test_restart_does_not_extend_ttl PASSED +student-tests/test_sessions.py::test_postgres_session_store PASSED +student-tests/unit/test_unit.py::test_valid_passwords[Twelve-chars] PASSED +student-tests/unit/test_unit.py::test_valid_passwords[\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f] PASSED +student-tests/unit/test_unit.py::test_valid_passwords[\u043f\u0430\u0440\u043e\u043b\u044c:\u0441:\u0434\u0432\u043e\u0435\u0442\u043e\u0447\u0438\u044f\u043c\u0438] PASSED +student-tests/unit/test_unit.py::test_valid_passwords[\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600\U0001f600] PASSED +student-tests/unit/test_unit.py::test_valid_passwords[a b c d e f g] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[short-11ch] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f\u044f] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[ ] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[\t\n\u3000\t\n\u3000\t\n\u3000\t\n\u3000\t\n\u3000] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[\ud800\ud800\ud800\ud800\ud800\ud800\ud800\ud800\ud800\ud800\ud800\ud800] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[None] PASSED +student-tests/unit/test_unit.py::test_invalid_passwords[123456789012] PASSED +student-tests/unit/test_unit.py::test_text_may_contain_nul_but_not_lone_surrogates PASSED +student-tests/unit/test_unit.py::test_cursor_roundtrip_and_binding PASSED +student-tests/unit/test_unit.py::test_broken_cursors_are_400_not_500[v1|m|3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11|253402300800000000|11111111-1111-4111-8111-111111111111] PASSED +student-tests/unit/test_unit.py::test_broken_cursors_are_400_not_500[v1|m|3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11|9999999999999999999|11111111-1111-4111-8111-111111111111] PASSED +student-tests/unit/test_unit.py::test_broken_cursors_are_400_not_500[v1|m|3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11|-1|11111111-1111-4111-8111-111111111111] PASSED +student-tests/unit/test_unit.py::test_broken_cursors_are_400_not_500[v1|m|3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11|1|not-a-uuid] PASSED +student-tests/unit/test_unit.py::test_broken_cursors_are_400_not_500[v1|m|3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11|1|11111111-1111-4111-8111-11111111111G] PASSED +student-tests/unit/test_unit.py::test_broken_cursors_are_400_not_500[v2|m|3f2c7a5e-0b7d-4a35-9a43-8d1f0f3b2c11|1|11111111-1111-4111-8111-111111111111] PASSED +student-tests/unit/test_unit.py::test_time_helpers_are_exact PASSED +student-tests/unit/test_unit.py::test_basic_is_parsed_and_password_may_contain_colons PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[None] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic \xe9] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic !!!!] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic bm8tY29sb24=] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic //46cHc=] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic OnBhc3N3b3Jk] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic YWxpY2U6] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic 0JDQu9C40YHQsDpwdw==] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Bearer aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED +student-tests/unit/test_unit.py::test_bad_basic_is_401_with_basic_challenge[Basic AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[None] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[Bearer] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[Bearer short] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[Bearer aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[Basic YWxpY2U6cGFzc3dvcmQtMTIz] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[Token aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa] PASSED +student-tests/unit/test_unit.py::test_bad_bearer_is_401_with_bearer_challenge[Bearer \xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9\xe9] PASSED +student-tests/unit/test_unit.py::test_bearer_ok PASSED +student-tests/unit/test_unit.py::test_argon2id_hash_and_verify PASSED +student-tests/unit/test_unit.py::test_settings_read_secret_files_and_contract_names PASSED + +======================= 108 passed in 208.53s (0:03:28) ======================= diff --git a/evidence/test-persistence-postgres.txt b/evidence/test-persistence-postgres.txt new file mode 100644 index 00000000..5574e13c --- /dev/null +++ b/evidence/test-persistence-postgres.txt @@ -0,0 +1,24 @@ +# Same persistence test with SESSION_STORE=postgres (sessions in table sessions) +$ SESSION_STORE=postgres docker compose up -d --wait api + Container mtusi-lab2-clean-api-1 Healthy + Container mtusi-lab2-clean-api-1 Recreated + Container mtusi-lab2-clean-postgres-1 Healthy + Container mtusi-lab2-clean-valkey-1 Healthy + api env SESSION_STORE=postgres +containers BEFORE: + api StartedAt=2026-10-12T17:10:11.785377847Z + postgres StartedAt=2026-10-12T17:09:31.655693328Z + valkey StartedAt=2026-10-12T17:09:31.612351204Z +$ python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +containers AFTER: + api StartedAt=2026-10-12T17:10:30.772464788Z + postgres StartedAt=2026-10-12T17:10:23.581636896Z + valkey StartedAt=2026-10-12T17:10:23.504892649Z + sessions rows in PostgreSQL: 3 +$ docker compose up -d --wait api # back to the default SESSION_STORE=valkey + Container mtusi-lab2-clean-api-1 Healthy + Container mtusi-lab2-clean-postgres-1 Healthy + Container mtusi-lab2-clean-valkey-1 Healthy + api env SESSION_STORE=valkey diff --git a/evidence/test-persistence-valkey.txt b/evidence/test-persistence-valkey.txt new file mode 100644 index 00000000..a65b1cab --- /dev/null +++ b/evidence/test-persistence-valkey.txt @@ -0,0 +1,14 @@ +# make test-persistence ACTION_SCRIPT=scripts/restart.sh (Windows: scripts/restart.cmd runs the same restart.sh via Git Bash) +containers BEFORE: + api StartedAt=2026-10-12T17:09:00.366421789Z + postgres StartedAt=2026-10-12T17:08:53.162313311Z + valkey StartedAt=2026-10-12T17:08:53.503522499Z +$ python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8081 +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +containers AFTER (all three restarted, volumes kept): + api StartedAt=2026-10-12T17:09:38.831312693Z + postgres StartedAt=2026-10-12T17:09:31.655693328Z + valkey StartedAt=2026-10-12T17:09:31.612351204Z +mtusi-lab2-clean_pgdata +mtusi-lab2-clean_valkeydata diff --git a/evidence/track2/index-sizes.csv b/evidence/track2/index-sizes.csv new file mode 100644 index 00000000..cf3a1c5a --- /dev/null +++ b/evidence/track2/index-sizes.csv @@ -0,0 +1,5 @@ +variant,rows,table_bytes,pkey_bytes,secondary_index_bytes,secondary_bytes_per_row,index_build_seconds +keyset_index,121120,35037184,4808704,7159808,59.1,0.3 +chat_id_index,121120,35037184,4808704,876544,7.2,0.3 +no_index,121120,35037184,4808704,0,0.0,0.0 +keyset_plus_sender,121120,35037184,4808704,10240000,84.5,0.59 diff --git a/evidence/track2/summary.md b/evidence/track2/summary.md index f46e8dc1..5e01b148 100644 --- a/evidence/track2/summary.md +++ b/evidence/track2/summary.md @@ -27,8 +27,10 @@ TPS и задержка — медиана 5 повторов по 10 с, 8 клиентов. WAL — медиана 3 детерминированных прогонов: 5 000 транзакций, 1 клиент, autovacuum выключен, CHECKPOINT перед прогоном. -| Индексы messages | TPS (min–max) | p50, мс | p95, мс | p99, мс | WAL, байт/вставку (min–max) | Размер индексов, МиБ | +| Индексы messages | TPS (min–max) | p50, мс | p95, мс | p99, мс | WAL, байт/вставку (min–max) | Доп. индексы на 121 120 строк, МиБ | | --- | ---: | ---: | ---: | ---: | ---: | ---: | -| no_index | 1 954 (1 540–2 055) | 3.55 | 7.14 | 12.2 | 1930 (1884–1940) | 4.6 | -| keyset_index | 1 577 (1 002–1 630) | 4.73 | 8.50 | 13.0 | 2910 (2800–2926) | 24.0 | -| keyset_plus_sender | 1 223 (896–1 607) | 6.25 | 9.30 | 13.9 | 3318 (3310–3414) | 46.6 | +| no_index | 1 954 (1 540–2 055) | 3.55 | 7.14 | 12.2 | 1930 (1884–1940) | 0.0 | +| keyset_index | 1 577 (1 002–1 630) | 4.73 | 8.50 | 13.0 | 2910 (2800–2926) | 6.8 | +| keyset_plus_sender | 1 223 (896–1 607) | 6.25 | 9.30 | 13.9 | 3318 (3310–3414) | 9.8 | + +Размеры индексов измерены отдельно на одинаковых 121 120 строках (bench/track2/index_sizes.py); первичный ключ во всех вариантах — 4.6 МиБ, таблица — 33.4 МиБ. -- 2.54.0 From f469b8efccf4cbafa8f6aa7be4a2fac50de322df Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Mon, 12 Oct 2026 20:20:22 +0300 Subject: [PATCH 6/7] =?UTF-8?q?ci:=20job=20=D0=BF=D1=80=D0=B8=D0=BB=D0=BE?= =?UTF-8?q?=D0=B6=D0=B5=D0=BD=D0=B8=D1=8F=20=E2=80=94=20=D1=81=D0=B1=D0=BE?= =?UTF-8?q?=D1=80=D0=BA=D0=B0,=20=D0=BC=D0=B8=D0=B3=D1=80=D0=B0=D1=86?= =?UTF-8?q?=D0=B8=D0=B8,=20smoke,=20persistence,=20=D1=81=D0=B2=D0=BE?= =?UTF-8?q?=D0=B8=20=D1=82=D0=B5=D1=81=D1=82=D1=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- .github/workflows/app.yml | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 .github/workflows/app.yml diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..a9ffaa18 --- /dev/null +++ b/.github/workflows/app.yml @@ -0,0 +1,32 @@ +name: Application (lab2) +on: [push, pull_request] +permissions: + contents: read +jobs: + app: + runs-on: ubuntu-latest + timeout-minutes: 30 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.13' + - name: Synthetic secrets and env (CI only, never committed) + run: python scripts/init_secrets.py && cp .env.example .env + - name: Build, migrate, start and wait for healthy services + run: docker compose --env-file .env up -d --build --wait + - name: Contract and public smoke + run: make check test PYTHON=python + - name: Persistence across restart of API and stores + run: make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python + - name: Own tests (unit + stand, failures restored in finally) + run: | + python -m pip install --require-hashes --no-deps -r requirements.txt + python -m pip install -r requirements-test.txt + make student-test PYTHON=python + - name: Logs + if: always() + run: docker compose logs --tail 100 + - name: Remove CI stand and its synthetic data + if: always() + run: docker compose down -v -- 2.54.0 From ef44e48464b615305e45c6084066a62e4a362c35 Mon Sep 17 00:00:00 2001 From: Alexey Bodanyuk <144894236+wfa22@users.noreply.github.com> Date: Tue, 13 Oct 2026 10:32:58 +0300 Subject: [PATCH 7/7] =?UTF-8?q?docs:=20=D0=B0=D0=B4=D1=80=D0=B5=D1=81=20?= =?UTF-8?q?=D1=84=D0=BE=D1=80=D0=BA=D0=B0=20=D0=B8=20=D0=B8=D0=BD=D1=81?= =?UTF-8?q?=D1=82=D1=80=D1=83=D0=BA=D1=86=D0=B8=D1=8F=20=D0=B4=D0=BB=D1=8F?= =?UTF-8?q?=20Windows?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 6 +-- docs/WINDOWS.md | 134 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 3 deletions(-) create mode 100644 docs/WINDOWS.md diff --git a/REPORT.md b/REPORT.md index d6f0b8df..152bba2f 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,17 +2,17 @@ - Автор, группа: Боданюк Алексей, БВТ2302 - Целевая оценка: **5**, трек 2 «План запроса и восстановление» -- Ветка: `solution/bvt2302-bodanyuk`. Форк: ``. PR: «ЛР 2 — БВТ2302 — Боданюк — на 5» в mtusi2026/mtusi2026lab2 +- Ветка: `solution/bvt2302-bodanyuk`. Форк: `https://gitea.privcloud.tech/wfa/mtusi2026lab2`. PR: «ЛР 2 — БВТ2302 — Боданюк — на 5» в mtusi2026/mtusi2026lab2 - Стек: Python 3.13.16, Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.3.6 + psycopg-pool 3.3.3, redis-py 8.1.0 (протокол Valkey), argon2-cffi 25.1.0; PostgreSQL 18.6, Valkey 8.1.3. Все образы закреплены по тегу и digest, все Python-пакеты — по хешам ([requirements.txt](requirements.txt)) - Источники: README, COURSE, контракт ([openapi.json](contracts/openapi.json), [семантика](contracts/README.md)), документация PostgreSQL (transactions, EXPLAIN, pg_dump/pg_restore, pgbench), Valkey persistence, RFC 7617, OWASP Password Storage Cheat Sheet (параметры Argon2id). Учтены замечания преподавателя к PR других студентов этого репозитория (см. раздел «Проверки, на которых ловили другие работы») -- Помощь ИИ: код, тесты, скрипты эксперимента и черновик отчёта написаны с помощью ИИ-ассистента Claude Code (Anthropic). Все команды и замеры реально выполнены на стенде ниже, их вывод лежит в [evidence/](evidence/). Пояснения для защиты — [docs/DEFENSE.md](docs/DEFENSE.md) +- Помощь ИИ: код, тесты, скрипты эксперимента и черновик отчёта написаны с помощью ИИ-ассистента Claude Code (Anthropic). Все команды и замеры реально выполнены на стенде ниже, их вывод лежит в [evidence/](evidence/). Пояснения для защиты — [docs/DEFENSE.md](docs/DEFENSE.md), запуск на Windows и сценарий защиты по шагам — [docs/WINDOWS.md](docs/WINDOWS.md) ## Запуск из чистого clone Нужны Git, Docker с Compose v2 (проверено: Docker 29.8.0, Compose 5.5.1) и Python 3.9+ (secrets, публичные тесты). Для своих тестов нужен venv. Учётные данные не хранятся в Git: их создаёт скрипт. ```sh -git clone mtusi2026lab2 && cd mtusi2026lab2 && git checkout solution/bvt2302-bodanyuk +git clone https://gitea.privcloud.tech/wfa/mtusi2026lab2 mtusi2026lab2 && cd mtusi2026lab2 && git checkout solution/bvt2302-bodanyuk python3 scripts/init_secrets.py # случайные локальные пароли -> ./secrets (git-ignored), идемпотентно cp .env.example .env # необязательно: значения по умолчанию заданы в compose.yaml docker compose --env-file .env config --quiet diff --git a/docs/WINDOWS.md b/docs/WINDOWS.md new file mode 100644 index 00000000..649152a4 --- /dev/null +++ b/docs/WINDOWS.md @@ -0,0 +1,134 @@ +# Запуск на ноутбуке с Windows и сценарий защиты + +Все команды — в **PowerShell**, из папки проекта. Внутри одного окна PowerShell переменные `$env:...` действуют до его закрытия. + +## 1. Что установить один раз + +| Программа | Зачем | Важно | +| --- | --- | --- | +| [Git for Windows](https://git-scm.com/download/win) | clone и Git Bash | ставить в путь по умолчанию `C:\Program Files\Git`: оттуда `scripts\restart.cmd` запускает `restart.sh` | +| [Docker Desktop](https://www.docker.com/products/docker-desktop/) | PostgreSQL, Valkey, API | backend WSL 2; в BIOS включена виртуализация; после установки перезагрузка | +| [Python 3.12+](https://www.python.org/downloads/windows/) | secrets, публичные тесты, свои тесты | галочка **Add python.exe to PATH**. Если `python` открывает Microsoft Store — отключить «Псевдонимы выполнения приложений» для python в настройках Windows | + +Проверка: + +```powershell +git --version; docker version --format '{{.Server.Version}}'; docker compose version; python --version +``` + +Docker Desktop должен быть **запущен** (кит в трее не мигает). + +## 2. Развернуть проект (дома, заранее — нужен интернет) + +```powershell +git clone https://gitea.privcloud.tech/wfa/mtusi2026lab2 mtusi2026lab2 +cd mtusi2026lab2 +git checkout solution/bvt2302-bodanyuk +python scripts\init_secrets.py +Copy-Item .env.example .env +docker compose --env-file .env up -d --build --wait +``` + +Первый запуск скачивает образы (~700 МБ) и собирает API — 3–10 минут. Сделайте это **дома**: в аудитории сеть может быть медленной. Последняя команда завершается, когда все сервисы `healthy`. + +Проверка в браузере: http://127.0.0.1:8080/health/ready → `{"status":"ok"}`, Swagger — http://127.0.0.1:8080/docs. + +Окружение для своих тестов (один раз): + +```powershell +python -m venv .venv +.venv\Scripts\python -m pip install --require-hashes --no-deps -r requirements.txt +.venv\Scripts\python -m pip install -r requirements-test.txt -r requirements-dev.txt +``` + +Активировать venv не нужно: везде вызывается `.venv\Scripts\python` напрямую, поэтому политика выполнения PowerShell не мешает. + +## 3. Перед защитой (в аудитории) + +```powershell +cd mtusi2026lab2 +docker compose up -d --wait # если стенд был остановлен +$env:PYTHONUTF8 = "1" # публичные тесты читают UTF-8 JSON +python tests\smoke.py # PASS: lab2 public API scenario +``` + +## 4. Сценарий защиты из README — команды по шагам + +**Шаг 1. Миграции к пустому volume, пользователи, вход, сообщение.** + +```powershell +docker compose down -v # стереть учебные данные (volumes) +docker compose up -d --wait # postgres и valkey пустые -> migrate применяет схему +docker compose logs migrate # "0001_init: applied" +docker compose run --rm migrate # повтор: "already applied, skipped" +``` + +Дальше в Swagger (http://127.0.0.1:8080/docs): +1. `POST /api/v1/users` — создать двух пользователей (пароль 12+ символов). +2. **Authorize → basicAuth**: логин и пароль первого; `POST /api/v1/auth/sessions` — скопировать `token`. +3. **Authorize → bearerAuth**: вставить токен. +4. `POST /api/v1/chats` (в `member_ids` — оба id) → `POST /api/v1/chats/{chat_id}/messages` → `GET` истории. + +**Шаги 2–3. Перезапуск API и хранилищ с сохранением volumes, тот же токен; logout → 401; короткий TTL.** + +```powershell +python tests\resilience.py --mode persistence --action-script scripts\restart.cmd # PASS +docker compose ps # у api, postgres, valkey свежее время запуска +``` + +В Swagger тот же токен по-прежнему работает. `DELETE /api/v1/auth/sessions/current` → 204, затем любой запрос → 401. + +Короткий TTL: + +```powershell +$env:SESSION_TTL_SECONDS = "2"; docker compose up -d --wait api +docker compose exec api printenv SESSION_TTL_SECONDS # 2 +# в Swagger: войти, сразу GET /users/me -> 200, через 3 секунды -> 401 +Remove-Item Env:SESSION_TTL_SECONDS; docker compose up -d --wait api # вернуть 3600 +``` + +**Шаг 4. Роль Valkey, план SQL, ошибка зависимости.** + +```powershell +# Сессии лежат только в Valkey: ключи session:, самих токенов там нет +# (без двойных кавычек внутри: PowerShell 5.1 ломает их при передаче в docker) +docker compose exec valkey sh -c 'REDISCLI_AUTH=$(cat /run/secrets/valkey_password) valkey-cli --scan --pattern ''session:*''' + +# План: поздняя страница по индексу (Index Cond) против IS NULL OR и OFFSET, 20 000 сообщений +.venv\Scripts\python scripts\explain_history.py + +# Ошибка зависимости: с действующим токеном -> 503, без токена -> 401, после старта всё работает +docker compose stop valkey # или: docker compose pause postgres +# в Swagger: GET /users/me -> 503 unavailable; GET /health/ready -> 503 +docker compose start valkey # или: docker compose unpause postgres +``` + +Всё то же автоматически, с восстановлением в `finally`, около 1 минуты: + +```powershell +.venv\Scripts\python -m pytest student-tests\test_failures.py -v +``` + +**Трек 2 вживую.** + +```powershell +.venv\Scripts\python bench\track2\backup_restore.py --repeats 1 # ~1 мин: dump во время записи -> restore в новый контейнер -> сверка +``` + +Скрипт печатает время дампа и восстановления, `reconciled: true` и сколько сообщений записано после снимка (RPO). Полный замер планов идёт ~25 минут, поэтому на защите показывайте готовые результаты: `evidence\track2\summary.md` и `evidence\track2\plans.png`. При желании можно запустить `.venv\Scripts\python bench\track2\index_sizes.py` (~2 мин). + +**Все свои тесты** (~3,5 мин): `.venv\Scripts\python -m pytest student-tests -v`. + +## 5. Если что-то пошло не так + +| Симптом | Что сделать | +| --- | --- | +| `error during connect … dockerDesktopLinuxEngine` | Docker Desktop не запущен — запустить и подождать минуту | +| `port is already allocated` на 8080 | в `.env` поставить `APP_PUBLISH_PORT=8081`; дальше тесты с `--base-url http://127.0.0.1:8081` (smoke и resilience), для pytest — `$env:BASE_URL="http://127.0.0.1:8081"` | +| `secrets/... not found` при `up` | не выполнен `python scripts\init_secrets.py` | +| `UnicodeDecodeError` в `tests\*.py` | не задан `$env:PYTHONUTF8 = "1"` | +| `restart.cmd`: «не удаётся найти путь» | Git установлен не в `C:\Program Files\Git` — поправить путь в `scripts\restart.cmd` | +| api `unhealthy` после сна ноутбука | `docker compose restart` и подождать `docker compose ps` | +| нужно начать с чистого листа | `docker compose down -v` (удаляет учебные данные) → `docker compose up -d --wait` | + +Остановить стенд после защиты: `docker compose down` (данные сохранятся) или `docker compose down -v` (данные удаляются). -- 2.54.0