From 9d3de3b2d9ae2308c4059eb3dcda04c4d1a86a3a Mon Sep 17 00:00:00 2001 From: Sunrise443 Date: Mon, 26 Oct 2026 16:42:32 +0300 Subject: [PATCH] level 3 basics --- .env.example | 11 +- Dockerfile | 1 + REPORT.md | 68 ++++++-- app/config.py | 20 +++ app/db.py | 37 ++++ app/errors.py | 4 + app/main.py | 17 +- app/migrate.py | 36 ++++ app/routes.py | 32 ++-- app/store.py | 363 ++++++++++++++++++++++++++++++---------- compose.yaml | 50 ++++++ evidence/grade3.txt | 39 +++++ migrations/001_init.sql | 53 ++++++ requirements.txt | 1 + scripts/check_grade3.py | 92 ++++++++++ scripts/restart.sh | 5 + 16 files changed, 703 insertions(+), 126 deletions(-) create mode 100644 app/db.py create mode 100644 app/migrate.py create mode 100644 compose.yaml create mode 100644 evidence/grade3.txt create mode 100644 migrations/001_init.sql create mode 100644 scripts/check_grade3.py create mode 100644 scripts/restart.sh diff --git a/.env.example b/.env.example index 714c8076..7a024f45 100644 --- a/.env.example +++ b/.env.example @@ -3,9 +3,16 @@ APP_HOST=0.0.0.0 APP_PORT=8080 APP_ENV=lab +LOG_LEVEL=info SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url +# Local synthetic database. Use a password without URL reserved characters. +# Compose injects DATABASE_URL into the API from these three values. +# The password below is a placeholder: change it in the untracked .env. +POSTGRES_USER=messenger +POSTGRES_PASSWORD=replace-with-a-local-password +POSTGRES_DB=messenger +# Optional. When set, the API reads the URL from this file instead of DATABASE_URL. +# DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url diff --git a/Dockerfile b/Dockerfile index ff2e6b08..e7d13f91 100644 --- a/Dockerfile +++ b/Dockerfile @@ -21,6 +21,7 @@ COPY requirements.txt . RUN python -m pip install --no-cache-dir --disable-pip-version-check --root-user-action=ignore -r requirements.txt COPY --chown=app:app app ./app +COPY --chown=app:app migrations ./migrations COPY --chown=app:app contracts/openapi.json ./contracts/openapi.json USER app diff --git a/REPORT.md b/REPORT.md index b3536740..cc15aa9e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,75 @@ # Отчёт — лабораторная 2 - Автор, группа: Тимаева М.П. БПИ2302 -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Целевая оценка; выбранный трек 5, если нужен: 3 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: контракт и README этой лабораторной; PostgreSQL transactions; RFC 7617; библиотеки fastapi, uvicorn, asyncpg 0.32.0, argon2-cffi 25.1.0. Реализацию переноса в PostgreSQL помог собрать агент Cursor. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker и Docker Compose v2. Образы закреплены: `python:3.14.8-slim-bookworm` (digest в Dockerfile) и `postgres:16.10-alpine`. + +```sh +cp .env.example .env +# В .env замените POSTGRES_PASSWORD на локальный пароль без символов @ : / # ? и пробелов. +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +``` + +API читает `DATABASE_URL`, который compose собирает из `POSTGRES_USER`, `POSTGRES_PASSWORD` и `POSTGRES_DB`. Если задан `DATABASE_URL_FILE`, он важнее и файл не логируется. Миграции из `migrations/` применяются при старте API и записываются в `schema_migrations`; повторный старт их не исполняет заново. Пароль БД лежит только в неотслеживаемом `.env`. + +Дождитесь `GET http://127.0.0.1:8080/health/ready` → `200 {"status":"ok"}`. Для smoke и persistence `SESSION_TTL_SECONDS` не меньше 300; в `.env.example` стоит 3600. + +```sh +make check +make test +chmod +x scripts/restart.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +На Windows `python` не может запустить `scripts/restart.sh` через CreateProcess (`WinError 193`). Сам hook — POSIX shell и рассчитан на Linux, WSL или Git Bash с POSIX Python. На этой машине публичный harness был выполнен в контейнере `docker:28-cli` с `python3`, в сети compose и с Docker socket; вызывался тот же `scripts/restart.sh`. Подробности в `evidence/grade3.txt`. + +Остановка без удаления данных: `docker compose --env-file .env stop`. Намеренное удаление учебного volume: `docker compose --env-file .env down -v`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент ходит в один процесс API. Источник истины — PostgreSQL, named volume `pgdata`. Redis/Valkey нет: действующие сессии лежат в таблице `sessions`. + +Таблицы `migrations/001_init.sql`: `users` (UNIQUE username, FK нет наружу), `sessions` (PK — SHA-256 токена, FK на пользователя, `expires_at`), `chats`, `chat_members` (PK пары, оба FK, `position`), `messages` (FK на чат и отправителя), `schema_migrations`. Индекс `messages_history_idx (chat_id, created_at, id)` обслуживает keyset. Парольный hash в ответы не выбирается. Клиенту отдаётся сырой opaque-токен (`secrets.token_urlsafe(32)`), в БД хранится только хеш. + +Создание чата — одна транзакция: все `member_ids` должны существовать, иначе rollback и 400, затем вставка чата и участников. Занятый username — unique violation → 409 без текста SQL. `created_at` назначает процесс и делает его строго возрастающим, чтобы порядок `(created_at, id)` совпадал с порядком записи. Рестарт не меняет `expires_at`. + +`GET /health/live` проверяет только процесс. `GET /health/ready` делает `SELECT 1`; без БД ответ 503 `unavailable`. Basic принимается только на `POST /api/v1/auth/sessions`. Остальные маршруты требуют Bearer. `X-User-Id` не идентифицирует пользователя. Пароли — Argon2id. + +Переменные: `APP_HOST`, `APP_PORT`, `APP_ENV`, `LOG_LEVEL`, `SHUTDOWN_TIMEOUT_SECONDS`, `SESSION_TTL_SECONDS` читаются как в `.env.example`. `DATABASE_URL` задаёт compose; `DATABASE_URL_FILE` — необязательная замена. `SESSION_STORE=postgres` описывает это решение; кэш на оценке 3 не используется. + +Из lab1 сохранены пользователи, чаты, членство, сообщения и keyset-пагинация. Идентификация lab1 (`X-User-Id`) заменена на пароль, Basic и Bearer. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --------------------------------- | ---------------- | --------------------- | ------------------- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| --- | --- | --- | --- | +| Публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8080` на образе из Dockerfile | PASS: lab2 public API scenario | evidence/grade3.txt | +| Данные и сессия переживают рестарт API и PostgreSQL | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS. ID контейнеров не сменились (`15bfccf88c7a`, `cbe7139645a5`), volume `mtusi2026lab2-fork_pgdata` на месте | evidence/grade3.txt | +| Повтор миграций не дублирует данные | второй `docker compose restart api`, затем counts | `schema_migrations` = 1, users = 14, messages = 6 и до, и после | evidence/grade3.txt | +| Атомарное создание чата | `python scripts/check_grade3.py` | 400 на неизвестного участника, в `chats` строки с этим title нет | evidence/grade3.txt | +| Expiry сессии | отдельный прогон с `SESSION_TTL_SECONDS=2`, затем возврат к 3600 | тот же токен через 3 с получил 401 | evidence/grade3.txt | +| Недоступная БД | `docker compose stop postgres`, затем start | `/health/live` 200, `/health/ready` 503 `unavailable` без SQL | evidence/grade3.txt | +| Секреты вне Git | `git check-ignore -v .env` | `.gitignore:2:.env` | — | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +`make check` эквивалентен `python scripts/check_contract.py` и тоже PASS. Контракт и публичные тесты не менялись. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Отдельного нагрузочного эксперимента для оценки 3 нет. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| ----------- | ----------- | ------------- | ------------------------------------ | -| TODO | TODO | TODO | TODO | +| --- | --- | --- | --- | +| `scripts/restart.sh` перезапускает api и postgres | Тот же Bearer читает прежнее сообщение, volume сохранён | PASS persistence; ID контейнеров те же, volume на месте | Готовность уложилась в бюджет теста (90 с). Подтверждённые строки не пропали | +| Остановлен только postgres | live 200, ready 503, без SQL в теле | Так и было | После `start` ready снова 200. Данные volume не удалялись | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Один процесс API и одна БД. Потеря Docker-хоста уничтожает и API, и PostgreSQL. Сессии не в Redis: оценка 4 потребует Redis или Valkey, пул уже ограничен (`max_size` 10, таймаут 5 с), но гонка username, EXPLAIN на ≥10 000 сообщений и автоматические тесты короткого TTL не делались. Идемпотентность и вторая реплика — лабораторная 3 курса, не эта оценка. + +Учебное упрощение: время сообщения монотонно только внутри одного процесса. На оценке 3 процесс один, поэтому порядок записи и `(created_at, id)` совпадают. diff --git a/app/config.py b/app/config.py index 09c792c2..cf46bedc 100644 --- a/app/config.py +++ b/app/config.py @@ -1,5 +1,6 @@ import os from dataclasses import dataclass +from pathlib import Path @dataclass(frozen=True) @@ -10,6 +11,24 @@ class Settings: log_level: str shutdown_timeout: int session_ttl_seconds: int + database_url: str + + +def _database_url() -> str: + """DATABASE_URL_FILE wins. The value is not logged.""" + file_name = os.getenv('DATABASE_URL_FILE', '').strip() + if file_name: + try: + value = Path(file_name).read_text(encoding='utf-8').strip() + except OSError: + raise RuntimeError('DATABASE_URL_FILE could not be read') from None + if not value: + raise RuntimeError('DATABASE_URL_FILE is empty') + return value + value = os.getenv('DATABASE_URL', '').strip() + if not value: + raise RuntimeError('DATABASE_URL or DATABASE_URL_FILE is required') + return value def load_settings() -> Settings: @@ -20,4 +39,5 @@ def load_settings() -> Settings: log_level=os.getenv('LOG_LEVEL', 'info').lower(), shutdown_timeout=int(os.getenv('SHUTDOWN_TIMEOUT_SECONDS', '5')), session_ttl_seconds=int(os.getenv('SESSION_TTL_SECONDS', '3600')), + database_url=_database_url(), ) diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..a6f03914 --- /dev/null +++ b/app/db.py @@ -0,0 +1,37 @@ +"""Connection pool. The URL is never written to the log.""" +import asyncio +import logging + +import asyncpg + +logger = logging.getLogger('messenger') + +_ATTEMPTS = 40 + + +async def open_pool(database_url: str) -> asyncpg.Pool: + delay = 0.5 + last_type = 'error' + for attempt in range(1, _ATTEMPTS + 1): + pool = None + try: + pool = await asyncpg.create_pool( + database_url, + min_size=1, + max_size=10, + timeout=5, + command_timeout=5, + ) + async with pool.acquire() as conn: + await conn.execute('SELECT 1') + return pool + except Exception as exc: + last_type = type(exc).__name__ + if pool is not None: + await pool.close() + if attempt == _ATTEMPTS: + break + logger.warning('database is not ready (%s), retrying', last_type) + await asyncio.sleep(delay) + delay = min(delay * 1.5, 2) + raise RuntimeError('database did not become reachable (%s)' % last_type) diff --git a/app/errors.py b/app/errors.py index b7dfe42c..2e7017db 100644 --- a/app/errors.py +++ b/app/errors.py @@ -23,3 +23,7 @@ def not_found(message: str) -> ApiError: def conflict(message: str) -> ApiError: return ApiError(409, 'conflict', message) + + +def unavailable(message: str) -> ApiError: + return ApiError(503, 'unavailable', message) diff --git a/app/main.py b/app/main.py index ac88da6e..097b7990 100644 --- a/app/main.py +++ b/app/main.py @@ -2,6 +2,7 @@ import json import logging import re import uuid +from contextlib import asynccontextmanager from pathlib import Path from fastapi import FastAPI, Request @@ -10,7 +11,9 @@ from fastapi.responses import JSONResponse from starlette.exceptions import HTTPException as StarletteHTTPException from .config import load_settings +from .db import open_pool from .errors import ApiError +from .migrate import apply_migrations from .routes import router from .store import Store @@ -51,10 +54,23 @@ def _request_id(request: Request) -> str: _OPENAPI_PATH = Path(__file__).resolve().parents[1] / 'contracts' / 'openapi.json' +@asynccontextmanager +async def lifespan(app: FastAPI): + settings = load_settings() + pool = await open_pool(settings.database_url) + try: + await apply_migrations(pool) + app.state.store = Store(pool, settings.session_ttl_seconds) + yield + finally: + await pool.close() + + def create_app() -> FastAPI: app = FastAPI( title='MTUSI Messenger lab2', version='1.2.0', + lifespan=lifespan, ) def openapi(): @@ -63,7 +79,6 @@ def create_app() -> FastAPI: return app.openapi_schema app.openapi = openapi - app.state.store = Store(load_settings().session_ttl_seconds) @app.middleware('http') async def request_context(request: Request, call_next): diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..de331051 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,36 @@ +"""Apply numbered SQL files once. Re-running records nothing new and inserts no rows.""" +import logging +from pathlib import Path + +import asyncpg + +logger = logging.getLogger('messenger') + +_MIGRATIONS = Path(__file__).resolve().parents[1] / 'migrations' + +_BOOTSTRAP = """ +CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp() +) +""" + + +async def apply_migrations(pool: asyncpg.Pool) -> None: + async with pool.acquire() as conn: + await conn.execute(_BOOTSTRAP) + rows = await conn.fetch('SELECT version FROM schema_migrations') + applied = {row['version'] for row in rows} + for path in sorted(_MIGRATIONS.glob('*.sql')): + version = path.name + if version in applied: + logger.info('migration %s already applied', version) + continue + sql = path.read_text(encoding='utf-8') + async with conn.transaction(): + await conn.execute(sql) + await conn.execute( + 'INSERT INTO schema_migrations (version) VALUES ($1)', + version, + ) + logger.info('applied migration %s', version) diff --git a/app/routes.py b/app/routes.py index ae8b9ef3..7aef9f59 100644 --- a/app/routes.py +++ b/app/routes.py @@ -26,7 +26,7 @@ async def current_user(request: Request) -> User: token = parse_bearer(request.headers.get('Authorization', '')) if token is None: raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE) - user = request.app.state.store.user_for_token(token) + user = await request.app.state.store.user_for_token(token) if user is None: raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE) return user @@ -45,12 +45,12 @@ async def read_body(request: Request, model: Type[Body]) -> Body: raise invalid_request('Тело запроса не соответствует контракту') from None -def _member_chat(store: Store, chat_id: str, actor: User) -> Chat: +async def _member_chat(store: Store, chat_id: str, actor: User) -> Chat: try: canonical = str(uuid.UUID(chat_id)) except ValueError: raise invalid_request('Некорректный chat_id') from None - chat = store.find_chat(canonical, actor.id) + chat = await store.find_chat(canonical, actor.id) if chat is None: raise not_found('Чат не найден') return chat @@ -69,15 +69,15 @@ async def liveness() -> JSONResponse: @router.get('/health/ready') -async def readiness() -> JSONResponse: - """In-memory only: the process itself is the single dependency of the sync path.""" +async def readiness(store: Store = Depends(get_store)) -> JSONResponse: + await store.ready() return JSONResponse({'status': 'ok'}) @router.post('/api/v1/users') async def register_user(request: Request, store: Store = Depends(get_store)) -> JSONResponse: payload = await read_body(request, CreateUser) - user = store.create_user(payload.username, payload.display_name, payload.password) + user = await store.create_user(payload.username, payload.display_name, payload.password) return JSONResponse(user.to_dict(), status_code=201) @@ -86,10 +86,10 @@ async def create_session(request: Request, store: Store = Depends(get_store)) -> parsed = parse_basic(request.headers.get('Authorization', '')) if parsed is None: raise unauthorized('Неверные учётные данные', BASIC_CHALLENGE) - user = store.authenticate(*parsed) + user = await store.authenticate(*parsed) if user is None: raise unauthorized('Неверные учётные данные', BASIC_CHALLENGE) - token, expires_at = store.create_session(user.id) + token, expires_at = await store.create_session(user.id) body = { 'token': token, 'token_type': 'Bearer', @@ -102,7 +102,7 @@ async def create_session(request: Request, store: Store = Depends(get_store)) -> @router.delete('/api/v1/auth/sessions/current') async def revoke_session(request: Request, actor: User = Depends(current_user)) -> Response: token = parse_bearer(request.headers.get('Authorization', '')) - if token is None or not request.app.state.store.revoke_session(token): + if token is None or not await request.app.state.store.revoke_session(token): raise unauthorized('Требуется действительная сессия', BEARER_CHALLENGE) return Response(status_code=204) @@ -121,7 +121,7 @@ async def create_chat( payload = await read_body(request, CreateChat) if actor.id not in payload.member_ids: raise invalid_request('Создатель чата должен быть указан в member_ids') - chat = store.create_chat(payload.title, payload.member_ids) + chat = await store.create_chat(payload.title, payload.member_ids) return JSONResponse(chat.to_dict(), status_code=201) @@ -133,7 +133,7 @@ async def list_chats( ) -> JSONResponse: scope = 'chats:' + actor.id limit, after = parse_page(request.query_params, scope) - chats, has_more = store.list_chats(actor.id, limit, after) + chats, has_more = await store.list_chats(actor.id, limit, after) return JSONResponse(_page(chats, has_more, scope)) @@ -143,7 +143,7 @@ async def show_chat( actor: User = Depends(current_user), store: Store = Depends(get_store), ) -> JSONResponse: - return JSONResponse(_member_chat(store, chat_id, actor).to_dict()) + return JSONResponse((await _member_chat(store, chat_id, actor)).to_dict()) @router.post('/api/v1/chats/{chat_id}/messages') @@ -153,9 +153,9 @@ async def send_message( actor: User = Depends(current_user), store: Store = Depends(get_store), ) -> JSONResponse: - chat = _member_chat(store, chat_id, actor) + chat = await _member_chat(store, chat_id, actor) payload = await read_body(request, CreateMessage) - message = store.add_message(chat.id, actor.id, payload.text) + message = await store.add_message(chat.id, actor.id, payload.text) return JSONResponse(message.to_dict(), status_code=201) @@ -166,8 +166,8 @@ async def list_messages( actor: User = Depends(current_user), store: Store = Depends(get_store), ) -> JSONResponse: - chat = _member_chat(store, chat_id, actor) + chat = await _member_chat(store, chat_id, actor) scope = 'messages:' + chat.id limit, after = parse_page(request.query_params, scope) - messages, has_more = store.list_messages(chat.id, limit, after) + messages, has_more = await store.list_messages(chat.id, limit, after) return JSONResponse(_page(messages, has_more, scope)) diff --git a/app/store.py b/app/store.py index dc878bd2..2ef1de83 100644 --- a/app/store.py +++ b/app/store.py @@ -2,12 +2,13 @@ import hashlib import secrets import threading import uuid -from bisect import bisect_right from dataclasses import dataclass from datetime import datetime, timedelta, timezone from typing import Dict, List, Optional, Sequence, Tuple -from .errors import conflict, invalid_request +import asyncpg + +from .errors import conflict, invalid_request, unavailable from .pagination import Key from .passwords import hash_password, password_matches @@ -62,23 +63,6 @@ class Message: } -class _Timeline: - """Append-only sequence ordered by (created_at, id), paginated with bisect.""" - - def __init__(self) -> None: - self._keys: List[Key] = [] - self._items: List = [] - - def append(self, item) -> None: - self._keys.append((item.created_at, item.id)) - self._items.append(item) - - def page(self, limit: int, after: Optional[Key]) -> Tuple[List, bool]: - start = bisect_right(self._keys, after) if after is not None else 0 - items = self._items[start:start + limit] - return items, start + len(items) < len(self._items) - - def _token_key(token: str) -> str: return hashlib.sha256(token.encode('utf-8')).hexdigest() @@ -87,102 +71,297 @@ def _stamp(moment: datetime) -> str: return moment.astimezone(timezone.utc).isoformat(timespec='microseconds').replace('+00:00', 'Z') -class Store: - """Single owner of mutable state; one lock keeps concurrent requests consistent.""" +def _parse_stamp(value: str) -> datetime: + if value.endswith('Z'): + value = value[:-1] + '+00:00' + return datetime.fromisoformat(value) - def __init__(self, session_ttl_seconds: int = 3600) -> None: + +def _user(row: asyncpg.Record) -> User: + return User(str(row['id']), row['username'], row['display_name'], _stamp(row['created_at'])) + + +def _as_uuid(value: str, message: str) -> uuid.UUID: + try: + return uuid.UUID(value) + except ValueError: + raise invalid_request(message) from None + + +class Store: + """PostgreSQL is the source of truth. One process clock keeps created_at ordered.""" + + def __init__(self, pool: asyncpg.Pool, session_ttl_seconds: int = 3600) -> None: + self._pool = pool self._session_ttl = timedelta(seconds=session_ttl_seconds) self._lock = threading.Lock() - self._users: Dict[str, User] = {} - self._user_id_by_username: Dict[str, str] = {} - self._password_hashes: Dict[str, str] = {} - self._sessions: Dict[str, Tuple[str, datetime]] = {} - self._chats: Dict[str, Chat] = {} - self._chats_of_user: Dict[str, _Timeline] = {} - self._messages_of_chat: Dict[str, _Timeline] = {} self._last_moment: Optional[datetime] = None - def _now(self) -> str: + def _now(self) -> datetime: """Strictly increasing server time, so append order always equals sort order.""" - moment = datetime.now(timezone.utc) - if self._last_moment is not None and moment <= self._last_moment: - moment = self._last_moment + timedelta(microseconds=1) - self._last_moment = moment - return _stamp(moment) + with self._lock: + moment = datetime.now(timezone.utc) + if self._last_moment is not None and moment <= self._last_moment: + moment = self._last_moment + timedelta(microseconds=1) + self._last_moment = moment + return moment - def create_user(self, username: str, display_name: str, password: str) -> User: + async def ready(self) -> None: + try: + async with self._pool.acquire() as conn: + await conn.execute('SELECT 1') + except Exception: + raise unavailable('Хранилище недоступно') from None + + async def create_user(self, username: str, display_name: str, password: str) -> User: password_hash = hash_password(password) - with self._lock: - if username in self._user_id_by_username: - raise conflict('Username уже занят') - user = User(str(uuid.uuid4()), username, display_name, self._now()) - self._users[user.id] = user - self._user_id_by_username[username] = user.id - self._password_hashes[user.id] = password_hash - return user + user_id = uuid.uuid4() + created = self._now() + try: + async with self._pool.acquire() as conn: + await conn.execute( + ''' + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES ($1, $2, $3, $4, $5) + ''', + user_id, + username, + display_name, + password_hash, + created, + ) + except asyncpg.UniqueViolationError: + raise conflict('Username уже занят') from None + return User(str(user_id), username, display_name, _stamp(created)) - def authenticate(self, username: str, password: str) -> Optional[User]: - with self._lock: - user_id = self._user_id_by_username.get(username) - user = self._users.get(user_id) if user_id is not None else None - stored_hash = self._password_hashes.get(user_id) if user_id is not None else None - if not password_matches(stored_hash, password): + async def authenticate(self, username: str, password: str) -> Optional[User]: + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = $1 + ''', + username, + ) + stored_hash = row['password_hash'] if row is not None else None + if not password_matches(stored_hash, password) or row is None: return None - return user + return _user(row) - def create_session(self, user_id: str) -> Tuple[str, str]: + async def create_session(self, user_id: str) -> Tuple[str, str]: token = secrets.token_urlsafe(32) expires = datetime.now(timezone.utc) + self._session_ttl - with self._lock: - self._sessions[_token_key(token)] = (user_id, expires) + async with self._pool.acquire() as conn: + await conn.execute( + ''' + INSERT INTO sessions (token_hash, user_id, expires_at) + VALUES ($1, $2, $3) + ''', + _token_key(token), + _as_uuid(user_id, 'Некорректный user_id'), + expires, + ) return token, _stamp(expires) - def user_for_token(self, token: str) -> Optional[User]: + async def user_for_token(self, token: str) -> Optional[User]: now = datetime.now(timezone.utc) - with self._lock: - record = self._sessions.get(_token_key(token)) - if record is None: + key = _token_key(token) + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at + FROM sessions s + JOIN users u ON u.id = s.user_id + WHERE s.token_hash = $1 + ''', + key, + ) + if row is None: return None - user_id, expires = record - if expires <= now: - del self._sessions[_token_key(token)] + if row['expires_at'] <= now: + await conn.execute('DELETE FROM sessions WHERE token_hash = $1', key) return None - return self._users.get(user_id) + return _user(row) - def revoke_session(self, token: str) -> bool: + async def revoke_session(self, token: str) -> bool: now = datetime.now(timezone.utc) - with self._lock: - record = self._sessions.pop(_token_key(token), None) - return record is not None and record[1] > now + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + DELETE FROM sessions + WHERE token_hash = $1 AND expires_at > $2 + RETURNING token_hash + ''', + _token_key(token), + now, + ) + return row is not None - def create_chat(self, title: str, member_ids: Sequence[str]) -> Chat: - with self._lock: - if any(member_id not in self._users for member_id in member_ids): - raise invalid_request('Все участники должны быть существующими пользователями') - chat = Chat(str(uuid.uuid4()), title, tuple(member_ids), self._now()) - self._chats[chat.id] = chat - for member_id in member_ids: - self._chats_of_user.setdefault(member_id, _Timeline()).append(chat) - return chat + async def create_chat(self, title: str, member_ids: Sequence[str]) -> Chat: + ids = [_as_uuid(member_id, 'Некорректный user_id') for member_id in member_ids] + chat_id = uuid.uuid4() + created = self._now() + async with self._pool.acquire() as conn: + async with conn.transaction(): + found = await conn.fetch( + 'SELECT id FROM users WHERE id = ANY($1::uuid[])', + ids, + ) + if len(found) != len(ids): + raise invalid_request('Все участники должны быть существующими пользователями') + await conn.execute( + 'INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)', + chat_id, + title, + created, + ) + await conn.execute( + ''' + INSERT INTO chat_members (chat_id, user_id, position) + SELECT $1, member_id, (ordinality - 1)::integer + FROM unnest($2::uuid[]) WITH ORDINALITY AS members(member_id, ordinality) + ''', + chat_id, + ids, + ) + return Chat(str(chat_id), title, tuple(member_ids), _stamp(created)) - def find_chat(self, chat_id: str, member_id: str) -> Optional[Chat]: + async def find_chat(self, chat_id: str, member_id: str) -> Optional[Chat]: """A chat of somebody else is indistinguishable from a missing one.""" - with self._lock: - chat = self._chats.get(chat_id) - return chat if chat is not None and member_id in chat.member_ids else None + chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id') + member_uuid = _as_uuid(member_id, 'Некорректный user_id') + async with self._pool.acquire() as conn: + row = await conn.fetchrow( + ''' + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $2 + WHERE c.id = $1 + ''', + chat_uuid, + member_uuid, + ) + if row is None: + return None + members = await self._members(conn, [chat_uuid]) + return Chat(str(row['id']), row['title'], members.get(chat_uuid, ()), _stamp(row['created_at'])) - def list_chats(self, member_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Chat], bool]: - with self._lock: - timeline = self._chats_of_user.get(member_id) - return timeline.page(limit, after) if timeline is not None else ([], False) + async def list_chats(self, member_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Chat], bool]: + member_uuid = _as_uuid(member_id, 'Некорректный user_id') + after_at, after_id = self._cursor(after) + async with self._pool.acquire() as conn: + if after_at is None: + rows = await conn.fetch( + ''' + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1 + ORDER BY c.created_at, c.id + LIMIT $2 + ''', + member_uuid, + limit + 1, + ) + else: + rows = await conn.fetch( + ''' + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members mine ON mine.chat_id = c.id AND mine.user_id = $1 + WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) + ORDER BY c.created_at, c.id + LIMIT $4 + ''', + member_uuid, + after_at, + after_id, + limit + 1, + ) + page = rows[:limit] + members = await self._members(conn, [row['id'] for row in page]) + chats = [ + Chat(str(row['id']), row['title'], members.get(row['id'], ()), _stamp(row['created_at'])) + for row in page + ] + return chats, len(rows) > limit - def add_message(self, chat_id: str, sender_id: str, text: str) -> Message: - with self._lock: - message = Message(str(uuid.uuid4()), chat_id, sender_id, text, self._now()) - self._messages_of_chat.setdefault(chat_id, _Timeline()).append(message) - return message + async def add_message(self, chat_id: str, sender_id: str, text: str) -> Message: + message_id = uuid.uuid4() + created = self._now() + async with self._pool.acquire() as conn: + await conn.execute( + ''' + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES ($1, $2, $3, $4, $5) + ''', + message_id, + _as_uuid(chat_id, 'Некорректный chat_id'), + _as_uuid(sender_id, 'Некорректный user_id'), + text, + created, + ) + return Message(str(message_id), chat_id, sender_id, text, _stamp(created)) - def list_messages(self, chat_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Message], bool]: - with self._lock: - timeline = self._messages_of_chat.get(chat_id) - return timeline.page(limit, after) if timeline is not None else ([], False) + async def list_messages(self, chat_id: str, limit: int, after: Optional[Key]) -> Tuple[List[Message], bool]: + chat_uuid = _as_uuid(chat_id, 'Некорректный chat_id') + after_at, after_id = self._cursor(after) + async with self._pool.acquire() as conn: + if after_at is None: + rows = await conn.fetch( + ''' + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + ORDER BY created_at, id + LIMIT $2 + ''', + chat_uuid, + limit + 1, + ) + else: + rows = await conn.fetch( + ''' + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND (created_at, id) > ($2::timestamptz, $3::uuid) + ORDER BY created_at, id + LIMIT $4 + ''', + chat_uuid, + after_at, + after_id, + limit + 1, + ) + page = rows[:limit] + messages = [ + Message(str(row['id']), str(row['chat_id']), str(row['sender_id']), row['text'], _stamp(row['created_at'])) + for row in page + ] + return messages, len(rows) > limit + + async def _members(self, conn: asyncpg.Connection, chat_ids: Sequence[uuid.UUID]) -> Dict[uuid.UUID, Tuple[str, ...]]: + if not chat_ids: + return {} + rows = await conn.fetch( + ''' + SELECT chat_id, user_id + FROM chat_members + WHERE chat_id = ANY($1::uuid[]) + ORDER BY chat_id, position + ''', + list(chat_ids), + ) + grouped: Dict[uuid.UUID, List[str]] = {} + for row in rows: + grouped.setdefault(row['chat_id'], []).append(str(row['user_id'])) + return {chat_id: tuple(member_ids) for chat_id, member_ids in grouped.items()} + + def _cursor(self, after: Optional[Key]) -> Tuple[Optional[datetime], Optional[uuid.UUID]]: + if after is None: + return None, None + try: + return _parse_stamp(after[0]), uuid.UUID(after[1]) + except ValueError: + raise invalid_request('Некорректный cursor') from None diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..c54afbb5 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,50 @@ +# Local lab2 grade-3 stand. Secrets come from .env, which is not committed. +services: + postgres: + image: postgres:16.10-alpine + environment: + POSTGRES_USER: ${POSTGRES_USER} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD} + POSTGRES_DB: ${POSTGRES_DB} + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"] + interval: 2s + timeout: 5s + retries: 30 + ports: + - "127.0.0.1:5432:5432" + restart: unless-stopped + + api: + build: + context: . + dockerfile: Dockerfile + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + LOG_LEVEL: ${LOG_LEVEL:-info} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SHUTDOWN_TIMEOUT_SECONDS: ${SHUTDOWN_TIMEOUT_SECONDS:-5} + DATABASE_URL: postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB} + ports: + - "127.0.0.1:8080:8080" + depends_on: + postgres: + condition: service_healthy + healthcheck: + test: + - CMD + - python + - -c + - import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3) + interval: 3s + timeout: 5s + retries: 30 + start_period: 20s + restart: unless-stopped + +volumes: + pgdata: diff --git a/evidence/grade3.txt b/evidence/grade3.txt new file mode 100644 index 00000000..df68f919 --- /dev/null +++ b/evidence/grade3.txt @@ -0,0 +1,39 @@ +Grade 3 checks. No tokens, passwords, or connection strings. + +make check equivalent: + .venv/Scripts/python.exe scripts/check_contract.py + PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. + +Pinned image smoke, http://127.0.0.1:8080: + .venv/Scripts/python.exe tests/smoke.py --base-url http://127.0.0.1:8080 + PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. + +Persistence on the same image. The public harness executes scripts/restart.sh. +On this Windows host CreateProcess cannot run a shell script (WinError 193), and the +only WSL distro is docker-desktop. The harness was therefore run inside docker:28-cli +with python3, the compose network, and the Docker socket. The hook was still +scripts/restart.sh. BASE_URL was http://api:8080. + PASS: persistence preserved confirmed data and existing session. + +Containers before and after that hook kept the same IDs (restart, not recreate): + api 15bfccf88c7a + postgres cbe7139645a5 +Volume still present: mtusi2026lab2-fork_pgdata + +Second API start, same volume, migrations not re-inserted: + before: migrations=1 users=14 messages=6 + after: migrations=1 users=14 messages=6 + +Unknown member: + .venv/Scripts/python.exe scripts/check_grade3.py + PASS: unknown member returns 400 and leaves no chat row + +Short TTL, separate from persistence. API recreated with SESSION_TTL_SECONDS=2, +then .env restored to 3600 and the API recreated again. + PASS: same token got 401 after 3 seconds. + +Postgres stopped, API left running: + GET /health/live 200 {"status":"ok"} + GET /health/ready 503 {"error":{"code":"unavailable","message":"Хранилище недоступно",...}} + request_id in the body matched X-Request-Id. Body had no SQL. + Postgres was started again; /health/ready returned 200. diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..5933542d --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,53 @@ +-- Initial schema. The runner records this file in schema_migrations and skips it on the next start. + +CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp() +); + +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + CONSTRAINT users_username_unique UNIQUE (username), + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +CREATE TABLE sessions ( + token_hash TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users (id), + expires_at TIMESTAMPTZ NOT NULL +); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats (id), + user_id UUID NOT NULL REFERENCES users (id), + position INTEGER NOT NULL, + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_position_nonnegative CHECK (position >= 0) +); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats (id), + sender_id UUID NOT NULL REFERENCES users (id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL, + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +-- Keyset history: WHERE chat_id = ? AND (created_at, id) > cursor ORDER BY created_at, id. +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); + +-- Chat list is filtered by the caller, then ordered by the chat's own (created_at, id). +CREATE INDEX chat_members_user_idx ON chat_members (user_id); diff --git a/requirements.txt b/requirements.txt index 4ca087a8..0c7146cb 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,5 @@ # Direct: fastapi, pydantic, uvicorn, argon2-cffi. The rest are their dependencies, pinned. +asyncpg==0.32.0 annotated-doc==0.0.5 annotated-types==0.8.0 anyio==4.15.1 diff --git a/scripts/check_grade3.py b/scripts/check_grade3.py new file mode 100644 index 00000000..17565240 --- /dev/null +++ b/scripts/check_grade3.py @@ -0,0 +1,92 @@ +#!/usr/bin/env python3 +"""Grade-3 check that is not part of make test. + +Creates a chat with one unknown member and expects 400. Then asks PostgreSQL +whether that title was stored. A rollback leaves zero rows. +""" +import json +import os +import subprocess +import sys +import urllib.error +import urllib.request +import uuid + + +ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +BASE_URL = os.environ.get('BASE_URL', 'http://127.0.0.1:8080').rstrip('/') + + +def request(method, path, body=None, headers=None, expected=200): + data = None if body is None else json.dumps(body).encode('utf-8') + req = urllib.request.Request(BASE_URL + path, data=data, method=method) + req.add_header('Content-Type', 'application/json') + for key, value in (headers or {}).items(): + req.add_header(key, value) + try: + with urllib.request.urlopen(req, timeout=10) as response: + status = response.status + payload = response.read() + except urllib.error.HTTPError as exc: + status = exc.code + payload = exc.read() + if status != expected: + sys.stderr.write('expected %s %s -> %s, got %s %s\n' % (method, path, expected, status, payload[:300])) + return None + if not payload: + return {} + return json.loads(payload) + + +def main(): + username = 'u_orphan_' + uuid.uuid4().hex[:12] + password = 'T3st-' + uuid.uuid4().hex + user = request('POST', '/api/v1/users', { + 'username': username, + 'display_name': 'Orphan check', + 'password': password, + }, expected=201) + if user is None: + return 1 + import base64 + basic = base64.b64encode((username + ':' + password).encode('utf-8')).decode('ascii') + session = request('POST', '/api/v1/auth/sessions', headers={'Authorization': 'Basic ' + basic}, expected=201) + if session is None: + return 1 + title = 'orphan-' + uuid.uuid4().hex + missing = str(uuid.uuid4()) + rejected = request( + 'POST', + '/api/v1/chats', + {'title': title, 'member_ids': [user['id'], missing]}, + headers={'Authorization': 'Bearer ' + session['token']}, + expected=400, + ) + if rejected is None: + return 1 + sql = "SELECT count(*) FROM chats WHERE title = '%s'" % title.replace("'", '') + probe = subprocess.run( + [ + 'docker', 'compose', '--env-file', '.env', 'exec', '-T', 'postgres', + 'psql', '-U', os.environ.get('POSTGRES_USER', 'messenger'), + '-d', os.environ.get('POSTGRES_DB', 'messenger'), + '-tAc', sql, + ], + cwd=ROOT, + check=False, + capture_output=True, + text=True, + ) + if probe.returncode != 0: + sys.stderr.write(probe.stderr) + return 1 + count = probe.stdout.strip() + if count != '0': + sys.stderr.write('rolled-back chat is still stored: count=%s\n' % count) + return 1 + print('PASS: unknown member returns 400 and leaves no chat row') + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..8c183c0e --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Restart the API and PostgreSQL. Named volumes stay; nothing is re-seeded. +docker compose --env-file .env restart api postgres