From 4937d6d4e8238d5e0e805c1fc54fe83e603833eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D1=8F=D0=BA=D0=B8=D1=88=D0=B5=D0=B2=20=D0=92=D0=BB?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D1=81=D0=BB=D0=B0=D0=B2?= Date: Fri, 16 Oct 2026 11:03:43 +0300 Subject: [PATCH 1/3] =?UTF-8?q?=D0=9B=D0=A02:=20PostgreSQL,=20=D1=81=D0=B5?= =?UTF-8?q?=D1=81=D1=81=D0=B8=D0=B8=20(Basic=20+=20Bearer),=20Compose,=20?= =?UTF-8?q?=D0=BC=D0=B8=D0=B3=D1=80=D0=B0=D1=86=D0=B8=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .dockerignore | 18 +++- .env.example | 33 ++++-- .gitattributes | 2 + .gitignore | 3 + Dockerfile | 22 ++++ Makefile | 14 ++- REPORT.md | 64 ++++++++--- app/alembic.ini | 43 ++++++++ app/api/dependencies.py | 51 +++++++++ app/api/health.py | 19 ++++ app/api/v1/auth_rout.py | 65 +++++++++++ app/api/v1/chats_rout.py | 54 ++++++++++ app/api/v1/messages_rout.py | 46 ++++++++ app/api/v1/users_rout.py | 31 ++++++ app/core/config.py | 86 +++++++++++++++ app/core/db.py | 57 ++++++++++ app/core/logger.py | 15 +++ app/database_functions/chats_functions.py | 50 +++++++++ app/database_functions/messages_functions.py | 27 +++++ app/database_functions/sessions_functions.py | 29 +++++ app/database_functions/users_functions.py | 30 ++++++ app/main.py | 48 +++++++++ app/migrations/env.py | 52 +++++++++ app/migrations/script.py.mako | 28 +++++ .../versions/0001_initial_schema.py | 85 +++++++++++++++ app/models/__init__.py | 8 ++ app/models/base.py | 15 +++ app/models/chats_models.py | 35 ++++++ app/models/messages_models.py | 30 ++++++ app/models/sessions_models.py | 25 +++++ app/models/users_models.py | 21 ++++ app/schemas/auth_schemas.py | 13 +++ app/schemas/chats_schemas.py | 38 +++++++ app/schemas/error_schemas.py | 11 ++ app/schemas/health_schemas.py | 7 ++ app/schemas/messages_schemas.py | 33 ++++++ app/schemas/users_schemas.py | 29 +++++ app/utils/dates.py | 18 ++++ app/utils/errors.py | 50 +++++++++ app/utils/middleware.py | 27 +++++ app/utils/pagination.py | 35 ++++++ app/utils/security.py | 63 +++++++++++ compose.yaml | 74 +++++++++++++ evidence/persistence.txt | 20 ++++ pytest.ini | 5 + requirements-test.txt | 3 + requirements.txt | 26 +++++ scripts/init-secrets.ps1 | 19 ++++ scripts/init-secrets.sh | 18 ++++ scripts/restart.cmd | 8 ++ scripts/restart.sh | 9 ++ student-tests/conftest.py | 102 ++++++++++++++++++ student-tests/test_auth_api.py | 92 ++++++++++++++++ student-tests/test_chats_api.py | 54 ++++++++++ student-tests/test_messages_api.py | 66 ++++++++++++ student-tests/test_users_api.py | 69 ++++++++++++ 56 files changed, 1969 insertions(+), 26 deletions(-) create mode 100644 .gitattributes create mode 100644 Dockerfile create mode 100644 app/alembic.ini create mode 100644 app/api/dependencies.py create mode 100644 app/api/health.py create mode 100644 app/api/v1/auth_rout.py create mode 100644 app/api/v1/chats_rout.py create mode 100644 app/api/v1/messages_rout.py create mode 100644 app/api/v1/users_rout.py create mode 100644 app/core/config.py create mode 100644 app/core/db.py create mode 100644 app/core/logger.py create mode 100644 app/database_functions/chats_functions.py create mode 100644 app/database_functions/messages_functions.py create mode 100644 app/database_functions/sessions_functions.py create mode 100644 app/database_functions/users_functions.py create mode 100644 app/main.py create mode 100644 app/migrations/env.py create mode 100644 app/migrations/script.py.mako create mode 100644 app/migrations/versions/0001_initial_schema.py create mode 100644 app/models/__init__.py create mode 100644 app/models/base.py create mode 100644 app/models/chats_models.py create mode 100644 app/models/messages_models.py create mode 100644 app/models/sessions_models.py create mode 100644 app/models/users_models.py create mode 100644 app/schemas/auth_schemas.py create mode 100644 app/schemas/chats_schemas.py create mode 100644 app/schemas/error_schemas.py create mode 100644 app/schemas/health_schemas.py create mode 100644 app/schemas/messages_schemas.py create mode 100644 app/schemas/users_schemas.py create mode 100644 app/utils/dates.py create mode 100644 app/utils/errors.py create mode 100644 app/utils/middleware.py create mode 100644 app/utils/pagination.py create mode 100644 app/utils/security.py create mode 100644 compose.yaml create mode 100644 evidence/persistence.txt create mode 100644 pytest.ini create mode 100644 requirements-test.txt create mode 100644 requirements.txt create mode 100644 scripts/init-secrets.ps1 create mode 100755 scripts/init-secrets.sh create mode 100644 scripts/restart.cmd create mode 100755 scripts/restart.sh create mode 100644 student-tests/conftest.py create mode 100644 student-tests/test_auth_api.py create mode 100644 student-tests/test_chats_api.py create mode 100644 student-tests/test_messages_api.py create mode 100644 student-tests/test_users_api.py diff --git a/.dockerignore b/.dockerignore index bc16e556..45a17f3d 100644 --- a/.dockerignore +++ b/.dockerignore @@ -14,7 +14,23 @@ backups *.pfx *.jks .venv -__pycache__ +**/__pycache__ +**/*.pyc +.pytest_cache node_modules evidence .DS_Store +tests +student-tests +pytest.ini +requirements-test.txt +requirements-dev.txt +scripts +contracts +examples +infra +*.md +Dockerfile* +compose*.yaml +Makefile +lab.json diff --git a/.env.example b/.env.example index 714c8076..cb58e6a7 100644 --- a/.env.example +++ b/.env.example @@ -1,11 +1,24 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab -SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -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 +# Names follow pydantic-settings: prefix APP_CONFIG__, nesting via "__" (see app/core/config.py). +# Mapping to the skeleton's logical names: APP_HOST -> APP_CONFIG__RUN__HOST, APP_PORT -> APP_CONFIG__RUN__PORT, +# DATABASE_URL_FILE -> APP_CONFIG__DB__* (host/port/name/user + password file), +# SESSION_TTL_SECONDS -> APP_CONFIG__JWT__SESSION_TTL_SECONDS, SESSION_STORE=postgres (sessions table). +APP_CONFIG__RUN__HOST=0.0.0.0 +APP_CONFIG__RUN__PORT=8080 +APP_CONFIG__LOGGING__LEVEL=INFO + +# PostgreSQL. Values below are for running the API from the venv on the host; +# inside Compose the defaults (host=postgres, /run/secrets/postgres_password) are used. +APP_CONFIG__DB__HOST=127.0.0.1 +APP_CONFIG__DB__PORT=5432 +APP_CONFIG__DB__NAME=messenger +APP_CONFIG__DB__USER=messenger +# Path only, never the password itself. Relative paths are resolved from the project root. +APP_CONFIG__DB__PASSWORD_FILE=secrets/postgres_password + +# Sessions: JWT signed with a key from a secret file + server-side session row in PostgreSQL. +APP_CONFIG__JWT__SECRET_FILE=secrets/jwt_secret +APP_CONFIG__JWT__SESSION_TTL_SECONDS=3600 + +# Used by compose.yaml: host port for PostgreSQL (bound to 127.0.0.1 only). +POSTGRES_HOST_PORT=5432 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..f4609ace --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +*.sh text eol=lf +*.cmd text eol=crlf diff --git a/.gitignore b/.gitignore index b5a71896..07adb7b5 100644 --- a/.gitignore +++ b/.gitignore @@ -28,5 +28,8 @@ coverage/ .DS_Store .idea/ .vscode/ +.pytest_cache/ +# Personal study notes, not part of the submission +report_help.md # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..e41e2329 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,22 @@ +FROM python:3.14.3-slim@sha256:5e59aae31ff0e87511226be8e2b94d78c58f05216efda3b07dbbed938ec8583b + +ENV PYTHONUNBUFFERED=1 \ + PYTHONDONTWRITEBYTECODE=1 + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app/ . + +RUN useradd --no-create-home --shell /usr/sbin/nologin appuser +USER appuser + +EXPOSE 8080 + +# Liveness не зависит от БД; готовность (/health/ready) проверяют тесты и restart-скрипт. +HEALTHCHECK --interval=10s --timeout=3s --start-period=10s \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live')" + +CMD ["python", "main.py"] diff --git a/Makefile b/Makefile index 9ecb223e..23d09285 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence test-own migrate up down help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" @@ -24,3 +24,15 @@ 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) + +test-own: + $(PYTHON) -m pytest -v + +migrate: + cd app && $(PYTHON) -m alembic upgrade head + +up: + docker compose up -d --build --wait + +down: + docker compose down diff --git a/REPORT.md b/REPORT.md index e42f2b05..84be683b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,73 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Мякишев Владислав, БПИ2302 +- Целевая оценка: 3 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Источники и библиотеки: FastAPI, SQLAlchemy 2.1 (ORM), Alembic, psycopg 3, argon2-cffi, PyJWT; документация PostgreSQL, Alembic, RFC 7617. При разработке использовался ИИ-ассистент (Claude). ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужно: Docker с Compose v2, Python 3.9+ (для тестов). Образы: `postgres:17.10-alpine`, `python:3.14.3-slim` (закреплены digest в `compose.yaml`/`Dockerfile`). + +```sh +sh scripts/init-secrets.sh # Windows: powershell -File scripts\init-secrets.ps1 +docker compose up -d --build --wait # postgres (healthy) -> migrate (exit 0) -> api (healthy) +make test # публичный smoke +chmod +x scripts/restart.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +- `init-secrets` создаёт `secrets/postgres_password`, `secrets/jwt_secret` (случайные, не выводятся, вне Git) и `.env` из `.env.example`. +- Миграции применяет разовый сервис `migrate` (`alembic upgrade head`) при каждом `up`; повторный запуск ничего не меняет. +- Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных: `docker compose down -v`. +- Свои тесты (нужен запущенный `postgres`, используют отдельную базу `messenger_test`): + `python -m venv .venv && .venv/bin/pip install -r requirements-test.txt && .venv/bin/python -m pytest` +- На Windows тест сохранности: `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` (`restart.cmd` — те же команды, что `restart.sh`). ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Клиент → API (FastAPI, `api`) → PostgreSQL 17 (`postgres`, volume `postgres_data`). PostgreSQL — источник истины для пользователей, чатов, участников, сообщений и сессий (`SESSION_STORE=postgres`). + +| Роль | Сервис | Готовность | Хранилище | Порт | Credentials | +| --- | --- | --- | --- | --- | --- | +| база | `postgres` | `pg_isready` | volume `postgres_data` | 127.0.0.1:5432 | secret `postgres_password` | +| миграции | `migrate` | exit 0 | — | — | secret `postgres_password` | +| API | `api` | `/health/live` (Docker), `/health/ready` (проверяет БД) | нет | 127.0.0.1:8080 | secrets `postgres_password`, `jwt_secret` | + +- **Схема** (миграция `0001`): `users` (UNIQUE username, CHECK формата), `sessions` (PK = SHA-256 токена, `expires_at`), `chats`, `chat_members` (PK `(chat_id, user_id)`), `messages` (составной FK `(chat_id, sender_id)` → `chat_members`, индекс `(chat_id, created_at, id)` для keyset-пагинации). +- **Транзакции:** создание чата — одна транзакция (чат + все участники); 201 возвращается только после COMMIT. Дубль username отсекается ограничением `users_username_key` → 409. +- **Аутентификация:** регистрация с паролем (Argon2id). `POST /auth/sessions` принимает только Basic и выдаёт JWT (HS256, `sub`/`iat`/`exp`/`jti`, `jti` — 256 бит случайности). На сервере хранится сессия (хеш токена + срок). Bearer проверяется по подписи, `exp` и наличию сессии в БД; logout удаляет сессию. `X-User-Id` не читается. +- **Из lab1 перенесено:** весь API, формат ошибок, `X-Request-Id`, cursor-пагинация, Dockerfile. **Изменено:** хранилище в памяти → PostgreSQL (`app/models`, `app/database_functions`), X-User-Id → Basic/Bearer, добавлены Compose и миграции. +- **Переменные** (`.env.example` курса → наши): `APP_HOST/APP_PORT` → `APP_CONFIG__RUN__HOST/PORT`; `DATABASE_URL_FILE` → `APP_CONFIG__DB__HOST/PORT/NAME/USER` + `APP_CONFIG__DB__PASSWORD_FILE`; `SESSION_TTL_SECONDS` → `APP_CONFIG__JWT__SESSION_TTL_SECONDS` (3600). ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` против стенда в Compose | `PASS: lab2 public API scenario` | вывод команды | +| Данные и действующие сессии переживают рестарт API и БД без удаления volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (на Windows — `restart.cmd`) | `PASS: persistence preserved confirmed data and existing session`; у `api` и `postgres` новый StartedAt при тех же id контейнеров и том же volume | `evidence/persistence.txt` | +| Таблицы, PK/FK, UNIQUE username, миграции с нуля | `alembic downgrade base` → `alembic upgrade head`; `alembic check` | схема создаётся заново; `No new upgrade operations detected` | `app/migrations/versions/0001_initial_schema.py` | +| Повторные миграции без дублей | `docker compose up` при существующей схеме | `migrate` завершается с кодом 0 без `Running upgrade`, данные не меняются | `docker compose logs migrate` | +| Атомарное создание чата | `pytest student-tests/test_chats_api.py` | при неизвестном участнике — 400 и 0 строк в `chats`/`chat_members` | `student-tests/test_chats_api.py` | +| Basic только на входе, Bearer, expiry, logout, X-User-Id не работает | `pytest student-tests/test_auth_api.py` + smoke | 401 с корректным `WWW-Authenticate`; токен после logout и после TTL → 401 | `student-tests/test_auth_api.py` | +| Пароли — password KDF | `pytest student-tests/test_users_api.py` | в БД `$argon2id$…`, в ответах пароля нет | `student-tests/test_users_api.py` | +| Секреты/volumes вне Git | `git status --ignored` | `.env`, `secrets/` в игноре | `.gitignore` | +| Свои тесты | `python -m pytest` | `30 passed` | `student-tests/` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Проверка истечения на стенде: `APP_CONFIG__JWT__SESSION_TTL_SECONDS=2 docker compose up -d --wait api` → войти, подождать 3 с → запрос с токеном даёт 401. Вернуть: `docker compose up -d --wait api`. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `scripts/restart.sh`: stop + up API и PostgreSQL | данные и сессии сохраняются | test-persistence PASS, тот же токен работает | ~22 с на весь сценарий; потерь нет | +| `docker compose stop postgres` при работающем API | `/health/ready` → 503, бизнес-запросы → 503 без деталей | 503 через ~3 с (connect_timeout); после `start` — 200 без рестарта API (`pool_pre_ping`) | несколько секунд; потерь нет | +| SIGTERM API (`docker compose stop api`) | корректное завершение | `Shutting down` → `Соединения с базой данных закрыты` → `Finished server process` | — | ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Один экземпляр API и одна PostgreSQL без реплик и бэкапов: потеря volume = потеря данных. +- Токен — JWT: payload (UUID пользователя, время) читается клиентом, секретов в нём нет; отзыв обеспечивается серверной сессией. +- При одновременной записи курсор может пропустить сообщение, чьё `created_at` меньше уже выданного (окно — время между INSERT и COMMIT); повторное чтение с начала его показывает. Время назначает PostgreSQL. +- Истёкшие сессии из таблицы не удаляются автоматически (индекс по `expires_at` есть). +- Не сделано (уровень 4): Redis/Valkey, EXPLAIN на ≥10 000 сообщений, тест гонки регистрации. diff --git a/app/alembic.ini b/app/alembic.ini new file mode 100644 index 00000000..26749615 --- /dev/null +++ b/app/alembic.ini @@ -0,0 +1,43 @@ +# ASCII only: Alembic reads this file in the OS locale encoding. +# Database URL is built in env.py from app/core/config.py. + +[alembic] +script_location = %(here)s/migrations +file_template = %%(rev)s_%%(slug)s +prepend_sys_path = . +path_separator = os +output_encoding = utf-8 + +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/app/api/dependencies.py b/app/api/dependencies.py new file mode 100644 index 00000000..5cbbbba1 --- /dev/null +++ b/app/api/dependencies.py @@ -0,0 +1,51 @@ +from fastapi import Depends, HTTPException, Request, Security +from fastapi.security import HTTPBasic, HTTPBearer +from sqlalchemy.orm import Session + +from core.db import get_db +from database_functions.sessions_functions import get_active_session +from models import AuthSession, User +from utils.security import decode_access_token, token_hash + +BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'} + + +# Security-схемы нужны, чтобы в Swagger появилась кнопка Authorize. +# Заголовок разбираем сами: стандартный HTTPBasic понимает пароль только в ASCII. +class RawBasicHeader(HTTPBasic): + async def __call__(self, request: Request) -> str | None: + return request.headers.get("Authorization") + + +class RawBearerHeader(HTTPBearer): + async def __call__(self, request: Request) -> str | None: + return request.headers.get("Authorization") + + +basic_scheme = RawBasicHeader(scheme_name="basicAuth", auto_error=False) +bearer_scheme = RawBearerHeader(scheme_name="bearerAuth", auto_error=False) + + +def unauthorized() -> HTTPException: + return HTTPException(status_code=401, detail="Нужен действительный Bearer-токен", headers=BEARER_CHALLENGE) + + +def get_current_session(authorization: str | None = Security(bearer_scheme), + db: Session = Depends(get_db)) -> AuthSession: + scheme, _, token = (authorization or "").partition(" ") + if scheme.lower() != "bearer" or not token: + raise unauthorized() + + # Подпись и exp проверяются без базы, отзыв (logout) — по таблице sessions. + payload = decode_access_token(token) + if payload is None: + raise unauthorized() + + auth_session = get_active_session(db, token_hash(token)) + if auth_session is None or str(auth_session.user_id) != payload["sub"]: + raise unauthorized() + return auth_session + + +def get_current_user(auth_session: AuthSession = Depends(get_current_session)) -> User: + return auth_session.user diff --git a/app/api/health.py b/app/api/health.py new file mode 100644 index 00000000..d2386218 --- /dev/null +++ b/app/api/health.py @@ -0,0 +1,19 @@ +from fastapi import APIRouter, HTTPException + +from core.db import check_database +from schemas.health_schemas import HealthResponse + +router = APIRouter(prefix="/health", tags=["health"]) + + +@router.get("/live", response_model=HealthResponse) +def live_api(): + return HealthResponse(status="ok") + + +# В отличие от live, ready зависит от PostgreSQL. +@router.get("/ready", response_model=HealthResponse) +def ready_api(): + if not check_database(): + raise HTTPException(status_code=503, detail="База данных недоступна") + return HealthResponse(status="ok") diff --git a/app/api/v1/auth_rout.py b/app/api/v1/auth_rout.py new file mode 100644 index 00000000..bce0828e --- /dev/null +++ b/app/api/v1/auth_rout.py @@ -0,0 +1,65 @@ +import base64 +import binascii + +from fastapi import APIRouter, Depends, HTTPException, Response, Security +from sqlalchemy.orm import Session + +from api.dependencies import basic_scheme, get_current_session +from core.config import settings +from core.db import get_db +from core.logger import logger +from database_functions.sessions_functions import create_session, delete_session +from database_functions.users_functions import get_user_by_username +from models import AuthSession +from schemas.auth_schemas import SessionResponse +from schemas.users_schemas import UserResponse +from utils.security import create_access_token, token_hash, verify_password + +roter = APIRouter( + prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.auth, + tags=["auth"], +) + +BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} + + +def invalid_credentials() -> HTTPException: + # Один ответ и для неизвестного username, и для неверного пароля. + return HTTPException(status_code=401, detail="Неверное имя пользователя или пароль", headers=BASIC_CHALLENGE) + + +def parse_basic(authorization: str | None) -> tuple[str, str]: + scheme, _, encoded = (authorization or "").partition(" ") + if scheme.lower() != "basic" or not encoded: + raise invalid_credentials() + try: + decoded = base64.b64decode(encoded, validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError): + raise invalid_credentials() + # По первому двоеточию: в пароле двоеточие допустимо. + username, separator, password = decoded.partition(":") + if not separator: + raise invalid_credentials() + return username, password + + +@roter.post("/sessions", status_code=201, response_model=SessionResponse) +def create_session_api(authorization: str | None = Security(basic_scheme), db: Session = Depends(get_db)): + username, password = parse_basic(authorization) + + user = get_user_by_username(db, username) + if not verify_password(user.password_hash if user else None, password): + logger.info("Неудачная попытка входа") + raise invalid_credentials() + + token, issued_at, expires_at = create_access_token(user.id) + create_session(db, token_hash(token), user.id, created_at=issued_at, expires_at=expires_at) + logger.info(f"Вход выполнен: user_id={user.id}") + return SessionResponse(token=token, expires_at=expires_at, user=UserResponse.model_validate(user)) + + +@roter.delete("/sessions/current", status_code=204) +def delete_session_api(auth_session: AuthSession = Depends(get_current_session), db: Session = Depends(get_db)): + delete_session(db, auth_session.token_hash) + logger.info(f"Выход выполнен: user_id={auth_session.user_id}") + return Response(status_code=204) diff --git a/app/api/v1/chats_rout.py b/app/api/v1/chats_rout.py new file mode 100644 index 00000000..c09b080f --- /dev/null +++ b/app/api/v1/chats_rout.py @@ -0,0 +1,54 @@ +import uuid + +from fastapi import APIRouter, Depends, HTTPException, Query +from sqlalchemy.orm import Session + +from api.dependencies import get_current_user +from core.config import settings +from core.db import get_db +from core.logger import logger +from database_functions.chats_functions import create_chat, get_member_chat, list_user_chats +from models import User +from schemas.chats_schemas import ChatPageResponse, ChatResponse, CreateChatRequest +from utils.pagination import read_cursor, split_page + +roter = APIRouter( + prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats, + tags=["chats"], +) + + +@roter.post("", status_code=201, response_model=ChatResponse) +def create_chat_api(request: CreateChatRequest, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db)): + if current_user.id not in request.member_ids: + raise HTTPException(status_code=400, detail="Создатель должен быть участником чата") + + chat = create_chat(db, title=request.title, member_ids=request.member_ids) + if chat is None: + raise HTTPException(status_code=400, detail="Неизвестный участник") + logger.info(f"Чат создан: id={chat.id} участников={len(request.member_ids)}") + return ChatResponse.model_validate(chat) + + +@roter.get("", response_model=ChatPageResponse) +def list_chats_api( + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +): + scope = f"chats:{current_user.id}" + chats = list_user_chats(db, current_user.id, limit=limit, after=read_cursor(scope, cursor)) + page, next_cursor = split_page(chats, limit, scope) + return ChatPageResponse(items=[ChatResponse.model_validate(chat) for chat in page], next_cursor=next_cursor) + + +@roter.get("/{chat_id}", response_model=ChatResponse) +def get_chat_api(chat_id: uuid.UUID, current_user: User = Depends(get_current_user), + db: Session = Depends(get_db)): + chat = get_member_chat(db, chat_id, current_user.id) + if chat is None: + # Чужой чат неотличим от несуществующего. + raise HTTPException(status_code=404, detail="Чат не найден") + return ChatResponse.model_validate(chat) diff --git a/app/api/v1/messages_rout.py b/app/api/v1/messages_rout.py new file mode 100644 index 00000000..ff6091a5 --- /dev/null +++ b/app/api/v1/messages_rout.py @@ -0,0 +1,46 @@ +import uuid + +from fastapi import APIRouter, Depends, HTTPException, Query +from sqlalchemy.orm import Session + +from api.dependencies import get_current_user +from core.config import settings +from core.db import get_db +from database_functions.chats_functions import is_chat_member +from database_functions.messages_functions import create_message, list_messages +from models import User +from schemas.messages_schemas import CreateMessageRequest, MessagePageResponse, MessageResponse +from utils.pagination import read_cursor, split_page + +roter = APIRouter( + prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.chats, + tags=["messages"], +) + + +def ensure_member(db: Session, chat_id: uuid.UUID, user: User): + if not is_chat_member(db, chat_id, user.id): + raise HTTPException(status_code=404, detail="Чат не найден") + + +@roter.post("/{chat_id}/messages", status_code=201, response_model=MessageResponse) +def create_message_api(chat_id: uuid.UUID, request: CreateMessageRequest, + current_user: User = Depends(get_current_user), db: Session = Depends(get_db)): + ensure_member(db, chat_id, current_user) + message = create_message(db, chat_id=chat_id, sender_id=current_user.id, text=request.text) + return MessageResponse.model_validate(message) + + +@roter.get("/{chat_id}/messages", response_model=MessagePageResponse) +def list_messages_api( + chat_id: uuid.UUID, + limit: int = Query(default=50, ge=1, le=100), + cursor: str | None = Query(default=None, min_length=1), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db), +): + ensure_member(db, chat_id, current_user) + scope = f"chat:{chat_id}" + messages = list_messages(db, chat_id, limit=limit, after=read_cursor(scope, cursor)) + page, next_cursor = split_page(messages, limit, scope) + return MessagePageResponse(items=[MessageResponse.model_validate(m) for m in page], next_cursor=next_cursor) diff --git a/app/api/v1/users_rout.py b/app/api/v1/users_rout.py new file mode 100644 index 00000000..59b2d3a8 --- /dev/null +++ b/app/api/v1/users_rout.py @@ -0,0 +1,31 @@ +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session + +from api.dependencies import get_current_user +from core.config import settings +from core.db import get_db +from core.logger import logger +from database_functions.users_functions import create_user +from models import User +from schemas.users_schemas import CreateUserRequest, UserResponse +from utils.security import hash_password + +roter = APIRouter( + prefix=settings.api.prefix + settings.api.v1.prefix + settings.api.v1.users, + tags=["users"], +) + + +@roter.post("", status_code=201, response_model=UserResponse) +def register_user_api(request: CreateUserRequest, db: Session = Depends(get_db)): + user = create_user(db, username=request.username, display_name=request.display_name, + password_hash=hash_password(request.password)) + if user is None: + raise HTTPException(status_code=409, detail="Username уже занят") + logger.info(f"Пользователь создан: id={user.id}") + return UserResponse.model_validate(user) + + +@roter.get("/me", response_model=UserResponse) +def get_me_api(current_user: User = Depends(get_current_user)): + return UserResponse.model_validate(current_user) diff --git a/app/core/config.py b/app/core/config.py new file mode 100644 index 00000000..f1079fe6 --- /dev/null +++ b/app/core/config.py @@ -0,0 +1,86 @@ +from pathlib import Path +from typing import Literal + +from pydantic import BaseModel +from pydantic_settings import BaseSettings, SettingsConfigDict + +# Корень проекта (в контейнере код лежит в /app, и это будет "/"). +BASE_DIR = Path(__file__).resolve().parents[2] + + +class RunConfig(BaseModel): + host: str = "0.0.0.0" + port: int = 8080 + graceful_timeout: int = 5 + + +class LoggingConfig(BaseModel): + level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO" + format: str = "[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s" + datefmt: str = "%Y-%m-%d %H:%M:%S" + + +class DatabaseConfig(BaseModel): + # Значения по умолчанию — для запуска внутри Compose. + host: str = "postgres" + port: int = 5432 + name: str = "messenger" + user: str = "messenger" + password_file: Path = Path("/run/secrets/postgres_password") + + pool_size: int = 5 + max_overflow: int = 5 + pool_timeout: int = 5 + connect_timeout: int = 3 + statement_timeout_ms: int = 5000 + echo: bool = False + + def read_password(self) -> str: + return read_secret(self.password_file) + + +class JWTConfig(BaseModel): + # Ключ должен сохраняться между перезапусками, иначе выданные токены станут недействительны. + secret_file: Path = Path("/run/secrets/jwt_secret") + algorithm: str = "HS256" + session_ttl_seconds: int = 3600 + + def read_secret_key(self) -> str: + return read_secret(self.secret_file) + + +def read_secret(path: Path) -> str: + """Прочитать файл-секрет. Относительный путь считается от корня проекта.""" + full_path = path if path.is_absolute() else BASE_DIR / path + return full_path.read_text(encoding="utf-8").strip() + + +class ApiV1Prefix(BaseModel): + prefix: str = "/v1" + users: str = "/users" + chats: str = "/chats" + auth: str = "/auth" + + +class ApiPrefix(BaseModel): + prefix: str = "/api" + v1: ApiV1Prefix = ApiV1Prefix() + + +class Settings(BaseSettings): + model_config = SettingsConfigDict( + env_file=BASE_DIR / ".env", + case_sensitive=False, + env_nested_delimiter="__", + env_prefix="APP_CONFIG__", + extra="ignore", + ) + + run: RunConfig = RunConfig() + api: ApiPrefix = ApiPrefix() + logging: LoggingConfig = LoggingConfig() + db: DatabaseConfig = DatabaseConfig() + jwt: JWTConfig = JWTConfig() + + +settings = Settings() diff --git a/app/core/db.py b/app/core/db.py new file mode 100644 index 00000000..655b3de8 --- /dev/null +++ b/app/core/db.py @@ -0,0 +1,57 @@ +from collections.abc import Iterator + +from sqlalchemy import URL, create_engine, text +from sqlalchemy.exc import SQLAlchemyError +from sqlalchemy.orm import Session, sessionmaker + +from core.config import settings +from core.logger import logger + + +def build_url() -> URL: + return URL.create( + drivername="postgresql+psycopg", + username=settings.db.user, + password=settings.db.read_password(), + host=settings.db.host, + port=settings.db.port, + database=settings.db.name, + ) + + +engine = create_engine( + build_url(), + pool_size=settings.db.pool_size, + max_overflow=settings.db.max_overflow, + pool_timeout=settings.db.pool_timeout, + # Проверять соединение перед выдачей из пула (нужно после рестарта PostgreSQL). + pool_pre_ping=True, + connect_args={ + "connect_timeout": settings.db.connect_timeout, + "options": f"-c statement_timeout={settings.db.statement_timeout_ms}", + }, + echo=settings.db.echo, +) + +SessionLocal = sessionmaker(bind=engine, expire_on_commit=False) + + +def get_db() -> Iterator[Session]: + """Одна ORM-сессия на HTTP-запрос.""" + with SessionLocal() as session: + yield session + + +def check_database() -> bool: + try: + with engine.connect() as connection: + connection.execute(text("SELECT 1")) + return True + except SQLAlchemyError as exc: + # Только тип ошибки: в тексте может оказаться адрес БД. + logger.warning(f"PostgreSQL недоступен: {type(exc).__name__}") + return False + + +def log_database_target(): + logger.info(f"База данных: {engine.url.render_as_string(hide_password=True)}") diff --git a/app/core/logger.py b/app/core/logger.py new file mode 100644 index 00000000..5c1d8d8f --- /dev/null +++ b/app/core/logger.py @@ -0,0 +1,15 @@ +import logging + +from core.config import settings + + +def setup_logger(): + logging.basicConfig( + level=settings.logging.level, + format=settings.logging.format, + datefmt=settings.logging.datefmt, + ) + return logging.getLogger("messenger") + + +logger = setup_logger() diff --git a/app/database_functions/chats_functions.py b/app/database_functions/chats_functions.py new file mode 100644 index 00000000..2f307f34 --- /dev/null +++ b/app/database_functions/chats_functions.py @@ -0,0 +1,50 @@ +import uuid + +from sqlalchemy import func, select, tuple_ +from sqlalchemy.exc import IntegrityError +from sqlalchemy.orm import Session + +from models import Chat, ChatMember, User +from utils.pagination import Position + + +def create_chat(db: Session, title: str, member_ids: list[uuid.UUID]) -> Chat | None: + """Чат и участники — одна транзакция. None — есть несуществующий участник.""" + found = db.scalar(select(func.count()).select_from(User).where(User.id.in_(member_ids))) + if found != len(member_ids): + return None + + chat = Chat(title=title, members=[ChatMember(user_id=user_id) for user_id in sorted(member_ids)]) + db.add(chat) + try: + db.commit() + except IntegrityError: + db.rollback() + return None + return chat + + +def is_chat_member(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> bool: + return db.get(ChatMember, (chat_id, user_id)) is not None + + +def get_member_chat(db: Session, chat_id: uuid.UUID, user_id: uuid.UUID) -> Chat | None: + query = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(Chat.id == chat_id, ChatMember.user_id == user_id) + ) + return db.scalar(query) + + +def list_user_chats(db: Session, user_id: uuid.UUID, limit: int, after: Position | None) -> list[Chat]: + query = ( + select(Chat) + .join(ChatMember, ChatMember.chat_id == Chat.id) + .where(ChatMember.user_id == user_id) + .order_by(Chat.created_at, Chat.id) + .limit(limit + 1) + ) + if after is not None: + query = query.where(tuple_(Chat.created_at, Chat.id) > tuple_(*after)) + return list(db.scalars(query)) diff --git a/app/database_functions/messages_functions.py b/app/database_functions/messages_functions.py new file mode 100644 index 00000000..9bbf2571 --- /dev/null +++ b/app/database_functions/messages_functions.py @@ -0,0 +1,27 @@ +import uuid + +from sqlalchemy import select, tuple_ +from sqlalchemy.orm import Session + +from models import Message +from utils.pagination import Position + + +def create_message(db: Session, chat_id: uuid.UUID, sender_id: uuid.UUID, text: str) -> Message: + message = Message(chat_id=chat_id, sender_id=sender_id, text=text) + db.add(message) + db.commit() + return message + + +def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | None) -> list[Message]: + # Keyset-пагинация по индексу messages_chat_history_idx (chat_id, created_at, id). + query = ( + select(Message) + .where(Message.chat_id == chat_id) + .order_by(Message.created_at, Message.id) + .limit(limit + 1) + ) + if after is not None: + query = query.where(tuple_(Message.created_at, Message.id) > tuple_(*after)) + return list(db.scalars(query)) diff --git a/app/database_functions/sessions_functions.py b/app/database_functions/sessions_functions.py new file mode 100644 index 00000000..092d87e7 --- /dev/null +++ b/app/database_functions/sessions_functions.py @@ -0,0 +1,29 @@ +import uuid +from datetime import datetime + +from sqlalchemy import delete, func, select +from sqlalchemy.orm import Session + +from models import AuthSession + + +def create_session(db: Session, token_hash: bytes, user_id: uuid.UUID, + created_at: datetime, expires_at: datetime) -> AuthSession: + auth_session = AuthSession(token_hash=token_hash, user_id=user_id, created_at=created_at, expires_at=expires_at) + db.add(auth_session) + db.commit() + return auth_session + + +def get_active_session(db: Session, token_hash: bytes) -> AuthSession | None: + query = select(AuthSession).where( + AuthSession.token_hash == token_hash, + AuthSession.expires_at > func.now(), + ) + return db.scalar(query) + + +def delete_session(db: Session, token_hash: bytes) -> bool: + result = db.execute(delete(AuthSession).where(AuthSession.token_hash == token_hash)) + db.commit() + return result.rowcount > 0 diff --git a/app/database_functions/users_functions.py b/app/database_functions/users_functions.py new file mode 100644 index 00000000..2aa8c1d4 --- /dev/null +++ b/app/database_functions/users_functions.py @@ -0,0 +1,30 @@ +import uuid + +from sqlalchemy import select +from sqlalchemy.exc import IntegrityError +from sqlalchemy.orm import Session + +from models import User + + +def create_user(db: Session, username: str, display_name: str, password_hash: str) -> User | None: + """None — username уже занят.""" + user = User(username=username, display_name=display_name, password_hash=password_hash) + db.add(user) + try: + db.commit() + except IntegrityError as exc: + db.rollback() + # Уникальность проверяет сама БД, поэтому гонка регистрации невозможна. + if exc.orig.diag.constraint_name == "users_username_key": + return None + raise + return user + + +def get_user(db: Session, user_id: uuid.UUID) -> User | None: + return db.get(User, user_id) + + +def get_user_by_username(db: Session, username: str) -> User | None: + return db.scalar(select(User).where(User.username == username)) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..951a5139 --- /dev/null +++ b/app/main.py @@ -0,0 +1,48 @@ +from contextlib import asynccontextmanager + +import uvicorn +from fastapi import FastAPI +from starlette.middleware.base import BaseHTTPMiddleware + +from api.health import router as health_router +from api.v1.auth_rout import roter as auth_router +from api.v1.chats_rout import roter as chats_router +from api.v1.messages_rout import roter as messages_router +from api.v1.users_rout import roter as users_router +from core.config import settings +from core.db import engine, log_database_target +from core.logger import logger +from utils.errors import register_error_handlers +from utils.middleware import request_id_middleware + + +@asynccontextmanager +async def lifespan(app: FastAPI): + log_database_target() + yield + # Остановка (в том числе по SIGTERM): закрываем соединения пула. + engine.dispose() + logger.info("Соединения с базой данных закрыты") + + +app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan) + +app.add_middleware(BaseHTTPMiddleware, dispatch=request_id_middleware) +register_error_handlers(app) + +app.include_router(health_router) +app.include_router(auth_router) +app.include_router(users_router) +app.include_router(chats_router) +app.include_router(messages_router) + + +if __name__ == "__main__": + logger.info(f"Запуск сервера на {settings.run.host}:{settings.run.port}") + uvicorn.run( + "main:app", + host=settings.run.host, + port=settings.run.port, + timeout_graceful_shutdown=settings.run.graceful_timeout, + access_log=False, # запросы логирует наш middleware + ) diff --git a/app/migrations/env.py b/app/migrations/env.py new file mode 100644 index 00000000..e5f91aa3 --- /dev/null +++ b/app/migrations/env.py @@ -0,0 +1,52 @@ +from logging.config import fileConfig + +from alembic import context +from sqlalchemy import create_engine, pool, text + +from core.config import settings +from core.db import build_url +from models import Base + +config = context.config + +if config.config_file_name is not None: + fileConfig(config.config_file_name) + +target_metadata = Base.metadata + +# Ключ advisory lock: параллельные запуски миграций выполнятся по очереди. +MIGRATION_LOCK_KEY = 2_026_002 + + +def run_migrations_offline() -> None: + context.configure( + url=build_url(), + target_metadata=target_metadata, + literal_binds=True, + dialect_opts={"paramstyle": "named"}, + ) + with context.begin_transaction(): + context.run_migrations() + + +def run_migrations_online() -> None: + engine = create_engine( + build_url(), + poolclass=pool.NullPool, + connect_args={"connect_timeout": settings.db.connect_timeout}, + ) + with engine.connect() as connection: + context.configure( + connection=connection, + target_metadata=target_metadata, + compare_server_default=True, + ) + with context.begin_transaction(): + connection.execute(text("SELECT pg_advisory_xact_lock(:key)"), {"key": MIGRATION_LOCK_KEY}) + context.run_migrations() + + +if context.is_offline_mode(): + run_migrations_offline() +else: + run_migrations_online() diff --git a/app/migrations/script.py.mako b/app/migrations/script.py.mako new file mode 100644 index 00000000..11016301 --- /dev/null +++ b/app/migrations/script.py.mako @@ -0,0 +1,28 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + """Upgrade schema.""" + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + """Downgrade schema.""" + ${downgrades if downgrades else "pass"} diff --git a/app/migrations/versions/0001_initial_schema.py b/app/migrations/versions/0001_initial_schema.py new file mode 100644 index 00000000..254d2257 --- /dev/null +++ b/app/migrations/versions/0001_initial_schema.py @@ -0,0 +1,85 @@ +"""initial schema + +Revision ID: 0001 +Revises: +Create Date: 2026-10-15 17:30:37.825446 + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = '0001' +down_revision: Union[str, Sequence[str], None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + """Upgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.create_table('chats', + sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False), + sa.Column('title', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False), + sa.CheckConstraint('char_length(title) BETWEEN 1 AND 100', name=op.f('chats_title_len')), + sa.PrimaryKeyConstraint('id', name=op.f('chats_pkey')) + ) + op.create_table('users', + sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False), + sa.Column('username', sa.Text(), nullable=False), + sa.Column('display_name', sa.Text(), nullable=False), + sa.Column('password_hash', sa.Text(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False), + sa.CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name=op.f('users_username_format')), + sa.CheckConstraint('char_length(display_name) BETWEEN 1 AND 100', name=op.f('users_display_name_len')), + sa.PrimaryKeyConstraint('id', name=op.f('users_pkey')), + sa.UniqueConstraint('username', name=op.f('users_username_key')) + ) + op.create_table('chat_members', + sa.Column('chat_id', sa.Uuid(), nullable=False), + sa.Column('user_id', sa.Uuid(), nullable=False), + sa.ForeignKeyConstraint(['chat_id'], ['chats.id'], name=op.f('chat_members_chat_id_fkey')), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('chat_members_user_id_fkey')), + sa.PrimaryKeyConstraint('chat_id', 'user_id', name=op.f('chat_members_pkey')) + ) + op.create_index(op.f('chat_members_user_id_chat_id_idx'), 'chat_members', ['user_id', 'chat_id'], unique=False) + op.create_table('sessions', + sa.Column('token_hash', sa.LargeBinary(), nullable=False), + sa.Column('user_id', sa.Uuid(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False), + sa.Column('expires_at', sa.DateTime(timezone=True), nullable=False), + sa.CheckConstraint('expires_at > created_at', name=op.f('sessions_expiry_after_creation')), + sa.ForeignKeyConstraint(['user_id'], ['users.id'], name=op.f('sessions_user_id_fkey'), ondelete='CASCADE'), + sa.PrimaryKeyConstraint('token_hash', name=op.f('sessions_pkey')) + ) + op.create_index(op.f('sessions_expires_at_idx'), 'sessions', ['expires_at'], unique=False) + op.create_table('messages', + sa.Column('id', sa.Uuid(), server_default=sa.text('gen_random_uuid()'), nullable=False), + sa.Column('chat_id', sa.Uuid(), nullable=False), + sa.Column('sender_id', sa.Uuid(), nullable=False), + sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('clock_timestamp()'), nullable=False), + sa.Column('text', sa.Text(), nullable=False), + sa.CheckConstraint('char_length(text) BETWEEN 1 AND 4000', name=op.f('messages_text_len')), + sa.ForeignKeyConstraint(['chat_id', 'sender_id'], ['chat_members.chat_id', 'chat_members.user_id'], name='messages_sender_is_member'), + sa.PrimaryKeyConstraint('id', name=op.f('messages_pkey')) + ) + op.create_index('messages_chat_history_idx', 'messages', ['chat_id', 'created_at', 'id'], unique=False) + # ### end Alembic commands ### + + +def downgrade() -> None: + """Downgrade schema.""" + # ### commands auto generated by Alembic - please adjust! ### + op.drop_index('messages_chat_history_idx', table_name='messages') + op.drop_table('messages') + op.drop_index(op.f('sessions_expires_at_idx'), table_name='sessions') + op.drop_table('sessions') + op.drop_index(op.f('chat_members_user_id_chat_id_idx'), table_name='chat_members') + op.drop_table('chat_members') + op.drop_table('users') + op.drop_table('chats') + # ### end Alembic commands ### diff --git a/app/models/__init__.py b/app/models/__init__.py new file mode 100644 index 00000000..91e29388 --- /dev/null +++ b/app/models/__init__.py @@ -0,0 +1,8 @@ +# Все модели импортируются здесь, чтобы Base.metadata (и Alembic) видел все таблицы. +from models.base import Base +from models.chats_models import Chat, ChatMember +from models.messages_models import Message +from models.sessions_models import AuthSession +from models.users_models import User + +__all__ = ["Base", "User", "AuthSession", "Chat", "ChatMember", "Message"] diff --git a/app/models/base.py b/app/models/base.py new file mode 100644 index 00000000..2f98d6c4 --- /dev/null +++ b/app/models/base.py @@ -0,0 +1,15 @@ +from sqlalchemy import MetaData +from sqlalchemy.orm import DeclarativeBase + +# Предсказуемые имена ограничений: по ним разбираем ошибки БД (users_username_key -> 409). +NAMING_CONVENTION = { + "pk": "%(table_name)s_pkey", + "uq": "%(table_name)s_%(column_0_name)s_key", + "ck": "%(table_name)s_%(constraint_name)s", + "fk": "%(table_name)s_%(column_0_name)s_fkey", + "ix": "%(table_name)s_%(column_0_N_name)s_idx", +} + + +class Base(DeclarativeBase): + metadata = MetaData(naming_convention=NAMING_CONVENTION) diff --git a/app/models/chats_models.py b/app/models/chats_models.py new file mode 100644 index 00000000..a086d791 --- /dev/null +++ b/app/models/chats_models.py @@ -0,0 +1,35 @@ +import uuid +from datetime import datetime + +from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, Text, Uuid, text +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from models.base import Base + + +class Chat(Base): + __tablename__ = "chats" + __table_args__ = ( + CheckConstraint("char_length(title) BETWEEN 1 AND 100", name="title_len"), + ) + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=text("gen_random_uuid()")) + title: Mapped[str] = mapped_column(Text) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()")) + + # selectin: участники всех чатов страницы грузятся одним запросом (без N+1). + members: Mapped[list["ChatMember"]] = relationship(lazy="selectin", order_by="ChatMember.user_id") + + @property + def member_ids(self) -> list[uuid.UUID]: + return [member.user_id for member in self.members] + + +class ChatMember(Base): + __tablename__ = "chat_members" + __table_args__ = ( + Index(None, "user_id", "chat_id"), # для «моих чатов» + ) + + chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), primary_key=True) + user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), primary_key=True) diff --git a/app/models/messages_models.py b/app/models/messages_models.py new file mode 100644 index 00000000..6b44d42f --- /dev/null +++ b/app/models/messages_models.py @@ -0,0 +1,30 @@ +import uuid +from datetime import datetime + +from sqlalchemy import CheckConstraint, DateTime, ForeignKeyConstraint, Index, Text, Uuid +# Псевдоним: столбец `text` ниже перекрыл бы функцию text(). +from sqlalchemy import text as sql_text +from sqlalchemy.orm import Mapped, mapped_column + +from models.base import Base + + +class Message(Base): + __tablename__ = "messages" + __table_args__ = ( + CheckConstraint("char_length(text) BETWEEN 1 AND 4000", name="text_len"), + # Отправитель обязан быть участником чата. + ForeignKeyConstraint( + ["chat_id", "sender_id"], + ["chat_members.chat_id", "chat_members.user_id"], + name="messages_sender_is_member", + ), + Index("messages_chat_history_idx", "chat_id", "created_at", "id"), + ) + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=sql_text("gen_random_uuid()")) + chat_id: Mapped[uuid.UUID] = mapped_column(Uuid) + sender_id: Mapped[uuid.UUID] = mapped_column(Uuid) + created_at: Mapped[datetime] = mapped_column( + DateTime(timezone=True), server_default=sql_text("clock_timestamp()")) + text: Mapped[str] = mapped_column(Text) diff --git a/app/models/sessions_models.py b/app/models/sessions_models.py new file mode 100644 index 00000000..ca350258 --- /dev/null +++ b/app/models/sessions_models.py @@ -0,0 +1,25 @@ +import uuid +from datetime import datetime + +from sqlalchemy import CheckConstraint, DateTime, ForeignKey, Index, LargeBinary, Uuid, text +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from models.base import Base +from models.users_models import User + + +class AuthSession(Base): + """Сессия входа (не путать с ORM-сессией SQLAlchemy).""" + __tablename__ = "sessions" + __table_args__ = ( + CheckConstraint("expires_at > created_at", name="expiry_after_creation"), + Index(None, "expires_at"), + ) + + # SHA-256 от токена, сам токен не храним. + token_hash: Mapped[bytes] = mapped_column(LargeBinary, primary_key=True) + user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id", ondelete="CASCADE")) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()")) + expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True)) + + user: Mapped[User] = relationship(lazy="joined") diff --git a/app/models/users_models.py b/app/models/users_models.py new file mode 100644 index 00000000..07884a16 --- /dev/null +++ b/app/models/users_models.py @@ -0,0 +1,21 @@ +import uuid +from datetime import datetime + +from sqlalchemy import CheckConstraint, DateTime, Text, Uuid, text +from sqlalchemy.orm import Mapped, mapped_column + +from models.base import Base + + +class User(Base): + __tablename__ = "users" + __table_args__ = ( + CheckConstraint("username ~ '^[a-z0-9_]{3,32}$'", name="username_format"), + CheckConstraint("char_length(display_name) BETWEEN 1 AND 100", name="display_name_len"), + ) + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True, server_default=text("gen_random_uuid()")) + username: Mapped[str] = mapped_column(Text, unique=True) + display_name: Mapped[str] = mapped_column(Text) + password_hash: Mapped[str] = mapped_column(Text) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=text("clock_timestamp()")) diff --git a/app/schemas/auth_schemas.py b/app/schemas/auth_schemas.py new file mode 100644 index 00000000..9f45dfb7 --- /dev/null +++ b/app/schemas/auth_schemas.py @@ -0,0 +1,13 @@ +from typing import Literal + +from pydantic import BaseModel + +from schemas.users_schemas import UserResponse +from utils.dates import UtcDatetime + + +class SessionResponse(BaseModel): + token: str + token_type: Literal["Bearer"] = "Bearer" + expires_at: UtcDatetime + user: UserResponse diff --git a/app/schemas/chats_schemas.py b/app/schemas/chats_schemas.py new file mode 100644 index 00000000..fbc3eb43 --- /dev/null +++ b/app/schemas/chats_schemas.py @@ -0,0 +1,38 @@ +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator + +from utils.dates import UtcDatetime + + +class CreateChatRequest(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: StrictStr = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1, max_length=100) + + @field_validator("title") + def validate_title(cls, v): + if not v.strip(): + raise ValueError("title must not be blank") + return v + + @field_validator("member_ids") + def validate_member_ids(cls, v): + if len(set(v)) != len(v): + raise ValueError("member_ids must be unique") + return v + + +class ChatResponse(BaseModel): + model_config = ConfigDict(from_attributes=True) + + id: UUID + title: str + member_ids: list[UUID] + created_at: UtcDatetime + + +class ChatPageResponse(BaseModel): + items: list[ChatResponse] + next_cursor: str | None diff --git a/app/schemas/error_schemas.py b/app/schemas/error_schemas.py new file mode 100644 index 00000000..b93b00af --- /dev/null +++ b/app/schemas/error_schemas.py @@ -0,0 +1,11 @@ +from pydantic import BaseModel + + +class ErrorBody(BaseModel): + code: str + message: str + request_id: str + + +class ErrorResponse(BaseModel): + error: ErrorBody diff --git a/app/schemas/health_schemas.py b/app/schemas/health_schemas.py new file mode 100644 index 00000000..9b69dec6 --- /dev/null +++ b/app/schemas/health_schemas.py @@ -0,0 +1,7 @@ +from typing import Literal + +from pydantic import BaseModel + + +class HealthResponse(BaseModel): + status: Literal["ok"] diff --git a/app/schemas/messages_schemas.py b/app/schemas/messages_schemas.py new file mode 100644 index 00000000..57b7b698 --- /dev/null +++ b/app/schemas/messages_schemas.py @@ -0,0 +1,33 @@ +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator + +from utils.dates import UtcDatetime + + +class CreateMessageRequest(BaseModel): + # extra="forbid": клиент не может прислать sender_id. + model_config = ConfigDict(extra="forbid") + + text: StrictStr = Field(min_length=1, max_length=4000) + + @field_validator("text") + def validate_text(cls, v): + if not v.strip(): + raise ValueError("text must not be blank") + return v + + +class MessageResponse(BaseModel): + model_config = ConfigDict(from_attributes=True) + + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: UtcDatetime + + +class MessagePageResponse(BaseModel): + items: list[MessageResponse] + next_cursor: str | None diff --git a/app/schemas/users_schemas.py b/app/schemas/users_schemas.py new file mode 100644 index 00000000..ff37a7b8 --- /dev/null +++ b/app/schemas/users_schemas.py @@ -0,0 +1,29 @@ +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator + +from utils.dates import UtcDatetime + + +class CreateUserRequest(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: StrictStr = Field(pattern=r"^[a-z0-9_]{3,32}$") + display_name: StrictStr = Field(min_length=1, max_length=100) + password: StrictStr = Field(min_length=12, max_length=128) + + @field_validator("display_name") + def validate_display_name(cls, v): + if not v.strip(): + raise ValueError("display_name must not be blank") + return v + + +class UserResponse(BaseModel): + # Собирается из ORM-объекта; password_hash сюда не попадает. + model_config = ConfigDict(from_attributes=True) + + id: UUID + username: str + display_name: str + created_at: UtcDatetime diff --git a/app/utils/dates.py b/app/utils/dates.py new file mode 100644 index 00000000..851217bc --- /dev/null +++ b/app/utils/dates.py @@ -0,0 +1,18 @@ +from datetime import datetime, timezone +from typing import Annotated + +from pydantic import PlainSerializer + +TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ" + + +def format_utc(value: datetime) -> str: + return value.astimezone(timezone.utc).strftime(TIME_FORMAT) + + +def parse_utc(value: str) -> datetime: + return datetime.strptime(value, TIME_FORMAT).replace(tzinfo=timezone.utc) + + +# datetime, который в JSON превращается в строку вида 2026-09-01T12:00:00.123456Z. +UtcDatetime = Annotated[datetime, PlainSerializer(format_utc, return_type=str)] diff --git a/app/utils/errors.py b/app/utils/errors.py new file mode 100644 index 00000000..d3066681 --- /dev/null +++ b/app/utils/errors.py @@ -0,0 +1,50 @@ +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from sqlalchemy.exc import OperationalError +from sqlalchemy.exc import TimeoutError as PoolTimeoutError +from starlette.exceptions import HTTPException + +from core.logger import logger +from schemas.error_schemas import ErrorBody, ErrorResponse + +ERROR_CODES = { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", + 500: "internal_error", + 503: "unavailable", +} + + +def error_response(request: Request, status_code: int, message: str, + headers: dict[str, str] | None = None) -> JSONResponse: + code = ERROR_CODES.get(status_code, "internal_error" if status_code >= 500 else "invalid_request") + body = ErrorResponse(error=ErrorBody(code=code, message=message, request_id=request.state.request_id)) + return JSONResponse(status_code=status_code, content=body.model_dump(), headers=headers) + + +def http_error_handler(request: Request, exc: HTTPException) -> JSONResponse: + message = exc.detail if isinstance(exc.detail, str) and exc.detail else "Ошибка запроса" + return error_response(request, exc.status_code, message, headers=exc.headers) + + +def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse: + return error_response(request, 400, "Неверный запрос") + + +# БД недоступна, statement_timeout или пул исчерпан -> 503 без подробностей. +def database_error_handler(request: Request, exc: Exception) -> JSONResponse: + logger.warning(f"Ошибка базы данных: {type(exc).__name__} request_id={request.state.request_id}") + return error_response(request, 503, "База данных недоступна") + + +def register_error_handlers(app: FastAPI): + app.add_exception_handler(HTTPException, http_error_handler) + app.add_exception_handler(RequestValidationError, validation_error_handler) + app.add_exception_handler(OperationalError, database_error_handler) + app.add_exception_handler(PoolTimeoutError, database_error_handler) diff --git a/app/utils/middleware.py b/app/utils/middleware.py new file mode 100644 index 00000000..09695f8e --- /dev/null +++ b/app/utils/middleware.py @@ -0,0 +1,27 @@ +import time +import uuid + +from fastapi import Request + +from core.logger import logger +from utils.errors import error_response + + +async def request_id_middleware(request: Request, call_next): + request.state.request_id = str(uuid.uuid4()) + start = time.monotonic() + + try: + response = await call_next(request) + except Exception: + # Подробности пишем только в лог сервера, клиенту — общий текст. + logger.exception(f"Непредвиденная ошибка request_id={request.state.request_id}") + response = error_response(request, 500, "Внутренняя ошибка сервера") + + response.headers["X-Request-Id"] = request.state.request_id + + # Тело запроса не логируем, чтобы текст сообщений не попадал в логи. + duration_ms = (time.monotonic() - start) * 1000 + logger.info(f"{request.method} {request.url.path} {response.status_code} " + f"{duration_ms:.1f}ms request_id={request.state.request_id}") + return response diff --git a/app/utils/pagination.py b/app/utils/pagination.py new file mode 100644 index 00000000..9cc34214 --- /dev/null +++ b/app/utils/pagination.py @@ -0,0 +1,35 @@ +import base64 +import json +import uuid +from datetime import datetime + +from fastapi import HTTPException + +from utils.dates import format_utc, parse_utc + +# Позиция в списке: (created_at, id) последнего выданного элемента. +Position = tuple[datetime, uuid.UUID] + + +def make_cursor(scope: str, created_at: datetime, item_id: uuid.UUID) -> str: + data = json.dumps({"scope": scope, "created_at": format_utc(created_at), "id": str(item_id)}) + return base64.urlsafe_b64encode(data.encode()).decode() + + +def read_cursor(scope: str, cursor: str | None) -> Position | None: + if cursor is None: + return None + try: + data = json.loads(base64.urlsafe_b64decode(cursor.encode())) + if data["scope"] != scope: + raise ValueError("cursor from another resource") + return parse_utc(data["created_at"]), uuid.UUID(data["id"]) + except Exception: + raise HTTPException(status_code=400, detail="Неверный cursor") + + +def split_page(rows: list, limit: int, scope: str) -> tuple[list, str | None]: + """rows получены с LIMIT limit + 1: лишняя строка значит, что есть следующая страница.""" + page = rows[:limit] + next_cursor = make_cursor(scope, page[-1].created_at, page[-1].id) if len(rows) > limit else None + return page, next_cursor diff --git a/app/utils/security.py b/app/utils/security.py new file mode 100644 index 00000000..76ea0703 --- /dev/null +++ b/app/utils/security.py @@ -0,0 +1,63 @@ +import hashlib +import secrets +import uuid +from datetime import datetime, timedelta, timezone + +import jwt +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +from core.config import settings + +password_hasher = PasswordHasher() # Argon2id + +# Проверяется, когда пользователя нет: время ответа такое же, как при неверном пароле. +DUMMY_PASSWORD_HASH = password_hasher.hash(secrets.token_urlsafe(16)) + + +def hash_password(password: str) -> str: + return password_hasher.hash(password) + + +def verify_password(password_hash: str | None, password: str) -> bool: + try: + password_hasher.verify(password_hash or DUMMY_PASSWORD_HASH, password) + return password_hash is not None + except (VerificationError, InvalidHashError): + return False + + +JWT_SECRET_KEY = settings.jwt.read_secret_key() + + +def create_access_token(user_id: uuid.UUID) -> tuple[str, datetime, datetime]: + """Возвращает (токен, время выдачи, время истечения).""" + # Целые секунды, чтобы expires_at совпадал с exp в токене. + issued_at = datetime.now(timezone.utc).replace(microsecond=0) + expires_at = issued_at + timedelta(seconds=settings.jwt.session_ttl_seconds) + payload = { + "sub": str(user_id), + "iat": issued_at, + "exp": expires_at, + "jti": secrets.token_urlsafe(32), # 256 бит случайности, токен всегда уникален + } + token = jwt.encode(payload, JWT_SECRET_KEY, algorithm=settings.jwt.algorithm) + return token, issued_at, expires_at + + +def decode_access_token(token: str) -> dict | None: + """None — подпись неверна, токен испорчен или истёк.""" + try: + return jwt.decode( + token, + JWT_SECRET_KEY, + algorithms=[settings.jwt.algorithm], # явно, чтобы не принять alg=none + options={"require": ["sub", "exp", "iat", "jti"]}, + ) + except jwt.InvalidTokenError: + return None + + +def token_hash(token: str) -> bytes: + # В БД хранится только хеш токена. + return hashlib.sha256(token.encode()).digest() diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..a6229738 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,74 @@ +# docker compose up -d --build --wait — запуск +# docker compose down — остановка (данные остаются в volume) +# docker compose down -v — удалить данные намеренно +name: mtusi-lab2 + +services: + postgres: + image: postgres:17.10-alpine@sha256:979c4379dd698aba0b890599a6104e082035f98ef31d9b9291ec22f2b13059ca + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - postgres_data:/var/lib/postgresql/data + ports: + - "127.0.0.1:${POSTGRES_HOST_PORT:-5432}:5432" + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 10s + restart: unless-stopped + + # Разовая задача: применить миграции и завершиться с кодом 0. + migrate: + build: . + image: mtusi-messenger:lab2 + command: ["python", "-m", "alembic", "upgrade", "head"] + environment: &app-env + APP_CONFIG__DB__HOST: postgres + APP_CONFIG__DB__PORT: "5432" + APP_CONFIG__DB__NAME: messenger + APP_CONFIG__DB__USER: messenger + APP_CONFIG__DB__PASSWORD_FILE: /run/secrets/postgres_password + APP_CONFIG__JWT__SECRET_FILE: /run/secrets/jwt_secret + APP_CONFIG__JWT__SESSION_TTL_SECONDS: ${APP_CONFIG__JWT__SESSION_TTL_SECONDS:-3600} + APP_CONFIG__LOGGING__LEVEL: ${APP_CONFIG__LOGGING__LEVEL:-INFO} + secrets: + - postgres_password + - jwt_secret + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api: + build: . + image: mtusi-messenger:lab2 + # Без env_file: в .env адреса для запуска из venv, а не из контейнера. + environment: *app-env + secrets: + - postgres_password + - jwt_secret + depends_on: + postgres: + condition: service_healthy + migrate: + condition: service_completed_successfully + ports: + - "127.0.0.1:8080:8080" + stop_grace_period: 10s + restart: unless-stopped + +volumes: + postgres_data: + +secrets: + postgres_password: + file: ./secrets/postgres_password + jwt_secret: + file: ./secrets/jwt_secret diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..bde26374 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,20 @@ +# test-persistence (Windows: scripts\restart.cmd = same commands as scripts/restart.sh) +date: 2026-10-16T10:05:33 + +## containers BEFORE +/mtusi-lab2-api-1 id=4dcf421abd1d started=2026-10-16T07:04:52.820712243Z status=running +/mtusi-lab2-postgres-1 id=64cc9db56db3 started=2026-10-16T07:04:41.833181321Z status=running + +## test output (exit 0, 22.3s) +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 (new StartedAt = really restarted) +/mtusi-lab2-api-1 id=4dcf421abd1d started=2026-10-16T07:05:25.634228444Z status=running +/mtusi-lab2-postgres-1 id=64cc9db56db3 started=2026-10-16T07:05:15.448515673Z status=running + +## volume (same, not recreated) +mtusi-lab2_postgres_data created=2026-10-15T14:23:31Z + +## rows in PostgreSQL after restart +users=15 chats=5 messages=9 active_sessions=8 diff --git a/pytest.ini b/pytest.ini new file mode 100644 index 00000000..78b8685f --- /dev/null +++ b/pytest.ini @@ -0,0 +1,5 @@ +[pytest] +testpaths = student-tests +pythonpath = app +filterwarnings = + ignore:Using .httpx. with .starlette.testclient. is deprecated diff --git a/requirements-test.txt b/requirements-test.txt new file mode 100644 index 00000000..9b5d2815 --- /dev/null +++ b/requirements-test.txt @@ -0,0 +1,3 @@ +-r requirements.txt +pytest==9.1.1 +httpx==0.28.1 diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..8bbaec33 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,26 @@ +fastapi==0.141.1 +starlette==1.7.0 +pydantic==2.13.5 +pydantic_core==2.46.5 +pydantic-settings==2.15.0 +python-dotenv==1.2.3 +uvicorn==0.54.0 +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +h11==0.16.0 +idna==3.20 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +SQLAlchemy==2.1.4 +psycopg==3.3.6 +psycopg-binary==3.3.6 +alembic==1.20.0 +Mako==1.4.3 +MarkupSafe==3.0.4 +argon2-cffi==25.1.0 +argon2-cffi-bindings==26.1.0 +cffi==2.1.1 +pycparser==3.11 +PyJWT==2.15.1 diff --git a/scripts/init-secrets.ps1 b/scripts/init-secrets.ps1 new file mode 100644 index 00000000..fa3fe6d5 --- /dev/null +++ b/scripts/init-secrets.ps1 @@ -0,0 +1,19 @@ +# Windows twin of scripts/init-secrets.sh. Existing files are kept. +$ErrorActionPreference = 'Stop' +Set-Location (Join-Path $PSScriptRoot '..') +New-Item -ItemType Directory -Force secrets | Out-Null + +function New-Secret($name, $bytes) { + $path = Join-Path 'secrets' $name + if ((Test-Path $path) -and (Get-Item $path).Length -gt 0) { "kept secrets/$name"; return } + $buffer = New-Object byte[] $bytes + [Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($buffer) + $value = [Convert]::ToBase64String($buffer) -replace '[+/=]', '' + # ASCII, no BOM, no trailing newline. + [IO.File]::WriteAllText((Join-Path (Get-Location) $path), $value, [Text.Encoding]::ASCII) + "created secrets/$name" +} + +New-Secret 'postgres_password' 32 +New-Secret 'jwt_secret' 64 +if (-not (Test-Path .env)) { Copy-Item .env.example .env; 'created .env' } diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..192ccba3 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,18 @@ +#!/bin/sh +# Создать локальные секреты после clone. Существующие файлы не перезаписываются. +set -eu +cd "$(dirname "$0")/.." +mkdir -p secrets + +make_secret() { + if [ ! -s "secrets/$1" ]; then + head -c "$2" /dev/urandom | base64 | tr -d '\n+/=' > "secrets/$1" + echo "created secrets/$1" + else + echo "kept secrets/$1" + fi +} + +make_secret postgres_password 32 +make_secret jwt_secret 64 +[ -f .env ] || { cp .env.example .env; echo "created .env"; } diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..636349c7 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,8 @@ +@echo off +rem Windows twin of scripts/restart.sh: the test cannot execute .sh on Windows. +setlocal +cd /d "%~dp0.." + +docker compose stop api postgres || exit /b 1 +docker compose up -d --wait || exit /b 1 +docker compose ps --format "{{.Name}} {{.Status}}" diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..100578c9 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,9 @@ +#!/bin/sh +# Hook для make test-persistence: перезапуск API и PostgreSQL с сохранением volumes. +set -eu +cd "$(dirname "$0")/.." + +docker compose stop api postgres +# Порядок: postgres (healthy) -> migrate (exit 0) -> api (healthy). +docker compose up -d --wait +docker compose ps --format '{{.Name}} {{.Status}}' diff --git a/student-tests/conftest.py b/student-tests/conftest.py new file mode 100644 index 00000000..8043a3b6 --- /dev/null +++ b/student-tests/conftest.py @@ -0,0 +1,102 @@ +import base64 +import os +from pathlib import Path + +# Отдельная тестовая база; задаётся до импорта приложения (настройки читаются при импорте). +TEST_DB_NAME = "messenger_test" +os.environ["APP_CONFIG__DB__NAME"] = TEST_DB_NAME + +import pytest +from alembic import command +from alembic.config import Config +from fastapi.testclient import TestClient +from sqlalchemy import create_engine, text + +from core.db import build_url, engine +from main import app + +APP_DIR = Path(__file__).resolve().parents[1] / "app" +PASSWORD = "Test-password-123" + + +@pytest.fixture(scope="session", autouse=True) +def test_database(): + # CREATE DATABASE нельзя выполнить в транзакции, поэтому AUTOCOMMIT. + admin = create_engine(build_url().set(database="postgres"), isolation_level="AUTOCOMMIT") + with admin.connect() as connection: + exists = connection.scalar(text("SELECT 1 FROM pg_database WHERE datname = :name"), {"name": TEST_DB_NAME}) + if not exists: + connection.execute(text(f'CREATE DATABASE "{TEST_DB_NAME}"')) + admin.dispose() + + command.upgrade(Config(str(APP_DIR / "alembic.ini")), "head") + yield + engine.dispose() + + +@pytest.fixture(autouse=True) +def clean_database(): + with engine.begin() as connection: + connection.execute(text("TRUNCATE users, sessions, chats, chat_members, messages")) + + +@pytest.fixture +def client(): + return TestClient(app) + + +def basic(username, password): + credential = base64.b64encode(f"{username}:{password}".encode()).decode() + return {"Authorization": "Basic " + credential} + + +def login(client, username, password=PASSWORD): + response = client.post("/api/v1/auth/sessions", headers=basic(username, password)) + assert response.status_code == 201 + return response.json() + + +def bearer(token): + return {"Authorization": "Bearer " + token} + + +def create_user(client, username): + """Регистрация + вход; заголовок авторизации — в поле "auth".""" + response = client.post("/api/v1/users", json={"username": username, "display_name": "Имя " + username, + "password": PASSWORD}) + assert response.status_code == 201 + user = response.json() + user["token"] = login(client, username)["token"] + user["auth"] = bearer(user["token"]) + return user + + +@pytest.fixture +def alice(client): + return create_user(client, "alice") + + +@pytest.fixture +def bob(client): + return create_user(client, "bob") + + +@pytest.fixture +def eve(client): + return create_user(client, "eve") + + +@pytest.fixture +def chat(client, alice, bob): + """Чат alice и bob; eve в него не входит.""" + response = client.post("/api/v1/chats", headers=alice["auth"], + json={"title": "Тестовый чат", "member_ids": [alice["id"], bob["id"]]}) + assert response.status_code == 201 + return response.json() + + +def assert_error(response, status_code, code): + assert response.status_code == status_code + body = response.json() + assert body["error"]["code"] == code + assert body["error"]["request_id"] == response.headers["X-Request-Id"] diff --git a/student-tests/test_auth_api.py b/student-tests/test_auth_api.py new file mode 100644 index 00000000..a3c7fda1 --- /dev/null +++ b/student-tests/test_auth_api.py @@ -0,0 +1,92 @@ +import time + +import jwt + +from conftest import PASSWORD, assert_error, basic, bearer, login +from core.config import settings + + +def assert_challenge(response, scheme): + assert response.headers["WWW-Authenticate"].startswith(scheme + ' realm="messenger"') + + +def test_login_returns_session(client, alice): + session = login(client, "alice") + assert session["token_type"] == "Bearer" + assert len(session["token"]) >= 32 + assert session["expires_at"].endswith("Z") + assert session["user"]["id"] == alice["id"] + assert "password" not in session["user"] and "password_hash" not in session["user"] + assert login(client, "alice")["token"] != session["token"] + + +def test_jwt_payload_contains_sub_exp_jti(client, alice): + payload = jwt.decode(alice["token"], options={"verify_signature": False}) + assert payload["sub"] == alice["id"] + assert payload["exp"] - payload["iat"] == settings.jwt.session_ttl_seconds + assert len(payload["jti"]) >= 43 + + +def test_wrong_password_and_unknown_user_give_same_401(client, alice): + wrong = client.post("/api/v1/auth/sessions", headers=basic("alice", "Wrong-password-1")) + unknown = client.post("/api/v1/auth/sessions", headers=basic("nobody", PASSWORD)) + for response in (wrong, unknown): + assert_error(response, 401, "unauthorized") + assert_challenge(response, "Basic") + assert 'charset="UTF-8"' in response.headers["WWW-Authenticate"] + assert wrong.json()["error"]["message"] == unknown.json()["error"]["message"] + + +def test_malformed_basic_returns_401(client): + for header in ("", "Basic", "Basic !!!not-base64!!!", "Bearer abc", "Basic " + "YWxpY2U="): # последний — без ':' + response = client.post("/api/v1/auth/sessions", headers={"Authorization": header}) + assert_error(response, 401, "unauthorized") + assert_challenge(response, "Basic") + + +def test_password_with_colon_and_unicode(client): + password = "пароль:с:двоеточиями 👋" + client.post("/api/v1/users", json={"username": "colon", "display_name": "C", "password": password}) + assert login(client, "colon", password)["user"]["username"] == "colon" + + +def test_protected_endpoint_requires_bearer(client, alice): + cases = [{}, basic("alice", PASSWORD), bearer("not-a-jwt"), {"Authorization": "Bearer"}] + for headers in cases: + response = client.get("/api/v1/users/me", headers=headers) + assert_error(response, 401, "unauthorized") + assert_challenge(response, "Bearer") + + +def test_x_user_id_does_not_override_token(client, alice, eve): + response = client.get("/api/v1/users/me", headers={**alice["auth"], "X-User-Id": eve["id"]}) + assert response.json()["id"] == alice["id"] + + +def test_forged_token_is_rejected(client, alice): + payload = jwt.decode(alice["token"], options={"verify_signature": False}) + forged = jwt.encode(payload, "attacker-key-attacker-key-attacker-key!!", algorithm="HS256") + assert_error(client.get("/api/v1/users/me", headers=bearer(forged)), 401, "unauthorized") + unsigned = jwt.encode(payload, None, algorithm="none") + assert_error(client.get("/api/v1/users/me", headers=bearer(unsigned)), 401, "unauthorized") + + +def test_logout_revokes_only_current_token(client, alice): + second = login(client, "alice")["token"] + response = client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]) + assert response.status_code == 204 + assert response.content == b"" + assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized") + assert_error(client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]), 401, "unauthorized") + # Другая сессия того же пользователя продолжает работать. + assert client.get("/api/v1/users/me", headers=bearer(second)).status_code == 200 + + +def test_session_expires(client, alice, monkeypatch): + monkeypatch.setattr(settings.jwt, "session_ttl_seconds", 1) + token = login(client, "alice")["token"] + assert client.get("/api/v1/users/me", headers=bearer(token)).status_code == 200 + time.sleep(2.1) + response = client.get("/api/v1/users/me", headers=bearer(token)) + assert_error(response, 401, "unauthorized") + assert_challenge(response, "Bearer") diff --git a/student-tests/test_chats_api.py b/student-tests/test_chats_api.py new file mode 100644 index 00000000..7296617a --- /dev/null +++ b/student-tests/test_chats_api.py @@ -0,0 +1,54 @@ +import uuid + +from sqlalchemy import text + +from conftest import assert_error +from core.db import engine + + +def count_rows(table): + with engine.connect() as connection: + return connection.scalar(text(f"SELECT count(*) FROM {table}")) + + +def test_unknown_member_returns_400_and_nothing_is_saved(client, alice): + response = client.post("/api/v1/chats", headers=alice["auth"], + json={"title": "С призраком", "member_ids": [alice["id"], str(uuid.uuid4())]}) + assert_error(response, 400, "invalid_request") + assert count_rows("chats") == 0 + assert count_rows("chat_members") == 0 + + +def test_created_chat_is_stored_with_members(client, chat, alice, bob): + assert sorted(chat["member_ids"]) == sorted([alice["id"], bob["id"]]) + assert count_rows("chats") == 1 + assert count_rows("chat_members") == 2 + again = client.get("/api/v1/chats/" + chat["id"], headers=bob["auth"]).json() + assert again == chat + + +def test_foreign_chat_returns_404(client, chat, eve): + headers = eve["auth"] + path = "/api/v1/chats/" + chat["id"] + + assert_error(client.get(path, headers=headers), 404, "not_found") + assert_error(client.get(path + "/messages", headers=headers), 404, "not_found") + assert_error(client.post(path + "/messages", headers=headers, json={"text": "чужое"}), 404, "not_found") + assert client.get("/api/v1/chats", headers=headers).json()["items"] == [] + + +def test_member_sees_chat(client, chat, bob): + response = client.get("/api/v1/chats", headers=bob["auth"]) + assert [c["id"] for c in response.json()["items"]] == [chat["id"]] + + +def test_creator_must_be_member(client, alice, bob): + response = client.post("/api/v1/chats", headers=alice["auth"], + json={"title": "Без меня", "member_ids": [bob["id"]]}) + assert_error(response, 400, "invalid_request") + + +def test_duplicate_members_return_400(client, alice): + response = client.post("/api/v1/chats", headers=alice["auth"], + json={"title": "Дубли", "member_ids": [alice["id"], alice["id"]]}) + assert_error(response, 400, "invalid_request") diff --git a/student-tests/test_messages_api.py b/student-tests/test_messages_api.py new file mode 100644 index 00000000..c7346699 --- /dev/null +++ b/student-tests/test_messages_api.py @@ -0,0 +1,66 @@ +from conftest import assert_error + + +def test_empty_message_returns_400(client, chat, alice): + path = "/api/v1/chats/" + chat["id"] + "/messages" + headers = alice["auth"] + + assert_error(client.post(path, headers=headers, json={"text": ""}), 400, "invalid_request") + assert_error(client.post(path, headers=headers, json={"text": " \n\t"}), 400, "invalid_request") + + +def test_sender_is_taken_from_token(client, chat, alice, bob): + path = "/api/v1/chats/" + chat["id"] + "/messages" + response = client.post(path, headers=bob["auth"], json={"text": "Привет 👋"}) + assert response.status_code == 201 + assert response.json()["sender_id"] == bob["id"] + assert response.json()["text"] == "Привет 👋" + + spoof = client.post(path, headers=bob["auth"], json={"text": "x", "sender_id": alice["id"]}) + assert_error(spoof, 400, "invalid_request") + + +def test_pagination_over_several_pages(client, chat, alice): + path = "/api/v1/chats/" + chat["id"] + "/messages" + headers = alice["auth"] + sent = [client.post(path, headers=headers, json={"text": f"сообщение {i}"}).json() for i in range(7)] + + received = [] + pages = 0 + cursor = None + while True: + params = {"limit": 3} + if cursor: + params["cursor"] = cursor + page = client.get(path, headers=headers, params=params).json() + received += page["items"] + pages += 1 + cursor = page["next_cursor"] + if cursor is None: + break + + assert pages == 3 # 3 + 3 + 1 + assert received == sent # тот же порядок, ничего не потеряно + assert len({m["id"] for m in received}) == 7 # без повторов + + +def test_cursor_from_another_chat_returns_400(client, chat, alice): + headers = alice["auth"] + path = "/api/v1/chats/" + chat["id"] + "/messages" + for i in range(2): + client.post(path, headers=headers, json={"text": f"m{i}"}) + cursor = client.get(path, headers=headers, params={"limit": 1}).json()["next_cursor"] + + other = client.post("/api/v1/chats", headers=headers, json={"title": "Другой", "member_ids": [alice["id"]]}).json() + response = client.get("/api/v1/chats/" + other["id"] + "/messages", headers=headers, params={"cursor": cursor}) + assert_error(response, 400, "invalid_request") + + response = client.get(path, headers=headers, params={"cursor": "мусор"}) + assert_error(response, 400, "invalid_request") + + +def test_invalid_limit_returns_400(client, chat, alice): + path = "/api/v1/chats/" + chat["id"] + "/messages" + for limit in (0, 101, "abc"): + response = client.get(path, headers=alice["auth"], params={"limit": limit}) + assert_error(response, 400, "invalid_request") diff --git a/student-tests/test_users_api.py b/student-tests/test_users_api.py new file mode 100644 index 00000000..8593c408 --- /dev/null +++ b/student-tests/test_users_api.py @@ -0,0 +1,69 @@ +import uuid + +from sqlalchemy import text + +from conftest import PASSWORD, assert_error +from core.db import engine + + +def test_invalid_json_returns_400(client): + response = client.post("/api/v1/users", content=b'{"username": "bob",', + headers={"Content-Type": "application/json"}) + assert_error(response, 400, "invalid_request") + + +def test_extra_field_and_wrong_type_return_400(client): + response = client.post("/api/v1/users", json={"username": "bob", "display_name": "Bob", "password": PASSWORD, + "admin": True}) + assert_error(response, 400, "invalid_request") + response = client.post("/api/v1/users", json={"username": "bob", "display_name": 123, "password": PASSWORD}) + assert_error(response, 400, "invalid_request") + + +def test_duplicate_username_returns_409(client, alice): + response = client.post("/api/v1/users", json={"username": "alice", "display_name": "Другая Алиса", + "password": PASSWORD}) + assert_error(response, 409, "conflict") + + +def test_unicode_display_name_is_kept(client): + response = client.post("/api/v1/users", json={"username": "uni", "display_name": "Алиса 👋", + "password": PASSWORD}) + assert response.status_code == 201 + assert response.json()["display_name"] == "Алиса 👋" + + +def test_password_is_required_and_length_checked(client): + for password in (None, "short", "x" * 129): + body = {"username": "pwd", "display_name": "P"} + if password is not None: + body["password"] = password + assert_error(client.post("/api/v1/users", json=body), 400, "invalid_request") + # 12 символов (не байт) — допустимо. + response = client.post("/api/v1/users", json={"username": "pwd", "display_name": "P", "password": "пароль123456"}) + assert response.status_code == 201 + + +def test_password_is_hashed_and_never_returned(client, alice): + assert "password" not in alice and "password_hash" not in alice + with engine.connect() as connection: + stored = connection.scalar(text("SELECT password_hash FROM users WHERE username = 'alice'")) + assert stored.startswith("$argon2id$") + assert PASSWORD not in stored + + +def test_me_returns_current_user(client, alice): + response = client.get("/api/v1/users/me", headers=alice["auth"]) + assert response.status_code == 200 + assert response.json() == {key: alice[key] for key in ("id", "username", "display_name", "created_at")} + + +def test_x_user_id_no_longer_authenticates(client, alice): + assert_error(client.get("/api/v1/users/me", headers={"X-User-Id": alice["id"]}), 401, "unauthorized") + assert_error(client.get("/api/v1/users/me", headers={"X-User-Id": str(uuid.uuid4())}), 401, "unauthorized") + + +def test_every_response_has_request_id(client): + assert client.get("/health/live").headers["X-Request-Id"] + assert client.get("/health/ready").headers["X-Request-Id"] + assert_error(client.get("/no/such/path"), 404, "not_found") -- 2.54.0 From 5ce43c33159f68eb11abb1e808406978245eb972 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D1=8F=D0=BA=D0=B8=D1=88=D0=B5=D0=B2=20=D0=92=D0=BB?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D1=81=D0=BB=D0=B0=D0=B2?= Date: Wed, 21 Oct 2026 10:46:20 +0300 Subject: [PATCH 2/3] =?UTF-8?q?=D0=92=D1=85=D0=BE=D0=B4:=20=D0=BE=D1=82?= =?UTF-8?q?=D0=BA=D0=BB=D0=BE=D0=BD=D1=8F=D1=82=D1=8C=20POST=20/auth/sessi?= =?UTF-8?q?ons=20=D1=81=20=D1=82=D0=B5=D0=BB=D0=BE=D0=BC=20(400)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Контракт задаёт вход без тела; раньше лишний JSON игнорировался, и запрос с правильным Basic создавал сессию. Добавлен отрицательный тест. --- app/api/dependencies.py | 6 ++++++ app/api/v1/auth_rout.py | 5 +++-- student-tests/test_auth_api.py | 14 ++++++++++++++ 3 files changed, 23 insertions(+), 2 deletions(-) diff --git a/app/api/dependencies.py b/app/api/dependencies.py index 5cbbbba1..79777b4e 100644 --- a/app/api/dependencies.py +++ b/app/api/dependencies.py @@ -26,6 +26,12 @@ basic_scheme = RawBasicHeader(scheme_name="basicAuth", auto_error=False) bearer_scheme = RawBearerHeader(scheme_name="bearerAuth", auto_error=False) +async def require_empty_body(request: Request) -> None: + # Контракт задаёт вход без тела: лишний JSON не игнорируем молча, а отклоняем. + if await request.body(): + raise HTTPException(status_code=400, detail="Тело запроса не допускается") + + def unauthorized() -> HTTPException: return HTTPException(status_code=401, detail="Нужен действительный Bearer-токен", headers=BEARER_CHALLENGE) diff --git a/app/api/v1/auth_rout.py b/app/api/v1/auth_rout.py index bce0828e..89e1abbc 100644 --- a/app/api/v1/auth_rout.py +++ b/app/api/v1/auth_rout.py @@ -4,7 +4,7 @@ import binascii from fastapi import APIRouter, Depends, HTTPException, Response, Security from sqlalchemy.orm import Session -from api.dependencies import basic_scheme, get_current_session +from api.dependencies import basic_scheme, get_current_session, require_empty_body from core.config import settings from core.db import get_db from core.logger import logger @@ -43,7 +43,8 @@ def parse_basic(authorization: str | None) -> tuple[str, str]: return username, password -@roter.post("/sessions", status_code=201, response_model=SessionResponse) +# Тело проверяется до пароля: зависимости маршрута выполняются раньше параметров. +@roter.post("/sessions", status_code=201, response_model=SessionResponse, dependencies=[Depends(require_empty_body)]) def create_session_api(authorization: str | None = Security(basic_scheme), db: Session = Depends(get_db)): username, password = parse_basic(authorization) diff --git a/student-tests/test_auth_api.py b/student-tests/test_auth_api.py index a3c7fda1..1c91a857 100644 --- a/student-tests/test_auth_api.py +++ b/student-tests/test_auth_api.py @@ -1,9 +1,11 @@ import time import jwt +from sqlalchemy import text from conftest import PASSWORD, assert_error, basic, bearer, login from core.config import settings +from core.db import engine def assert_challenge(response, scheme): @@ -44,6 +46,18 @@ def test_malformed_basic_returns_401(client): assert_challenge(response, "Basic") +def test_login_with_body_returns_400_and_creates_no_session(client, alice): + with engine.connect() as connection: + before = connection.scalar(text("SELECT count(*) FROM sessions")) + for kwargs in ({"json": {"unexpected": True}}, {"json": {}}, {"content": b"x"}): + response = client.post("/api/v1/auth/sessions", headers=basic("alice", PASSWORD), **kwargs) + assert_error(response, 400, "invalid_request") + with engine.connect() as connection: + assert connection.scalar(text("SELECT count(*) FROM sessions")) == before + # Без тела вход по-прежнему работает. + assert login(client, "alice")["user"]["id"] == alice["id"] + + def test_password_with_colon_and_unicode(client): password = "пароль:с:двоеточиями 👋" client.post("/api/v1/users", json={"username": "colon", "display_name": "C", "password": password}) -- 2.54.0 From ac1317d22e4441383bd1212dc98a3e4f11c80184 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=9C=D1=8F=D0=BA=D0=B8=D1=88=D0=B5=D0=B2=20=D0=92=D0=BB?= =?UTF-8?q?=D0=B0=D0=B4=D0=B8=D1=81=D0=BB=D0=B0=D0=B2?= Date: Thu, 29 Oct 2026 15:42:37 +0300 Subject: [PATCH 3/3] =?UTF-8?q?=D0=9B=D0=A02=20=D0=BD=D0=B0=205:=20Redis-?= =?UTF-8?q?=D0=BA=D1=8D=D1=88=20=D1=81=D0=B5=D1=81=D1=81=D0=B8=D0=B9,=20?= =?UTF-8?q?=D0=BE=D1=82=D0=BA=D0=B0=D0=B7=D0=BE=D1=83=D1=81=D1=82=D0=BE?= =?UTF-8?q?=D0=B9=D1=87=D0=B8=D0=B2=D0=BE=D1=81=D1=82=D1=8C,=20=D1=82?= =?UTF-8?q?=D1=80=D0=B5=D0=BA=202=20(=D0=B8=D0=BD=D0=B4=D0=B5=D0=BA=D1=81?= =?UTF-8?q?=D1=8B=20=D0=B8=20=D0=B2=D0=BE=D1=81=D1=81=D1=82=D0=B0=D0=BD?= =?UTF-8?q?=D0=BE=D0=B2=D0=BB=D0=B5=D0=BD=D0=B8=D0=B5)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Уровень 4: - Redis как кэш сессий (cache-aside, источник истины — PostgreSQL): TTL <= остатка сессии, метка revoked при logout + SET NX против гонки, при отказе Redis — работа через базу и фоновая проверка доступности - тесты: гонка регистрации, откат посреди транзакции, недоступность БД и Redis (44 теста) - EXPLAIN (ANALYZE, BUFFERS) на 22 000 сообщений, history_query общий для API и скрипта - эксперименты отказа Redis/PostgreSQL под нагрузкой; dns_opt у API, чтобы отказ БД давал быстрый 503, а не зависание на поиске имени остановленного контейнера Уровень 5, трек 2: - 105 000 сообщений в неравномерных чатах, 4 варианта индекса + OFFSET против keyset, стоимость записи (время, WAL), два независимых прогона - pg_dump -> pg_restore в новый контейнер -> сверка md5 всех таблиц и выборки сообщений, RTO 14 с, демонстрация RPO --- .env.example | 12 +- REPORT.md | 211 ++++++++-- app/api/dependencies.py | 12 +- app/api/health.py | 3 +- app/api/v1/auth_rout.py | 7 + app/core/config.py | 19 + app/core/redis_client.py | 99 +++++ app/database_functions/messages_functions.py | 11 +- app/database_functions/sessions_cache.py | 68 ++++ app/main.py | 4 +- compose.yaml | 36 ++ evidence/explain-history.txt | 90 ++++ evidence/failure-postgres-before-dns-fix.json | 84 ++++ evidence/failure-postgres.json | 82 ++++ evidence/failure-redis.json | 82 ++++ evidence/persistence.txt | 31 +- evidence/pytest.txt | 57 +++ evidence/smoke.txt | 7 + evidence/track2-backup-restore.json | 62 +++ evidence/track2-indexes-run1.json | 385 ++++++++++++++++++ evidence/track2-indexes-run1.md | 34 ++ evidence/track2-indexes-run2.json | 385 ++++++++++++++++++ evidence/track2-indexes-run2.md | 34 ++ evidence/track2-plans.txt | 77 ++++ requirements.txt | 1 + scripts/explain_history.py | 161 ++++++++ scripts/failure_experiment.py | 154 +++++++ scripts/init-secrets.ps1 | 1 + scripts/init-secrets.sh | 1 + scripts/restart.cmd | 2 +- scripts/restart.sh | 6 +- scripts/track2_backup_restore.py | 215 ++++++++++ scripts/track2_indexes.py | 314 ++++++++++++++ student-tests/conftest.py | 6 + student-tests/test_failures_api.py | 99 +++++ student-tests/test_session_cache.py | 142 +++++++ 36 files changed, 2932 insertions(+), 62 deletions(-) create mode 100644 app/core/redis_client.py create mode 100644 app/database_functions/sessions_cache.py create mode 100644 evidence/explain-history.txt create mode 100644 evidence/failure-postgres-before-dns-fix.json create mode 100644 evidence/failure-postgres.json create mode 100644 evidence/failure-redis.json create mode 100644 evidence/pytest.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/track2-backup-restore.json create mode 100644 evidence/track2-indexes-run1.json create mode 100644 evidence/track2-indexes-run1.md create mode 100644 evidence/track2-indexes-run2.json create mode 100644 evidence/track2-indexes-run2.md create mode 100644 evidence/track2-plans.txt create mode 100644 scripts/explain_history.py create mode 100644 scripts/failure_experiment.py create mode 100644 scripts/track2_backup_restore.py create mode 100644 scripts/track2_indexes.py create mode 100644 student-tests/test_failures_api.py create mode 100644 student-tests/test_session_cache.py diff --git a/.env.example b/.env.example index cb58e6a7..0b148633 100644 --- a/.env.example +++ b/.env.example @@ -2,7 +2,8 @@ # Names follow pydantic-settings: prefix APP_CONFIG__, nesting via "__" (see app/core/config.py). # Mapping to the skeleton's logical names: APP_HOST -> APP_CONFIG__RUN__HOST, APP_PORT -> APP_CONFIG__RUN__PORT, # DATABASE_URL_FILE -> APP_CONFIG__DB__* (host/port/name/user + password file), -# SESSION_TTL_SECONDS -> APP_CONFIG__JWT__SESSION_TTL_SECONDS, SESSION_STORE=postgres (sessions table). +# SESSION_TTL_SECONDS -> APP_CONFIG__JWT__SESSION_TTL_SECONDS, SESSION_STORE=postgres (sessions table), +# CACHE_URL_FILE -> APP_CONFIG__REDIS__HOST/PORT + APP_CONFIG__REDIS__PASSWORD_FILE (Redis = session cache). APP_CONFIG__RUN__HOST=0.0.0.0 APP_CONFIG__RUN__PORT=8080 APP_CONFIG__LOGGING__LEVEL=INFO @@ -20,5 +21,12 @@ APP_CONFIG__DB__PASSWORD_FILE=secrets/postgres_password APP_CONFIG__JWT__SECRET_FILE=secrets/jwt_secret APP_CONFIG__JWT__SESSION_TTL_SECONDS=3600 -# Used by compose.yaml: host port for PostgreSQL (bound to 127.0.0.1 only). +# Redis: cache of sessions (source of truth stays in PostgreSQL). Values for running from the venv; +# inside Compose the defaults (host=redis, /run/secrets/redis_password) are used. +APP_CONFIG__REDIS__HOST=127.0.0.1 +APP_CONFIG__REDIS__PORT=6379 +APP_CONFIG__REDIS__PASSWORD_FILE=secrets/redis_password + +# Used by compose.yaml: host ports for PostgreSQL and Redis (bound to 127.0.0.1 only). POSTGRES_HOST_PORT=5432 +REDIS_HOST_PORT=6379 diff --git a/REPORT.md b/REPORT.md index 84be683b..afd91de2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,73 +1,220 @@ # Отчёт — лабораторная 2 - Автор, группа: Мякишев Владислав, БПИ2302 -- Целевая оценка: 3 -- Commit/PR: TODO после публикации -- Источники и библиотеки: FastAPI, SQLAlchemy 2.1 (ORM), Alembic, psycopg 3, argon2-cffi, PyJWT; документация PostgreSQL, Alembic, RFC 7617. При разработке использовался ИИ-ассистент (Claude). +- Целевая оценка: **5**, трек 2 «План запроса и восстановление» +- Commit/PR: ветка `solution/bpi2302-myakishev`; ссылка на PR — после публикации +- Источники и библиотеки: FastAPI, SQLAlchemy 2.1 (ORM), Alembic, psycopg 3, argon2-cffi, PyJWT, redis-py 8; PostgreSQL 17, Redis 8.6; документация PostgreSQL (EXPLAIN, индексы), Alembic, Redis (`SET NX EX`), RFC 7617, resolv.conf(5). При разработке использовался ИИ-ассистент (Claude); запуски и измерения выполнены на стенде автора, числа взяты из файлов в `evidence/`. + +Проверки выполнены 2026-10-29 на одной машине: AMD Ryzen 5 5500U (12 логических CPU), Windows 11, Docker Desktop 29.8 (WSL2), Compose 5.5, Python 3.14. ## Запуск из чистого clone -Нужно: Docker с Compose v2, Python 3.9+ (для тестов). Образы: `postgres:17.10-alpine`, `python:3.14.3-slim` (закреплены digest в `compose.yaml`/`Dockerfile`). +Нужно: Docker с Compose v2, Python 3.9+ (для тестов). Образы закреплены digest: `postgres:17.10-alpine`, `redis:8.6.8-alpine`, `python:3.14.3-slim`. На Windows для Python-скриптов задайте `PYTHONUTF8=1`. ```sh -sh scripts/init-secrets.sh # Windows: powershell -File scripts\init-secrets.ps1 -docker compose up -d --build --wait # postgres (healthy) -> migrate (exit 0) -> api (healthy) -make test # публичный smoke +sh scripts/init-secrets.sh # Windows: powershell -ExecutionPolicy Bypass -File scripts\init-secrets.ps1 +docker compose up -d --build --wait # postgres + redis (healthy) -> migrate (exit 0) -> api (healthy) +make test # публичный smoke (= python tests/smoke.py) chmod +x scripts/restart.sh make test-persistence ACTION_SCRIPT=scripts/restart.sh ``` -- `init-secrets` создаёт `secrets/postgres_password`, `secrets/jwt_secret` (случайные, не выводятся, вне Git) и `.env` из `.env.example`. +- `init-secrets` создаёт `secrets/postgres_password`, `secrets/jwt_secret`, `secrets/redis_password` (случайные, не выводятся, вне Git) и `.env` из `.env.example`. Существующие файлы не перезаписываются. - Миграции применяет разовый сервис `migrate` (`alembic upgrade head`) при каждом `up`; повторный запуск ничего не меняет. - Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных: `docker compose down -v`. -- Свои тесты (нужен запущенный `postgres`, используют отдельную базу `messenger_test`): +- Свои тесты (нужны запущенные `postgres` и `redis`; используют базу `messenger_test` и Redis-базу 15): `python -m venv .venv && .venv/bin/pip install -r requirements-test.txt && .venv/bin/python -m pytest` -- На Windows тест сохранности: `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` (`restart.cmd` — те же команды, что `restart.sh`). +- На Windows тест сохранности: `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd`. +- Эксперименты уровня 4 (из venv при запущенном стенде): + `python scripts/explain_history.py` (EXPLAIN на ≥10 000 сообщений), `python scripts/failure_experiment.py redis`, `python scripts/failure_experiment.py postgres`. +- Трек 2 (из venv при запущенном `postgres`; работает в отдельной базе `messenger_bench`, рабочие данные не трогает): + `python scripts/track2_indexes.py --rebuild` (≈3 мин), затем `python scripts/track2_backup_restore.py` (≈1 мин; дамп пишется в `backups/`, вне Git; временный контейнер восстановления удаляется). ## Архитектура и решения -Клиент → API (FastAPI, `api`) → PostgreSQL 17 (`postgres`, volume `postgres_data`). PostgreSQL — источник истины для пользователей, чатов, участников, сообщений и сессий (`SESSION_STORE=postgres`). +Клиент → API (FastAPI, `api`) → PostgreSQL 17 (`postgres`, volume `postgres_data`) — источник истины; Redis 8.6 (`redis`) — кэш сессий. | Роль | Сервис | Готовность | Хранилище | Порт | Credentials | | --- | --- | --- | --- | --- | --- | | база | `postgres` | `pg_isready` | volume `postgres_data` | 127.0.0.1:5432 | secret `postgres_password` | +| кэш сессий | `redis` | `redis-cli ping` | нет (persistence выключен, это кэш) | 127.0.0.1:6379 (только для pytest) | secret `redis_password` (`requirepass`) | | миграции | `migrate` | exit 0 | — | — | secret `postgres_password` | -| API | `api` | `/health/live` (Docker), `/health/ready` (проверяет БД) | нет | 127.0.0.1:8080 | secrets `postgres_password`, `jwt_secret` | +| API | `api` | `/health/live` (Docker), `/health/ready` (проверяет БД; Redis намеренно не входит) | нет | 127.0.0.1:8080 | secrets `postgres_password`, `jwt_secret`, `redis_password` | - **Схема** (миграция `0001`): `users` (UNIQUE username, CHECK формата), `sessions` (PK = SHA-256 токена, `expires_at`), `chats`, `chat_members` (PK `(chat_id, user_id)`), `messages` (составной FK `(chat_id, sender_id)` → `chat_members`, индекс `(chat_id, created_at, id)` для keyset-пагинации). -- **Транзакции:** создание чата — одна транзакция (чат + все участники); 201 возвращается только после COMMIT. Дубль username отсекается ограничением `users_username_key` → 409. -- **Аутентификация:** регистрация с паролем (Argon2id). `POST /auth/sessions` принимает только Basic и выдаёт JWT (HS256, `sub`/`iat`/`exp`/`jti`, `jti` — 256 бит случайности). На сервере хранится сессия (хеш токена + срок). Bearer проверяется по подписи, `exp` и наличию сессии в БД; logout удаляет сессию. `X-User-Id` не читается. -- **Из lab1 перенесено:** весь API, формат ошибок, `X-Request-Id`, cursor-пагинация, Dockerfile. **Изменено:** хранилище в памяти → PostgreSQL (`app/models`, `app/database_functions`), X-User-Id → Basic/Bearer, добавлены Compose и миграции. -- **Переменные** (`.env.example` курса → наши): `APP_HOST/APP_PORT` → `APP_CONFIG__RUN__HOST/PORT`; `DATABASE_URL_FILE` → `APP_CONFIG__DB__HOST/PORT/NAME/USER` + `APP_CONFIG__DB__PASSWORD_FILE`; `SESSION_TTL_SECONDS` → `APP_CONFIG__JWT__SESSION_TTL_SECONDS` (3600). +- **Транзакции:** создание чата — одна транзакция (чат + все участники); 201 возвращается только после COMMIT. Дубль username отсекается ограничением `users_username_key` → 409 (в том числе при гонке: проверяет сама БД). +- **Аутентификация:** регистрация с паролем (Argon2id). `POST /auth/sessions` принимает только Basic (без тела) и выдаёт JWT (HS256, `sub`/`iat`/`exp`/`jti`, `jti` — 256 бит случайности). На сервере хранится сессия (хеш токена + срок). Bearer проверяется по подписи и `exp`, затем по кэшу или таблице `sessions`; logout удаляет сессию. `X-User-Id` не читается. + +### Redis: кэш сессий (cache-aside) + +| | Решение | +| --- | --- | +| Источник истины | таблица `sessions` в PostgreSQL. Redis хранит только копию, поэтому persistence Redis выключен (`--save "" --appendonly no`): рестарт или отказ Redis не теряет ни одной сессии | +| Что в Redis | ключ `session:` → JSON: `user_id`, `username`, `display_name`, `user_created_at`, `expires_at`. Ни токена, ни хеша пароля. Профиль кэшировать безопасно: по контракту пользователя нельзя изменить или удалить | +| Когда пишем | при входе (после COMMIT) и при промахе (прочитали из базы → положили). Запрос с действующим токеном не делает SQL к `sessions`/`users` | +| Expiry | TTL записи = `min(остаток жизни сессии, 300 с)`: кэш никогда не переживает сессию; JWT `exp` проверяется отдельно | +| Инвалидация | logout: `DELETE` в базе, затем в тот же ключ пишется метка `revoked` на весь остаток жизни сессии. Запись из базы кладётся только `SET NX`, поэтому медленный запрос, прочитавший сессию до logout, не может вернуть её в кэш (тест `test_slow_reader_cannot_resurrect_session_after_logout`) | +| Отказ Redis | таймаут 0.25 с, без встроенных повторов; ошибка = промах, запрос идёт в базу. После первой ошибки запросы Redis не трогают, доступность проверяет фоновый поток раз в 5 с, затем кэш включается сам | +| Память | `maxmemory 64mb`, `volatile-ttl` (вытесняются ключи с наименьшим остатком TTL) | + +### Пул, таймауты, запросы + +- Все запросы через SQLAlchemy ORM/Core с параметрами (без конкатенации SQL). +- Пул: `pool_size=5`, `max_overflow=5`, `pool_timeout=5 с`, `pool_pre_ping` (переживает рестарт БД без рестарта API); `connect_timeout=3 с`; `statement_timeout=5000 мс` на сессию PostgreSQL. Ошибки БД, исчерпание пула и таймауты → `503 unavailable` без подробностей. +- `dns_opt: timeout:1 attempts:1` у API: имя остановленного контейнера резолвер по умолчанию искал **8 с** (этот этап не покрывается `connect_timeout`), запрос висел вместо быстрого 503. С опцией — 1 с (замер в разделе экспериментов). + +**Из lab1 перенесено:** весь API, формат ошибок, `X-Request-Id`, cursor-пагинация, Dockerfile. **Изменено в lab2:** хранилище в памяти → PostgreSQL, X-User-Id → Basic/Bearer, Compose и миграции; на уровень 4 — Redis-кэш сессий, `history_query` (общий для API и EXPLAIN), `dns_opt`, новые тесты и скрипты экспериментов. + +**Переменные** (`.env.example` курса → наши): `APP_HOST/APP_PORT` → `APP_CONFIG__RUN__HOST/PORT`; `DATABASE_URL_FILE` → `APP_CONFIG__DB__HOST/PORT/NAME/USER` + `APP_CONFIG__DB__PASSWORD_FILE`; `SESSION_TTL_SECONDS` → `APP_CONFIG__JWT__SESSION_TTL_SECONDS` (3600); `SESSION_STORE=postgres` (+ Redis как кэш); `CACHE_URL_FILE` → `APP_CONFIG__REDIS__HOST/PORT` + `APP_CONFIG__REDIS__PASSWORD_FILE`. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | `make test` против стенда в Compose | `PASS: lab2 public API scenario` | вывод команды | -| Данные и действующие сессии переживают рестарт API и БД без удаления volumes | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (на Windows — `restart.cmd`) | `PASS: persistence preserved confirmed data and existing session`; у `api` и `postgres` новый StartedAt при тех же id контейнеров и том же volume | `evidence/persistence.txt` | -| Таблицы, PK/FK, UNIQUE username, миграции с нуля | `alembic downgrade base` → `alembic upgrade head`; `alembic check` | схема создаётся заново; `No new upgrade operations detected` | `app/migrations/versions/0001_initial_schema.py` | -| Повторные миграции без дублей | `docker compose up` при существующей схеме | `migrate` завершается с кодом 0 без `Running upgrade`, данные не меняются | `docker compose logs migrate` | -| Атомарное создание чата | `pytest student-tests/test_chats_api.py` | при неизвестном участнике — 400 и 0 строк в `chats`/`chat_members` | `student-tests/test_chats_api.py` | -| Basic только на входе, Bearer, expiry, logout, X-User-Id не работает | `pytest student-tests/test_auth_api.py` + smoke | 401 с корректным `WWW-Authenticate`; токен после logout и после TTL → 401 | `student-tests/test_auth_api.py` | -| Пароли — password KDF | `pytest student-tests/test_users_api.py` | в БД `$argon2id$…`, в ответах пароля нет | `student-tests/test_users_api.py` | -| Секреты/volumes вне Git | `git status --ignored` | `.env`, `secrets/` в игноре | `.gitignore` | -| Свои тесты | `python -m pytest` | `30 passed` | `student-tests/` | - -Проверка истечения на стенде: `APP_CONFIG__JWT__SESSION_TTL_SECONDS=2 docker compose up -d --wait api` → войти, подождать 3 с → запрос с токеном даёт 401. Вернуть: `docker compose up -d --wait api`. +| Публичный smoke | `make test` против стенда в Compose | `PASS: lab2 public API scenario`; `check_contract` PASS | `evidence/smoke.txt` | +| 3: данные и сессии переживают рестарт API и всех хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (Windows — `restart.cmd`; перезапускает api, postgres, redis) | `PASS`; новые StartedAt у api, postgres, redis; volume тот же (создан 2026-10-15); прежний токен работает (Redis пуст → сессия из PostgreSQL) | `evidence/persistence.txt` | +| 3: таблицы, PK/FK, UNIQUE username, миграции с нуля и повторно | `alembic downgrade base` → `upgrade head`; `alembic check`; `docker compose up` при существующей схеме | схема создаётся заново; `migrate` завершается 0 без `Running upgrade` | `app/migrations/versions/0001_initial_schema.py` | +| 3: Basic только на входе, Bearer, expiry, logout, X-User-Id не работает, KDF | `pytest student-tests/test_auth_api.py test_users_api.py` + smoke | 401 с корректным `WWW-Authenticate`; токен после logout и после TTL → 401; в БД `$argon2id$…` | `evidence/pytest.txt` | +| 4: Redis реально используется для сессий с TTL; источник истины, expiry, инвалидация описаны | раздел «Redis» выше; `pytest student-tests/test_session_cache.py` (9 тестов) | вход кладёт запись без секретов, TTL ≤ min(сессия, 300 с); запрос с токеном идёт без SQL; промах → 1 чтение из базы и снова кэш; logout → `revoked` → 401; гонка «воскрешения» закрыта; отозванный токен не кэшируется | `evidence/pytest.txt` | +| 4: параметризованные запросы, ограниченный пул, таймауты | код `core/db.py`, `core/config.py` | пул 5+5, `pool_timeout` 5 с, `connect_timeout` 3 с, `statement_timeout` 5 с, Redis 0.25 с | `app/core/` | +| 4: гонка регистрации одного username | `test_parallel_registration_of_same_username_creates_one_user` | 12 параллельных регистраций: ровно 1 × 201, 11 × 409 `conflict`, 1 строка в `users` | `evidence/pytest.txt` | +| 4: rollback составной операции | `test_chat_creation_rolls_back_when_member_insert_fails` (+ `test_unknown_member_returns_400_and_nothing_is_saved`) | проверка участников «проходит», INSERT `chats` выполнен, INSERT `chat_members` падает на FK → 400, в `chats` и `chat_members` 0 строк | `evidence/pytest.txt` | +| 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщений, нет полного скана на страницу | `python scripts/explain_history.py` | 22 024 сообщения (чат 12 000 + 20 × 500): первая, средняя и последняя страница — `Index Scan using messages_chat_history_idx`, 5 буферов, 0.24–0.28 мс, 0 отфильтрованных строк; для сравнения OFFSET до той же глубины — `Seq Scan`, 296 буферов, 12.9 мс | `evidence/explain-history.txt` | +| 4: автотесты expiry (короткий TTL), logout, неверного пароля | `test_session_expires`, `test_logout_revokes_only_current_token`, `test_wrong_password_and_unknown_user_give_same_401` | PASS | `evidence/pytest.txt` | +| 4: автотест недоступности Redis | `test_redis_down_falls_back_to_database`, `test_redis_down_does_not_slow_every_request`, `test_cache_comes_back_after_redis_recovers` | вход, запросы и logout работают через базу; таймаут платится один раз; после возврата Redis кэш включается сам | `evidence/pytest.txt` | +| 4: автотест недоступности БД; аноним не доверенный | `test_database_down_gives_limited_503_and_no_anonymous_access`, `test_database_down_cached_session_still_authenticates` | `/health/live` 200, `/health/ready` и бизнес-запросы → 503 без деталей (нет драйвера, адреса, SQL); без токена и с поддельным → 401 | `evidence/pytest.txt` | +| 4: Redis с конкретной ролью + повтор эксперимента отказа | `python scripts/failure_experiment.py redis` / `postgres` | см. «Эксперименты»: без Redis 0 ошибок; без PostgreSQL — 503 ≤ 3.1 с, восстановление без рестарта API | `evidence/failure-redis.json`, `evidence/failure-postgres.json` | +| Свои тесты | `python -m pytest` | **44 passed** (31 прежний + 13 новых) | `evidence/pytest.txt` | +| 5, трек 2: ≥100 000 сообщений, неравномерные чаты; ≥2 индекса/запроса; стоимость записи | `python scripts/track2_indexes.py --rebuild` (2 независимых прогона) | 105 000 сообщений (60 000 / 5 000 / 300 / 20); 4 индекса + OFFSET против keyset; рабочий индекс 0.25–0.31 мс на любом чате и глубине, `chat_id` 28–84 мс на большом чате, OFFSET 263–300 мс; WAL/строку 671 → 820 (рабочий) → 1232 (покрывающий) | `evidence/track2-indexes-run1.*`, `track2-indexes-run2.*`, `track2-plans.txt` | +| 5, трек 2: backup → восстановление в новое хранилище → сверка; время восстановления и граница потерь | `python scripts/track2_backup_restore.py` | `pg_dump -Fc` 2.2 с, 6.5 МБ; новый контейнер + `pg_restore -j 4` = **RTO 14.0 с**; счётчики, md5 всех 6 таблиц и 36 выборочных сообщений совпали; 100 сообщений, записанных после дампа, в восстановленной базе отсутствуют | `evidence/track2-backup-restore.json` | +| Секреты/volumes вне Git | `git status --ignored` | `.env`, `secrets/` в игноре; в `evidence/` нет токенов | `.gitignore` | ## Эксперименты и отказы +Нагрузка `failure_experiment.py`: 4 потока по кругу делают `GET /users/me` (путь проверки сессии) и `POST` сообщения; таймаут клиента 5 с; сервис останавливается `docker compose stop` примерно через 5 с после старта и запускается через ~10 с. Клиент на той же машине; по одному прогону на сценарий. + +**Redis остановлен под нагрузкой** (`failure-redis.json`): + +| Фаза | `/users/me` | запись | p50 `/users/me` | +| --- | --- | --- | --- | +| до остановки (кэш) | 168 × 200 | 166 × 201 | 50 мс | +| Redis остановлен (сессии из PostgreSQL) | 299 × 200 | 300 × 201 | 64 мс | +| после запуска | 325 × 200 | 326 × 201 | 56 мс | + +0 ошибок; `/health/ready` всё время 200 (Redis не критичен); в логе API одно предупреждение «Redis недоступен…» и «Redis снова доступен» после запуска; кэш после рестарта пуст и снова заполняется (ключей до/после: 5/1 — заполнилась только используемая сессия). + +**Найдено и исправлено.** В первом прогоне 4 запроса (по одному на поток) повисли на 5 с: после паузы все потоки одновременно пробовали Redis, а разрешение DNS-имени остановленного контейнера не ограничено `socket_timeout`. Решение: после ошибки запросы Redis не трогают, проверяет фоновый поток → 0 ошибок. + +**PostgreSQL остановлен под нагрузкой** (`failure-postgres.json`): + +| Фаза | `/users/me` | запись | | +| --- | --- | --- | --- | +| до остановки | 163 × 200 | 162 × 201 | p50 записи 76 мс | +| БД остановлена | 65 × 200 (сессия из кэша) | 10 × 201 (до фактической остановки), **56 × 503** | 503 не дольше 3.1 с (`connect_timeout`) | +| после запуска | 496 × 200 | 492 × 201, 4 × 503 в первые 1.6 с | первая успешная запись через 1.4 с, без рестарта API | + +`/health/live` 200, `/health/ready` 503. Анонимные запросы и поддельные токены при этом получают 401 (автотест). Личность пользователя с действующей сессией подтверждается кэшем, но данные из базы недоступны → 503. + +**Найдено и исправлено.** До `dns_opt` из 56 неудачных записей 8 повисли дольше таймаута клиента 5 с (`failure-postgres-before-dns-fix.json`: 31 × 503 + 8 × timeout). Замер изнутри контейнера API: `getaddrinfo('postgres')` для остановленного контейнера — **8.0–8.1 с**, с `options timeout:1 attempts:1` — **1.0 с**; для запущенного — 0.00–0.12 с в обоих случаях. + | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| `scripts/restart.sh`: stop + up API и PostgreSQL | данные и сессии сохраняются | test-persistence PASS, тот же токен работает | ~22 с на весь сценарий; потерь нет | -| `docker compose stop postgres` при работающем API | `/health/ready` → 503, бизнес-запросы → 503 без деталей | 503 через ~3 с (connect_timeout); после `start` — 200 без рестарта API (`pool_pre_ping`) | несколько секунд; потерь нет | -| SIGTERM API (`docker compose stop api`) | корректное завершение | `Shutting down` → `Соединения с базой данных закрыты` → `Finished server process` | — | +| `restart.cmd`: stop + up API, PostgreSQL, Redis | данные и сессии сохраняются | persistence PASS, тот же токен работает | весь тест ~40 с; потерь нет | +| `docker compose stop redis` под нагрузкой | 0 ошибок, работа через базу | 0 ошибок из 599 запросов за время отказа | кэш включается сам ≤ 5 с после запуска; потерь нет | +| `docker compose stop postgres` под нагрузкой | быстрый 503 без деталей, без зависаний | 56 × 503 ≤ 3.1 с, 0 зависаний (после `dns_opt`) | 1.4 с после старта БД, без рестарта API; подтверждённые записи на месте | +| SIGTERM API (`docker compose stop api`) | корректное завершение | `Shutting down` → `Соединения с базой данных и Redis закрыты` → `Finished server process` | — | + +## Трек 2 (оценка «5»): план запроса и восстановление + +### Гипотезы + +- **H1.** С индексом `(chat_id, created_at, id)` стоимость страницы истории не зависит ни от размера чата, ни от глубины страницы. С индексом только по `chat_id` она растёт с размером чата (сортируется весь чат), без индекса — с размером всей таблицы. +- **H2.** Каждый индекс удорожает запись; покрывающий индекс с текстом — заметно сильнее остальных, а выигрыш на чтении у него мал. +- **H3.** OFFSET-пагинация дорожает с глубиной, keyset — нет. +- **H4.** `pg_dump` → `pg_restore` в пустой экземпляр воспроизводит данные точно (счётчики и содержимое). Время восстановления для 10⁵ сообщений меньше минуты. Всё, что записано после снимка, теряется: RPO равен интервалу между бэкапами. + +### Методика + +`scripts/track2_indexes.py` (повторяемая: фиксированный `setseed`, схема — миграциями Alembic, отдельная база `messenger_bench`): +1. Данные: 105 000 сообщений в чатах **неравномерного** размера: 1 × 60 000, 4 × 5 000, 50 × 300, 500 × 20. Отправитель — случайный участник, время — случайное за 30 дней (строки в куче не упорядочены по времени), текст 32–500 символов. 300 пользователей, 555 чатов. `VACUUM ANALYZE`. +2. Четыре варианта (каждый раз единственный вторичный индекс на `messages`): + - `none` — без индекса; + - `chat_id`; + - `chat_created_id` — рабочий `(chat_id, created_at, id)`; + - `covering` — `(chat_id, created_at, id) INCLUDE (sender_id, text)`. +3. **Чтение:** ровно SQL API (`history_query()`, общий для API и скрипта) по самому большому чату каждого класса; первая и «глубокая» (90% истории) страница. 3 прогрева + 15 замеров `EXPLAIN (ANALYZE, TIMING OFF, BUFFERS)`, медиана. Для рабочего индекса дополнительно OFFSET на той же глубине. +4. **Запись:** `INSERT` 20 000 строк одной транзакцией (3 повтора, медиана) и 1 000 одиночных `INSERT` + `COMMIT`, как в API. Время и объём WAL (`pg_wal_lsn_diff`); затем `DELETE` + `VACUUM`. +5. Весь скрипт прогнан **дважды** с пересозданием данных (`--rebuild`) для проверки повторяемости. + +`scripts/track2_backup_restore.py`: +1. Отпечаток источника: число строк и md5 содержимого каждой таблицы (строки по первичному ключу) + 36 выборочных сообщений: первые и последние в чате каждого класса и 20 псевдослучайных. +2. `pg_dump -Fc` — один согласованный снимок. Время, размер, sha256 файла. +3. После дампа в источник записывается 100 сообщений: имитация работы между бэкапом и аварией. +4. **Новое хранилище:** отдельный контейнер того же образа PostgreSQL с новым пустым volume и без портов наружу; `createdb` + `pg_restore -j 4 --no-owner --no-privileges` + `ANALYZE`. RTO — от запуска контейнера до готовой восстановленной базы. +5. Сверка: счётчики, md5 всех таблиц, поля выборочных сообщений, версия миграций, индексы, план запроса истории. Временный контейнер и volume удаляются, 100 «поздних» сообщений из источника — тоже. + +Окружение: PostgreSQL 17.10, `shared_buffers` 128 MB, `work_mem` 4 MB, `synchronous_commit` on; Docker Desktop (WSL2), Ryzen 5 5500U, без лимитов CPU у postgres. + +### Результаты: чтение (медиана мс / буферы; прогон 1 → прогон 2) + +| Чат (сообщений), страница | none | chat_id | **chat_created_id** | covering | +| --- | --- | --- | --- | --- | +| 60 000, первая | 45 → 85 / 7423 | 47 → 84 / 7423 | **0.26 → 0.31 / 54** | 0.15 → 0.22 / 5 | +| 60 000, глубокая (90%) | 37 → 79 / 7365 | 28 → 30 / 4248 | **0.25 → 0.31 / 54** | 0.18 → 0.23 / 5 | +| 5 000, глубокая | 36 → 82 / 7365 | 2.6 → 2.9 / 379 | **0.23 → 0.26 / 54** | 0.19 → 0.21 / 6 | +| 300, глубокая | 31 / 7365 | 0.31 / 25 | **0.18 / 31** | 0.17 / 5 | +| 20, глубокая | 36 / 7365 | 0.18 / 4 | **0.16 / 4** | 0.15 / 4 | +| 60 000, OFFSET 54 000 | — | — | **263 → 300 / 7423** | — | + +Планы глубокой страницы большого чата (`track2-plans.txt`): `none` — `Seq Scan → Sort → Gather Merge`; `chat_id` — `Bitmap Index Scan → Bitmap Heap Scan → Sort`; рабочий — `Index Scan` с `ROW(created_at, id) > ROW(…)` в `Index Cond`, без сортировки; `covering` — `Index Only Scan`. + +### Результаты: запись и размер (прогон 1 / прогон 2) + +| Вариант | Индекс | Bulk, строк/с | WAL bulk, Б/строку | INSERT+COMMIT p50, мс | WAL одиночный, Б/строку | +| --- | --- | --- | --- | --- | --- | +| none | 0 | 7695 / 7919 | 671 / 673 | 4.63 / 4.66 | 313 / 313 | +| chat_id | 0.7 MiB | 7438 / 7077 | 747 / 746 | 5.32 / 5.34 | 403 / 403 | +| **chat_created_id** | **5.9 MiB** | 7375 / 6764 | **820 / 821** | 4.71 / 5.43 | **457 / 457** | +| covering | 29.0 MiB | 6761 / 6445 | 1232 / 1230 | 4.68 / 4.85 | 557 / 558 | + +### Результаты: backup и восстановление (`track2-backup-restore.json`) + +| Этап | Результат | +| --- | --- | +| `pg_dump -Fc` | 2.2 с, 6.5 МБ (сжатый формат; база 75 МБ — индексы в дамп не входят, только их определения) | +| Запуск нового экземпляра (init + готовность) | 7.4 с | +| `pg_restore -j 4` + `ANALYZE` (с построением индексов) | 6.6 с | +| **RTO** (от запуска контейнера до готовой базы) | **14.0 с** | +| Сверка | 6/6 таблиц: число строк и md5 содержимого совпали (`messages` 105 000, `chat_members` 2216, `chats` 555, `users` 300, `sessions` 0, `alembic_version` 1); 36/36 выборочных сообщений совпали по id, чату, отправителю, времени, длине и md5 текста; версия миграций `0001` = `0001`; индексы `messages_pkey`, `messages_chat_history_idx` на месте; запрос истории — `Index Scan using messages_chat_history_idx` (`read=4`: кэш нового экземпляра холодный) | +| Граница потерь | в источнике к «моменту аварии» 105 100 сообщений, в восстановленной базе 105 000: **100 сообщений, записанных после снимка, потеряны** | + +### Выводы + +- **H1 подтверждена; неравномерность чатов — ключевой фактор.** Индекс по `chat_id` на маленьких чатах не хуже рабочего (0.18 мс на 20 сообщениях), но на чате в 60 000 бесполезен (28–84 мс): нужно прочитать и отсортировать весь чат. Для первой страницы планировщик вообще выбирает полный скан, потому что чат — 57% таблицы. Рабочий индекс держит 0.16–0.31 мс на любом чате и любой глубине. +- **H2 подтверждена частично.** Индексы стабильно увеличивают WAL: +22% у рабочего и +84% у покрывающего на bulk, +46% и +78% на одиночной вставке, разброс между прогонами меньше 0.5%. Bulk-вставка медленнее на 4–19%, но это время шумит между прогонами (±8%). **Задержку одиночной вставки API индексы не меняют** (4.6–5.4 мс у всех): её определяет `COMMIT` с fsync журнала. +- **Решение:** оставить рабочий индекс. Покрывающий в 5 раз больше (29 MiB), пишет на 50% больше журнала и дольше строится при восстановлении ради 0.05–0.1 мс. +- **H3 подтверждена.** OFFSET на глубине 54 000 — 263–300 мс против 0.25–0.31 мс у keyset, то есть примерно в 1000 раз. +- **H4 подтверждена.** Восстановление в новое хранилище точное (md5 всех таблиц). RTO 14 с, из них половина — запуск экземпляра. Время восстановления растёт с объёмом данных и **числом индексов** (они строятся заново при `pg_restore`), а размер дампа от индексов не зависит. +- **Граница потери данных (RPO).** Логический дамп — снимок на момент начала `pg_dump`. Всё записанное позже (у нас 100 сообщений) при восстановлении из него теряется. RPO = интервал между дампами плюс длительность дампа: при ежесуточном `pg_dump` — до суток сообщений. Уменьшить можно так: + - непрерывное архивирование WAL + `pg_basebackup` (PITR): RPO — секунды (`archive_timeout`), восстановление на любой момент; + - потоковая реплика: асинхронная — RPO доли секунды, синхронная — RPO 0 ценой задержки `COMMIT`; RTO = время переключения. + Redis в бэкап не входит и не должен: это кэш, сессии восстанавливаются из таблицы `sessions`, которая есть в дампе. + +### Ограничения трека + +- Тёплый кэш: таблица ≈ 58 MiB с индексом помещается в `shared_buffers`; на холодном кэше разница 54 против 5 буферов проявилась бы сильнее (после восстановления видно `read=4`). +- Одна машина, Docker Desktop. Абсолютное время чтения при полном скане между прогонами расходилось до 2× (фоновая нагрузка, параллельные воркеры), а выводы и порядок вариантов совпали. Самые стабильные метрики — буферы и WAL/строку. +- Синтетические данные: случайное время вставки — пессимистичный случай для рабочего индекса (54 буфера); при вставке в порядке времени было 5 (шаг EXPLAIN уровня 4). +- Дамп хранится на той же машине в `backups/`: это не защита от потери диска. Для настоящего бэкапа нужна копия вне хоста и проверка sha256. +- RTO измерен на 105 000 сообщений; на больших объёмах время `pg_restore` (особенно построение индексов) растёт, и логический дамп перестаёт подходить. Тогда нужны физические бэкапы. ## Ограничения и следующие шаги -- Один экземпляр API и одна PostgreSQL без реплик и бэкапов: потеря volume = потеря данных. +- Один экземпляр API, одна PostgreSQL и один Redis без реплик. Процедура бэкапа и восстановления проверена (трек 2), но регулярные бэкапы рабочей базы не настроены: потеря volume = потеря данных после последнего ручного дампа. +- Если **в момент logout** Redis недоступен по сети, но сохранил данные, метку отзыва записать не удаётся, и копия сессии в кэше может прожить до 300 с (`max_ttl_seconds`); это пишется в лог. При остановке/рестарте Redis (без persistence) копия исчезает вместе с кэшем. +- При недоступной БД пользователь с сессией в кэше по-прежнему аутентифицируется (например, `GET /users/me` отвечает 200 из кэша), а все запросы к данным дают 503. Это осознанный выбор: кэш содержит только неизменяемый профиль. - Токен — JWT: payload (UUID пользователя, время) читается клиентом, секретов в нём нет; отзыв обеспечивается серверной сессией. - При одновременной записи курсор может пропустить сообщение, чьё `created_at` меньше уже выданного (окно — время между INSERT и COMMIT); повторное чтение с начала его показывает. Время назначает PostgreSQL. - Истёкшие сессии из таблицы не удаляются автоматически (индекс по `expires_at` есть). -- Не сделано (уровень 4): Redis/Valkey, EXPLAIN на ≥10 000 сообщений, тест гонки регистрации. +- Измерения — по одному прогону, клиент на той же машине. +- Следующие шаги: регулярный `pg_dump` или WAL-архивирование для рабочей базы с хранением вне хоста; периодическая очистка истёкших сессий. diff --git a/app/api/dependencies.py b/app/api/dependencies.py index 79777b4e..da6a1b5a 100644 --- a/app/api/dependencies.py +++ b/app/api/dependencies.py @@ -3,6 +3,7 @@ from fastapi.security import HTTPBasic, HTTPBearer from sqlalchemy.orm import Session from core.db import get_db +from database_functions.sessions_cache import REVOKED, get_cached_session, store_session from database_functions.sessions_functions import get_active_session from models import AuthSession, User from utils.security import decode_access_token, token_hash @@ -42,12 +43,19 @@ def get_current_session(authorization: str | None = Security(bearer_scheme), if scheme.lower() != "bearer" or not token: raise unauthorized() - # Подпись и exp проверяются без базы, отзыв (logout) — по таблице sessions. + # Подпись и exp проверяются без базы, отзыв (logout) — по Redis, а при промахе по таблице sessions. payload = decode_access_token(token) if payload is None: raise unauthorized() - auth_session = get_active_session(db, token_hash(token)) + digest = token_hash(token) + auth_session = get_cached_session(digest) + if auth_session == REVOKED: + raise unauthorized() + if auth_session is None: + auth_session = get_active_session(db, digest) + if auth_session is not None: + store_session(digest, auth_session.user, auth_session.expires_at) if auth_session is None or str(auth_session.user_id) != payload["sub"]: raise unauthorized() return auth_session diff --git a/app/api/health.py b/app/api/health.py index d2386218..f6d715db 100644 --- a/app/api/health.py +++ b/app/api/health.py @@ -11,7 +11,8 @@ def live_api(): return HealthResponse(status="ok") -# В отличие от live, ready зависит от PostgreSQL. +# В отличие от live, ready зависит от PostgreSQL. Redis сюда намеренно не входит: +# это кэш, без него API работает (сессии читаются из базы). @router.get("/ready", response_model=HealthResponse) def ready_api(): if not check_database(): diff --git a/app/api/v1/auth_rout.py b/app/api/v1/auth_rout.py index 89e1abbc..09d61e03 100644 --- a/app/api/v1/auth_rout.py +++ b/app/api/v1/auth_rout.py @@ -8,6 +8,7 @@ from api.dependencies import basic_scheme, get_current_session, require_empty_bo from core.config import settings from core.db import get_db from core.logger import logger +from database_functions.sessions_cache import revoke_cached_session, store_session from database_functions.sessions_functions import create_session, delete_session from database_functions.users_functions import get_user_by_username from models import AuthSession @@ -55,12 +56,18 @@ def create_session_api(authorization: str | None = Security(basic_scheme), db: S token, issued_at, expires_at = create_access_token(user.id) create_session(db, token_hash(token), user.id, created_at=issued_at, expires_at=expires_at) + # Сразу в кэш (после COMMIT): первый же запрос с токеном не пойдёт в базу. + store_session(token_hash(token), user, expires_at) logger.info(f"Вход выполнен: user_id={user.id}") return SessionResponse(token=token, expires_at=expires_at, user=UserResponse.model_validate(user)) @roter.delete("/sessions/current", status_code=204) def delete_session_api(auth_session: AuthSession = Depends(get_current_session), db: Session = Depends(get_db)): + # Сначала база (источник истины), затем метка отзыва в кэше. delete_session(db, auth_session.token_hash) + if not revoke_cached_session(auth_session.token_hash, auth_session.expires_at): + logger.warning(f"Отзыв не записан в Redis: копия сессии в кэше (если есть) " + f"проживёт не дольше {settings.redis.max_ttl_seconds} с") logger.info(f"Выход выполнен: user_id={auth_session.user_id}") return Response(status_code=204) diff --git a/app/core/config.py b/app/core/config.py index f1079fe6..3364d680 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -49,6 +49,24 @@ class JWTConfig(BaseModel): return read_secret(self.secret_file) +class RedisConfig(BaseModel): + # Кэш сессий. Источник истины — таблица sessions в PostgreSQL: без Redis всё работает, только медленнее. + host: str = "redis" + port: int = 6379 + db: int = 0 + password_file: Path = Path("/run/secrets/redis_password") + # Короткие таймауты: недоступный кэш не должен заметно тормозить запрос. + timeout_seconds: float = 0.25 + # После ошибки запросы Redis не трогают; фоновый поток проверяет его с таким периодом. + retry_after_seconds: float = 5 + # Верхняя граница жизни записи в кэше (меньше TTL сессии): ограничивает окно, в котором + # кэш может разойтись с базой, если отзыв не удалось записать в Redis. + max_ttl_seconds: int = 300 + + def read_password(self) -> str: + return read_secret(self.password_file) + + def read_secret(path: Path) -> str: """Прочитать файл-секрет. Относительный путь считается от корня проекта.""" full_path = path if path.is_absolute() else BASE_DIR / path @@ -81,6 +99,7 @@ class Settings(BaseSettings): logging: LoggingConfig = LoggingConfig() db: DatabaseConfig = DatabaseConfig() jwt: JWTConfig = JWTConfig() + redis: RedisConfig = RedisConfig() settings = Settings() diff --git a/app/core/redis_client.py b/app/core/redis_client.py new file mode 100644 index 00000000..4da55d2e --- /dev/null +++ b/app/core/redis_client.py @@ -0,0 +1,99 @@ +import threading +import time +from collections.abc import Callable +from typing import TypeVar + +import redis +from redis.backoff import NoBackoff +from redis.retry import Retry + +from core.config import settings +from core.logger import logger + +T = TypeVar("T") + + +class RedisClient: + """Подключение к Redis, которое никогда не роняет и не задерживает запрос надолго. + + Любая ошибка (нет соединения, таймаут, неверный пароль, нет файла-секрета) превращается в None: + вызывающий код считает это промахом кэша и идёт в PostgreSQL. После первой ошибки запросы + к Redis не обращаются вообще, а доступность проверяет фоновый поток раз в retry_after_seconds. + Так ни один запрос не ждёт на недоступном Redis: например, разрешение DNS-имени остановленного + контейнера не ограничено socket_connect_timeout и может занимать секунды. + """ + + def __init__(self): + self._client: redis.Redis | None = None + self._down = threading.Event() + self._lock = threading.Lock() + self._generation = 0 # меняется в reset(): старый фоновый поток понимает, что пора выйти + + def _connect(self) -> redis.Redis: + cfg = settings.redis + return redis.Redis( + host=cfg.host, + port=cfg.port, + db=cfg.db, + password=cfg.read_password(), + socket_connect_timeout=cfg.timeout_seconds, + socket_timeout=cfg.timeout_seconds, + # Без встроенных повторов: при отказе сразу уходим в базу. + retry=Retry(NoBackoff(), 0), + decode_responses=True, + ) + + def run(self, operation: Callable[[redis.Redis], T]) -> T | None: + if self._down.is_set(): + return None + try: + if self._client is None: + self._client = self._connect() + return operation(self._client) + except (redis.RedisError, OSError) as exc: + self._mark_down(exc) + return None + + def _mark_down(self, exc: Exception) -> None: + with self._lock: + if self._down.is_set(): + return + self._down.set() + generation = self._generation + # Только тип ошибки: в тексте может оказаться адрес. + logger.warning(f"Redis недоступен ({type(exc).__name__}), сессии читаются из PostgreSQL; " + f"проверка доступности каждые {settings.redis.retry_after_seconds:g} с") + threading.Thread(target=self._probe_until_up, args=(generation,), daemon=True).start() + + def _probe_until_up(self, generation: int) -> None: + while True: + time.sleep(settings.redis.retry_after_seconds) + if generation != self._generation: + return + try: + client = self._connect() + client.ping() + except (redis.RedisError, OSError): + continue + with self._lock: + if generation != self._generation: + client.close() + return + old, self._client = self._client, client + self._down.clear() + if old is not None: + old.close() + logger.info("Redis снова доступен, сессии снова кэшируются") + return + + def reset(self) -> None: + """Забыть соединение и состояние отказа (нужно тестам после смены настроек и при остановке).""" + with self._lock: + self._generation += 1 + old, self._client = self._client, None + self._down.clear() + if old is not None: + old.close() + + +redis_client = RedisClient() diff --git a/app/database_functions/messages_functions.py b/app/database_functions/messages_functions.py index 9bbf2571..bce22610 100644 --- a/app/database_functions/messages_functions.py +++ b/app/database_functions/messages_functions.py @@ -1,6 +1,6 @@ import uuid -from sqlalchemy import select, tuple_ +from sqlalchemy import Select, select, tuple_ from sqlalchemy.orm import Session from models import Message @@ -14,7 +14,8 @@ def create_message(db: Session, chat_id: uuid.UUID, sender_id: uuid.UUID, text: return message -def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | None) -> list[Message]: +def history_query(chat_id: uuid.UUID, limit: int, after: Position | None) -> Select: + """Запрос страницы истории. Отдельно, чтобы scripts/explain_history.py анализировал ровно его.""" # Keyset-пагинация по индексу messages_chat_history_idx (chat_id, created_at, id). query = ( select(Message) @@ -24,4 +25,8 @@ def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | ) if after is not None: query = query.where(tuple_(Message.created_at, Message.id) > tuple_(*after)) - return list(db.scalars(query)) + return query + + +def list_messages(db: Session, chat_id: uuid.UUID, limit: int, after: Position | None) -> list[Message]: + return list(db.scalars(history_query(chat_id, limit, after))) diff --git a/app/database_functions/sessions_cache.py b/app/database_functions/sessions_cache.py new file mode 100644 index 00000000..c3b8e62c --- /dev/null +++ b/app/database_functions/sessions_cache.py @@ -0,0 +1,68 @@ +"""Кэш сессий в Redis (cache-aside). + +Источник истины — таблица sessions. В Redis по ключу session: лежит +JSON с user_id, профилем пользователя и сроком сессии; сам токен и password_hash не хранятся. +Профиль кэшировать безопасно: по контракту пользователей нельзя изменить или удалить. + +TTL записи = min(остаток жизни сессии, max_ttl_seconds): кэш никогда не переживает сессию. +Logout пишет в тот же ключ метку "revoked" на весь остаток жизни сессии, а запись из базы +кладётся только через SET NX. Поэтому медленный запрос, прочитавший сессию до logout, +не может «воскресить» её в кэше после logout. +""" +import json +import uuid +from datetime import datetime, timezone + +from core.config import settings +from core.redis_client import redis_client +from models import AuthSession, User + +REVOKED = "revoked" + + +def cache_key(token_hash: bytes) -> str: + return "session:" + token_hash.hex() + + +def seconds_left(expires_at: datetime) -> int: + return int((expires_at - datetime.now(timezone.utc)).total_seconds()) + + +def get_cached_session(token_hash: bytes) -> AuthSession | str | None: + """Сессия из кэша, REVOKED для отозванной или None (нет в кэше / Redis недоступен).""" + raw = redis_client.run(lambda r: r.get(cache_key(token_hash))) + if raw is None or raw == REVOKED: + return raw + data = json.loads(raw) + expires_at = datetime.fromisoformat(data["expires_at"]) + if expires_at <= datetime.now(timezone.utc): + return None + # Объекты не привязаны к ORM-сессии: обработчикам нужны только поля, в базу они не попадают. + user = User(id=uuid.UUID(data["user_id"]), username=data["username"], + display_name=data["display_name"], created_at=datetime.fromisoformat(data["user_created_at"])) + auth_session = AuthSession(token_hash=token_hash, user_id=user.id, expires_at=expires_at) + auth_session.user = user + return auth_session + + +def store_session(token_hash: bytes, user: User, expires_at: datetime) -> bool: + """Положить сессию в кэш, если там ещё ничего нет (в том числе метки отзыва).""" + ttl = min(seconds_left(expires_at), settings.redis.max_ttl_seconds) + if ttl <= 0: + return False + value = json.dumps({ + "user_id": str(user.id), + "username": user.username, + "display_name": user.display_name, + "user_created_at": user.created_at.isoformat(), + "expires_at": expires_at.isoformat(), + }) + return bool(redis_client.run(lambda r: r.set(cache_key(token_hash), value, ex=ttl, nx=True))) + + +def revoke_cached_session(token_hash: bytes, expires_at: datetime) -> bool: + """Заменить запись меткой отзыва до конца жизни сессии. False, если Redis недоступен.""" + ttl = seconds_left(expires_at) + if ttl <= 0: + return True + return bool(redis_client.run(lambda r: r.set(cache_key(token_hash), REVOKED, ex=ttl))) diff --git a/app/main.py b/app/main.py index 951a5139..7275c49e 100644 --- a/app/main.py +++ b/app/main.py @@ -12,6 +12,7 @@ from api.v1.users_rout import roter as users_router from core.config import settings from core.db import engine, log_database_target from core.logger import logger +from core.redis_client import redis_client from utils.errors import register_error_handlers from utils.middleware import request_id_middleware @@ -22,7 +23,8 @@ async def lifespan(app: FastAPI): yield # Остановка (в том числе по SIGTERM): закрываем соединения пула. engine.dispose() - logger.info("Соединения с базой данных закрыты") + redis_client.reset() + logger.info("Соединения с базой данных и Redis закрыты") app = FastAPI(title="MTUSI Messenger lab2", lifespan=lifespan) diff --git a/compose.yaml b/compose.yaml index a6229738..1dca0131 100644 --- a/compose.yaml +++ b/compose.yaml @@ -24,6 +24,29 @@ services: start_period: 10s restart: unless-stopped + # Кэш сессий. Источник истины — таблица sessions в PostgreSQL, поэтому persistence выключен: + # после рестарта кэш пуст и заполняется из базы, ни одна сессия не теряется. + redis: + image: redis:8.6.8-alpine@sha256:f4ed7d6732f9a5dcc6b64e2b347860b9f329334bfd4839a672f78cd981a8bba6 + # Пароль из Docker secret (виден в списке процессов только внутри контейнера). + # volatile-ttl: при нехватке памяти вытесняются ключи, которым меньше всего осталось жить. + command: + - sh + - -c + - >- + exec redis-server --requirepass "$$(cat /run/secrets/redis_password)" + --save "" --appendonly no --maxmemory 64mb --maxmemory-policy volatile-ttl + secrets: + - redis_password + ports: + - "127.0.0.1:${REDIS_HOST_PORT:-6379}:6379" + healthcheck: + test: ["CMD-SHELL", "redis-cli -a \"$$(cat /run/secrets/redis_password)\" --no-auth-warning ping | grep -q PONG"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + # Разовая задача: применить миграции и завершиться с кодом 0. migrate: build: . @@ -37,6 +60,8 @@ services: APP_CONFIG__DB__PASSWORD_FILE: /run/secrets/postgres_password APP_CONFIG__JWT__SECRET_FILE: /run/secrets/jwt_secret APP_CONFIG__JWT__SESSION_TTL_SECONDS: ${APP_CONFIG__JWT__SESSION_TTL_SECONDS:-3600} + APP_CONFIG__REDIS__HOST: redis + APP_CONFIG__REDIS__PASSWORD_FILE: /run/secrets/redis_password APP_CONFIG__LOGGING__LEVEL: ${APP_CONFIG__LOGGING__LEVEL:-INFO} secrets: - postgres_password @@ -51,14 +76,23 @@ services: image: mtusi-messenger:lab2 # Без env_file: в .env адреса для запуска из venv, а не из контейнера. environment: *app-env + # Имя остановленного контейнера (postgres/redis) резолвер по умолчанию ищет ~8 с, и connect_timeout + # этот этап не покрывает: запрос висел бы 8 с вместо быстрого 503. Ограничиваем поиск 1 с. + dns_opt: + - timeout:1 + - attempts:1 secrets: - postgres_password - jwt_secret + - redis_password depends_on: postgres: condition: service_healthy migrate: condition: service_completed_successfully + # Только порядок старта: API работает и без Redis (сессии из базы). + redis: + condition: service_started ports: - "127.0.0.1:8080:8080" stop_grace_period: 10s @@ -72,3 +106,5 @@ secrets: file: ./secrets/postgres_password jwt_secret: file: ./secrets/jwt_secret + redis_password: + file: ./secrets/redis_password diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..d63cbe41 --- /dev/null +++ b/evidence/explain-history.txt @@ -0,0 +1,90 @@ +# 2026-10-29T10:48:16Z PostgreSQL 17.10 +# messages: 22024 rows total, 5560 kB with indexes; big chat 12000, 20 small chats x 500; ANALYZE done +# indexes on messages: +# CREATE INDEX messages_chat_history_idx ON public.messages USING btree (chat_id, created_at, id) +# CREATE UNIQUE INDEX messages_pkey ON public.messages USING btree (id) + +# SUMMARY (top node, rows removed by filter, buffers of the top node, execution time) +# 1. big chat, first page (no cursor): Index Scan using messages_chat_history_idx; removed=0; buffers hit=5 read=0; 0.237 ms +# 2. big chat, middle page (cursor after #6000): Index Scan using messages_chat_history_idx; removed=0; buffers hit=5 read=0; 0.282 ms +# 3. big chat, last page (cursor after #11949): Index Scan using messages_chat_history_idx; removed=0; buffers hit=5 read=0; 0.241 ms +# 4. small chat, first page: Index Scan using messages_chat_history_idx; removed=0; buffers hit=6 read=0; 0.226 ms +# 5. for comparison: OFFSET pagination to the same depth as case 3 (NOT used by the API): Seq Scan on messages; removed=10024; buffers hit=296 read=0; 12.874 ms + +## 1. big chat, first page (no cursor) +-- SQL generated by the API (history_query): +SELECT messages.id, messages.chat_id, messages.sender_id, messages.created_at, messages.text +FROM messages +WHERE messages.chat_id = %(chat_id_1)s::UUID ORDER BY messages.created_at, messages.id + LIMIT %(param_1)s::INTEGER + +Limit (cost=0.41..8.65 rows=51 width=79) (actual time=0.054..0.075 rows=51 loops=1) + Buffers: shared hit=5 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..1938.38 rows=12000 width=79) (actual time=0.052..0.066 rows=51 loops=1) + Index Cond: (chat_id = '46e81345-6190-4647-a359-24a7b2b54811'::uuid) + Buffers: shared hit=5 +Planning: + Buffers: shared hit=6 +Planning Time: 0.548 ms +Execution Time: 0.237 ms + +## 2. big chat, middle page (cursor after #6000) +-- SQL generated by the API (history_query): +SELECT messages.id, messages.chat_id, messages.sender_id, messages.created_at, messages.text +FROM messages +WHERE messages.chat_id = %(chat_id_1)s::UUID AND (messages.created_at, messages.id) > (%(param_1)s::TIMESTAMP WITH TIME ZONE, %(param_2)s::UUID) ORDER BY messages.created_at, messages.id + LIMIT %(param_3)s::INTEGER + +Limit (cost=0.41..10.57 rows=51 width=79) (actual time=0.044..0.064 rows=51 loops=1) + Buffers: shared hit=5 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..1736.13 rows=8717 width=79) (actual time=0.043..0.055 rows=51 loops=1) + Index Cond: ((chat_id = '46e81345-6190-4647-a359-24a7b2b54811'::uuid) AND (ROW(created_at, id) > ROW('2026-10-29 10:48:07.896359+00'::timestamp with time zone, '402e4609-d59c-4a14-8778-c1b2ea8f741c'::uuid))) + Buffers: shared hit=5 +Planning Time: 0.140 ms +Execution Time: 0.282 ms + +## 3. big chat, last page (cursor after #11949) +-- SQL generated by the API (history_query): +SELECT messages.id, messages.chat_id, messages.sender_id, messages.created_at, messages.text +FROM messages +WHERE messages.chat_id = %(chat_id_1)s::UUID AND (messages.created_at, messages.id) > (%(param_1)s::TIMESTAMP WITH TIME ZONE, %(param_2)s::UUID) ORDER BY messages.created_at, messages.id + LIMIT %(param_3)s::INTEGER + +Limit (cost=0.41..14.36 rows=51 width=79) (actual time=0.103..0.131 rows=50 loops=1) + Buffers: shared hit=5 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..1509.60 rows=5517 width=79) (actual time=0.101..0.119 rows=50 loops=1) + Index Cond: ((chat_id = '46e81345-6190-4647-a359-24a7b2b54811'::uuid) AND (ROW(created_at, id) > ROW('2026-10-29 10:48:14.005334+00'::timestamp with time zone, 'd99d5478-4411-4166-b023-54ff684194b4'::uuid))) + Buffers: shared hit=5 +Planning Time: 0.199 ms +Execution Time: 0.241 ms + +## 4. small chat, first page +-- SQL generated by the API (history_query): +SELECT messages.id, messages.chat_id, messages.sender_id, messages.created_at, messages.text +FROM messages +WHERE messages.chat_id = %(chat_id_1)s::UUID ORDER BY messages.created_at, messages.id + LIMIT %(param_1)s::INTEGER + +Limit (cost=0.41..108.66 rows=51 width=79) (actual time=0.101..0.127 rows=51 loops=1) + Buffers: shared hit=6 + -> Index Scan using messages_chat_history_idx on messages (cost=0.41..1061.66 rows=500 width=79) (actual time=0.099..0.118 rows=51 loops=1) + Index Cond: (chat_id = '074dc7b2-e596-4686-b75e-ee925fd2bd87'::uuid) + Buffers: shared hit=6 +Planning Time: 0.144 ms +Execution Time: 0.226 ms + +## 5. for comparison: OFFSET pagination to the same depth as case 3 (NOT used by the API) +SELECT * FROM messages WHERE chat_id = %(c)s ORDER BY created_at, id OFFSET %(o)s LIMIT %(l)s + +Limit (cost=1414.22..1414.34 rows=51 width=79) (actual time=11.721..11.735 rows=51 loops=1) + Buffers: shared hit=296 + -> Sort (cost=1384.34..1414.34 rows=12000 width=79) (actual time=9.709..10.792 rows=12000 loops=1) + Sort Key: created_at, id + Sort Method: quicksort Memory: 1978kB + Buffers: shared hit=296 + -> Seq Scan on messages (cost=0.00..571.30 rows=12000 width=79) (actual time=0.025..3.964 rows=12000 loops=1) + Filter: (chat_id = '46e81345-6190-4647-a359-24a7b2b54811'::uuid) + Rows Removed by Filter: 10024 + Buffers: shared hit=296 +Planning Time: 0.127 ms +Execution Time: 12.874 ms diff --git a/evidence/failure-postgres-before-dns-fix.json b/evidence/failure-postgres-before-dns-fix.json new file mode 100644 index 00000000..ea02bb08 --- /dev/null +++ b/evidence/failure-postgres-before-dns-fix.json @@ -0,0 +1,84 @@ +{ + "service": "postgres", + "method": "4 closed-loop workers: GET /users/me + POST message; client timeout 5 s; docker compose stop postgres at t=5.1s, start at t=24.6s", + "docker_stop_seconds": 1.41, + "health_while_down": { + "live": 200, + "ready": 503 + }, + "before": { + "seconds": 5.1, + "me": { + "requests": 161, + "statuses": { + "200": 161 + }, + "ok_latency_ms_p50": 49.0, + "ok_latency_ms_p95": 72.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 157, + "statuses": { + "201": 157 + }, + "ok_latency_ms_p50": 72.0, + "ok_latency_ms_p95": 103.0, + "failed_latency_ms_max": null + } + }, + "while_down": { + "seconds": 19.5, + "me": { + "requests": 52, + "statuses": { + "200": 52 + }, + "ok_latency_ms_p50": 49.0, + "ok_latency_ms_p95": 77.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 56, + "statuses": { + "201": 17, + "503": 31, + "error": 8 + }, + "ok_latency_ms_p50": 87.0, + "ok_latency_ms_p95": 4141.0, + "failed_latency_ms_max": 5052.0 + } + }, + "after_start": { + "seconds": 16.6, + "me": { + "requests": 466, + "statuses": { + "200": 466 + }, + "ok_latency_ms_p50": 48.0, + "ok_latency_ms_p95": 72.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 466, + "statuses": { + "201": 466 + }, + "ok_latency_ms_p50": 73.0, + "ok_latency_ms_p95": 99.0, + "failed_latency_ms_max": null + } + }, + "first_failure_seconds_after_stop": 0.51, + "last_failure_seconds_after_start": 0.0, + "first_successful_write_seconds_after_start": 2.17, + "redis_session_keys_before_after": [ + null, + null + ], + "api_log_redis_warnings": [ + "Redis недоступен (ConnectionError), сессии читаются из PostgreSQL; проверка доступности каждые 5 с" + ] +} diff --git a/evidence/failure-postgres.json b/evidence/failure-postgres.json new file mode 100644 index 00000000..6de40cee --- /dev/null +++ b/evidence/failure-postgres.json @@ -0,0 +1,82 @@ +{ + "service": "postgres", + "method": "4 closed-loop workers: GET /users/me + POST message; client timeout 5 s; docker compose stop postgres at t=5.1s, start at t=17.5s", + "docker_stop_seconds": 1.27, + "health_while_down": { + "live": 200, + "ready": 503 + }, + "before": { + "seconds": 5.1, + "me": { + "requests": 163, + "statuses": { + "200": 163 + }, + "ok_latency_ms_p50": 46.0, + "ok_latency_ms_p95": 71.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 162, + "statuses": { + "201": 162 + }, + "ok_latency_ms_p50": 76.0, + "ok_latency_ms_p95": 101.0, + "failed_latency_ms_max": null + } + }, + "while_down": { + "seconds": 12.4, + "me": { + "requests": 65, + "statuses": { + "200": 65 + }, + "ok_latency_ms_p50": 43.0, + "ok_latency_ms_p95": 64.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 66, + "statuses": { + "201": 10, + "503": 56 + }, + "ok_latency_ms_p50": 85.0, + "ok_latency_ms_p95": 156.0, + "failed_latency_ms_max": 3089.0 + } + }, + "after_start": { + "seconds": 16.6, + "me": { + "requests": 496, + "statuses": { + "200": 496 + }, + "ok_latency_ms_p50": 48.0, + "ok_latency_ms_p95": 73.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 496, + "statuses": { + "503": 4, + "201": 492 + }, + "ok_latency_ms_p50": 72.0, + "ok_latency_ms_p95": 104.0, + "failed_latency_ms_max": 1066.0 + } + }, + "first_failure_seconds_after_stop": 0.54, + "last_failure_seconds_after_start": 1.56, + "first_successful_write_seconds_after_start": 1.38, + "redis_session_keys_before_after": [ + null, + null + ], + "api_log_redis_warnings": [] +} diff --git a/evidence/failure-redis.json b/evidence/failure-redis.json new file mode 100644 index 00000000..17335d44 --- /dev/null +++ b/evidence/failure-redis.json @@ -0,0 +1,82 @@ +{ + "service": "redis", + "method": "4 closed-loop workers: GET /users/me + POST message; client timeout 5 s; docker compose stop redis at t=5.6s, start at t=16.9s", + "docker_stop_seconds": 1.18, + "health_while_down": { + "live": 200, + "ready": 200 + }, + "before": { + "seconds": 5.6, + "me": { + "requests": 168, + "statuses": { + "200": 168 + }, + "ok_latency_ms_p50": 50.0, + "ok_latency_ms_p95": 75.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 166, + "statuses": { + "201": 166 + }, + "ok_latency_ms_p50": 78.0, + "ok_latency_ms_p95": 107.0, + "failed_latency_ms_max": null + } + }, + "while_down": { + "seconds": 11.3, + "me": { + "requests": 299, + "statuses": { + "200": 299 + }, + "ok_latency_ms_p50": 64.0, + "ok_latency_ms_p95": 90.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 300, + "statuses": { + "201": 300 + }, + "ok_latency_ms_p50": 86.0, + "ok_latency_ms_p95": 115.0, + "failed_latency_ms_max": null + } + }, + "after_start": { + "seconds": 11.2, + "me": { + "requests": 325, + "statuses": { + "200": 325 + }, + "ok_latency_ms_p50": 56.0, + "ok_latency_ms_p95": 85.0, + "failed_latency_ms_max": null + }, + "write": { + "requests": 326, + "statuses": { + "201": 326 + }, + "ok_latency_ms_p50": 79.0, + "ok_latency_ms_p95": 106.0, + "failed_latency_ms_max": null + } + }, + "first_failure_seconds_after_stop": null, + "last_failure_seconds_after_start": 0.0, + "first_successful_write_seconds_after_start": 0.09, + "redis_session_keys_before_after": [ + 5, + 1 + ], + "api_log_redis_warnings": [ + "Redis недоступен (ConnectionError), сессии читаются из PostgreSQL; проверка доступности каждые 5 с" + ] +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt index bde26374..67cf440b 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -1,20 +1,17 @@ -# test-persistence (Windows: scripts\restart.cmd = same commands as scripts/restart.sh) -date: 2026-10-16T10:05:33 - +# 2026-10-29T13:56:19 persistence: restart api, postgres, redis with volumes kept; same bearer token after restart ## containers BEFORE -/mtusi-lab2-api-1 id=4dcf421abd1d started=2026-10-16T07:04:52.820712243Z status=running -/mtusi-lab2-postgres-1 id=64cc9db56db3 started=2026-10-16T07:04:41.833181321Z status=running - -## test output (exit 0, 22.3s) + /mtusi-lab2-api-1 running StartedAt=2026-10-29T10:54:06.160154929Z + /mtusi-lab2-migrate-1 exited StartedAt=2026-10-29T10:54:01.857928321Z + /mtusi-lab2-postgres-1 running StartedAt=2026-10-29T10:54:56.204288024Z + /mtusi-lab2-redis-1 running StartedAt=2026-10-29T10:50:55.728984099Z + volume mtusi-lab2_postgres_data CreatedAt=2026-10-15T14:23:31Z +$ 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 (new StartedAt = really restarted) -/mtusi-lab2-api-1 id=4dcf421abd1d started=2026-10-16T07:05:25.634228444Z status=running -/mtusi-lab2-postgres-1 id=64cc9db56db3 started=2026-10-16T07:05:15.448515673Z status=running - -## volume (same, not recreated) -mtusi-lab2_postgres_data created=2026-10-15T14:23:31Z - -## rows in PostgreSQL after restart -users=15 chats=5 messages=9 active_sessions=8 +exit=0 +## containers AFTER (new StartedAt = really restarted; Redis comes back empty, sessions are re-read from PostgreSQL) + /mtusi-lab2-api-1 running StartedAt=2026-10-29T10:56:37.367116728Z + /mtusi-lab2-migrate-1 exited StartedAt=2026-10-29T10:56:33.062187191Z + /mtusi-lab2-postgres-1 running StartedAt=2026-10-29T10:56:26.947421567Z + /mtusi-lab2-redis-1 running StartedAt=2026-10-29T10:56:26.357852423Z + volume mtusi-lab2_postgres_data CreatedAt=2026-10-15T14:23:31Z diff --git a/evidence/pytest.txt b/evidence/pytest.txt new file mode 100644 index 00000000..a88d0022 --- /dev/null +++ b/evidence/pytest.txt @@ -0,0 +1,57 @@ +# 2026-10-29T13:55:35 student tests (PostgreSQL DB messenger_test, Redis DB 15) +$ .venv\Scripts\python.exe -m pytest -v +============================= test session starts ============================= +platform win32 -- Python 3.14.3, pytest-9.1.1, pluggy-1.7.0 -- D:\диск С\Документы\unic\VP\lab2\mtusi2026lab2\.venv\Scripts\python.exe +rootdir: D:\диск С\Документы\unic\VP\lab2\mtusi2026lab2 +configfile: pytest.ini +testpaths: student-tests +plugins: anyio-4.15.1 +collecting ... collected 44 items + +student-tests/test_auth_api.py::test_login_returns_session PASSED [ 2%] +student-tests/test_auth_api.py::test_jwt_payload_contains_sub_exp_jti PASSED [ 4%] +student-tests/test_auth_api.py::test_wrong_password_and_unknown_user_give_same_401 PASSED [ 6%] +student-tests/test_auth_api.py::test_malformed_basic_returns_401 PASSED [ 9%] +student-tests/test_auth_api.py::test_login_with_body_returns_400_and_creates_no_session PASSED [ 11%] +student-tests/test_auth_api.py::test_password_with_colon_and_unicode PASSED [ 13%] +student-tests/test_auth_api.py::test_protected_endpoint_requires_bearer PASSED [ 15%] +student-tests/test_auth_api.py::test_x_user_id_does_not_override_token PASSED [ 18%] +student-tests/test_auth_api.py::test_forged_token_is_rejected PASSED [ 20%] +student-tests/test_auth_api.py::test_logout_revokes_only_current_token PASSED [ 22%] +student-tests/test_auth_api.py::test_session_expires PASSED [ 25%] +student-tests/test_chats_api.py::test_unknown_member_returns_400_and_nothing_is_saved PASSED [ 27%] +student-tests/test_chats_api.py::test_created_chat_is_stored_with_members PASSED [ 29%] +student-tests/test_chats_api.py::test_foreign_chat_returns_404 PASSED [ 31%] +student-tests/test_chats_api.py::test_member_sees_chat PASSED [ 34%] +student-tests/test_chats_api.py::test_creator_must_be_member PASSED [ 36%] +student-tests/test_chats_api.py::test_duplicate_members_return_400 PASSED [ 38%] +student-tests/test_failures_api.py::test_parallel_registration_of_same_username_creates_one_user PASSED [ 40%] +student-tests/test_failures_api.py::test_chat_creation_rolls_back_when_member_insert_fails PASSED [ 43%] +student-tests/test_failures_api.py::test_database_down_gives_limited_503_and_no_anonymous_access PASSED [ 45%] +student-tests/test_failures_api.py::test_database_down_cached_session_still_authenticates PASSED [ 47%] +student-tests/test_messages_api.py::test_empty_message_returns_400 PASSED [ 50%] +student-tests/test_messages_api.py::test_sender_is_taken_from_token PASSED [ 52%] +student-tests/test_messages_api.py::test_pagination_over_several_pages PASSED [ 54%] +student-tests/test_messages_api.py::test_cursor_from_another_chat_returns_400 PASSED [ 56%] +student-tests/test_messages_api.py::test_invalid_limit_returns_400 PASSED [ 59%] +student-tests/test_session_cache.py::test_login_puts_session_into_cache_without_secrets PASSED [ 61%] +student-tests/test_session_cache.py::test_cached_session_is_served_without_database PASSED [ 63%] +student-tests/test_session_cache.py::test_cache_miss_reads_database_once_and_fills_cache PASSED [ 65%] +student-tests/test_session_cache.py::test_logout_revokes_cached_session PASSED [ 68%] +student-tests/test_session_cache.py::test_slow_reader_cannot_resurrect_session_after_logout PASSED [ 70%] +student-tests/test_session_cache.py::test_revoked_token_from_database_is_not_cached PASSED [ 72%] +student-tests/test_session_cache.py::test_redis_down_falls_back_to_database PASSED [ 75%] +student-tests/test_session_cache.py::test_redis_down_does_not_slow_every_request PASSED [ 77%] +student-tests/test_session_cache.py::test_cache_comes_back_after_redis_recovers PASSED [ 79%] +student-tests/test_users_api.py::test_invalid_json_returns_400 PASSED [ 81%] +student-tests/test_users_api.py::test_extra_field_and_wrong_type_return_400 PASSED [ 84%] +student-tests/test_users_api.py::test_duplicate_username_returns_409 PASSED [ 86%] +student-tests/test_users_api.py::test_unicode_display_name_is_kept PASSED [ 88%] +student-tests/test_users_api.py::test_password_is_required_and_length_checked PASSED [ 90%] +student-tests/test_users_api.py::test_password_is_hashed_and_never_returned PASSED [ 93%] +student-tests/test_users_api.py::test_me_returns_current_user PASSED [ 95%] +student-tests/test_users_api.py::test_x_user_id_no_longer_authenticates PASSED [ 97%] +student-tests/test_users_api.py::test_every_response_has_request_id PASSED [100%] + +============================= 44 passed in 39.30s ============================= +exit=0 diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..915d1057 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,7 @@ +# 2026-10-29T13:55:32 base commit 5ce43c3 (+ Redis/level-4 changes); stack: api + postgres + redis +$ python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +exit=0 +$ python tests/smoke.py --base-url http://localhost:8080 +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. +exit=0 diff --git a/evidence/track2-backup-restore.json b/evidence/track2-backup-restore.json new file mode 100644 index 00000000..52900684 --- /dev/null +++ b/evidence/track2-backup-restore.json @@ -0,0 +1,62 @@ +{ + "generated_at": "2026-10-29T12:35:58Z", + "source": "compose service postgres, database messenger_bench", + "target": "new container mtusi-lab2-restore-check (same image, empty volume mtusi-lab2-restore-check-data, no published ports)", + "backup": { + "tool": "pg_dump -Fc (one consistent snapshot)", + "seconds": 2.23, + "bytes": 6480746, + "sha256": "4b01c0959421964e0ce0a3e12f673cbb94717ced122a4d070ff14d9d959b815a" + }, + "restore": { + "tool": "pg_restore -j 4 --no-owner --no-privileges + ANALYZE", + "container_start_seconds": 7.39, + "restore_seconds": 6.59, + "rto_seconds": 13.98, + "restored_database_size": "75 MB" + }, + "verification": { + "row_counts_equal": true, + "table_md5_equal": true, + "sample_messages_equal": true, + "sample_size": 36, + "counts": { + "alembic_version": 1, + "users": 300, + "sessions": 0, + "chats": 555, + "chat_members": 2216, + "messages": 105000 + }, + "md5_source": { + "alembic_version": "3cbb53ae3485d46443b969ffd1937453", + "users": "a103f13c50fd6edec2002008237c1821", + "sessions": "empty", + "chats": "abe832994eb322fd0f751e9fb616c98b", + "chat_members": "07c4e6a49afe0c4cbbd38866f89e284b", + "messages": "a1fd01da121bf535f2e84d2cb05c6831" + }, + "md5_restored": { + "alembic_version": "3cbb53ae3485d46443b969ffd1937453", + "users": "a103f13c50fd6edec2002008237c1821", + "sessions": "empty", + "chats": "abe832994eb322fd0f751e9fb616c98b", + "chat_members": "07c4e6a49afe0c4cbbd38866f89e284b", + "messages": "a1fd01da121bf535f2e84d2cb05c6831" + }, + "alembic_version_source": "0001", + "alembic_version_restored": "0001", + "indexes_on_messages": [ + "messages_chat_history_idx", + "messages_pkey" + ], + "history_query_plan_on_restored": "Limit (cost=0.42..24.71 rows=51 width=531) (actual time=0.188..1.148 rows=51 loops=1)\n Buffers: shared hit=51 read=4\n -> Index Scan using messages_chat_history_idx on messages (cost=0.42..28505.57 rows=59853 width=531) (actual time=0.186..1.134 rows=51 loops=1)\n Index Cond: (chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid)\n Buffers: shared hit=51 read=4\nPlanning:\n Buffers: shared hit=146\nPlanning Time: 5.411 ms\nExecution Time: 1.258 ms" + }, + "data_loss_boundary": { + "messages_in_backup": 105000, + "messages_written_after_backup": 100, + "messages_in_source_at_failure_time": 105100, + "late_messages_present_in_restore": 0, + "lost_if_restored_from_this_backup": 100 + } +} diff --git a/evidence/track2-indexes-run1.json b/evidence/track2-indexes-run1.json new file mode 100644 index 00000000..e81cd479 --- /dev/null +++ b/evidence/track2-indexes-run1.json @@ -0,0 +1,385 @@ +{ + "generated_at": "2026-10-29T11:15:19Z", + "database": "messenger_bench", + "postgres_settings": { + "server_version": "17.10", + "shared_buffers": "128MB", + "work_mem": "4MB", + "random_page_cost": "4", + "synchronous_commit": "on" + }, + "messages_total": 105000, + "chat_classes": [ + { + "class": "huge", + "chats": 1, + "messages_each": 60000 + }, + { + "class": "medium", + "chats": 4, + "messages_each": 5000 + }, + { + "class": "small", + "chats": 50, + "messages_each": 300 + }, + { + "class": "tiny", + "chats": 500, + "messages_each": 20 + } + ], + "representative_chats": [ + { + "class": "huge", + "messages": 60000 + }, + { + "class": "medium", + "messages": 5000 + }, + { + "class": "small", + "messages": 300 + }, + { + "class": "tiny", + "messages": 20 + } + ], + "data_loaded_this_run": false, + "load_seconds": null, + "runs_per_query": 15, + "page_limit": 51, + "variants": { + "none": { + "index_bytes": 0, + "table_bytes": 60137472, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 45.406, + "p95_ms": 50.12, + "buffers": 7423, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 37.304, + "p95_ms": 40.512, + "buffers": 7365, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 29.434, + "p95_ms": 42.16, + "buffers": 7335, + "plan": "Limit -> Sort -> Seq Scan" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 36.372, + "p95_ms": 49.917, + "buffers": 7365, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 26.969, + "p95_ms": 31.007, + "buffers": 7335, + "plan": "Limit -> Sort -> Seq Scan" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 31.33, + "p95_ms": 33.104, + "buffers": 7365, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 25.529, + "p95_ms": 29.511, + "buffers": 7335, + "plan": "Limit -> Sort -> Seq Scan" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 35.777, + "p95_ms": 45.186, + "buffers": 7365, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.611, + 2.51, + 2.599 + ], + "bulk_seconds": 2.599, + "bulk_rows_per_second": 7695, + "bulk_wal_bytes_per_row": 671, + "single_rows": 1000, + "single_latency_ms_median": 4.626, + "single_latency_ms_p95": 5.489, + "single_wal_bytes_per_row": 313 + } + }, + "chat_id": { + "index_bytes": 770048, + "table_bytes": 60137472, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 47.125, + "p95_ms": 64.228, + "buffers": 7423, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 27.676, + "p95_ms": 29.85, + "buffers": 4248, + "plan": "Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx)" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 3.352, + "p95_ms": 5.07, + "buffers": 379, + "plan": "Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx)" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 2.615, + "p95_ms": 2.993, + "buffers": 379, + "plan": "Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx)" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 0.586, + "p95_ms": 0.647, + "buffers": 25, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 0.313, + "p95_ms": 0.343, + "buffers": 25, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 0.169, + "p95_ms": 0.258, + "buffers": 4, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 0.175, + "p95_ms": 0.185, + "buffers": 4, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.701, + 2.651, + 2.689 + ], + "bulk_seconds": 2.689, + "bulk_rows_per_second": 7438, + "bulk_wal_bytes_per_row": 747, + "single_rows": 1000, + "single_latency_ms_median": 5.317, + "single_latency_ms_p95": 6.276, + "single_wal_bytes_per_row": 403 + } + }, + "chat_created_id": { + "index_bytes": 6201344, + "table_bytes": 60137472, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 0.26, + "p95_ms": 0.321, + "buffers": 54, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 0.252, + "p95_ms": 0.381, + "buffers": 54, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 0.201, + "p95_ms": 0.298, + "buffers": 54, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 0.233, + "p95_ms": 0.329, + "buffers": 54, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 0.183, + "p95_ms": 0.288, + "buffers": 53, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 0.177, + "p95_ms": 0.247, + "buffers": 31, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 0.135, + "p95_ms": 0.204, + "buffers": 17, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 0.164, + "p95_ms": 0.301, + "buffers": 4, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "huge/first/OFFSET": { + "chat_messages": 60000, + "median_ms": 0.249, + "p95_ms": 0.378, + "buffers": 54, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "huge/deep_90pct/OFFSET": { + "chat_messages": 60000, + "median_ms": 262.605, + "p95_ms": 267.052, + "buffers": 7423, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.712, + 3.025, + 2.641 + ], + "bulk_seconds": 2.712, + "bulk_rows_per_second": 7375, + "bulk_wal_bytes_per_row": 820, + "single_rows": 1000, + "single_latency_ms_median": 4.708, + "single_latency_ms_p95": 6.076, + "single_wal_bytes_per_row": 457 + } + }, + "covering": { + "index_bytes": 30416896, + "table_bytes": 60137472, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 0.152, + "p95_ms": 0.246, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 0.182, + "p95_ms": 0.288, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 0.174, + "p95_ms": 0.269, + "buffers": 6, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 0.185, + "p95_ms": 0.27, + "buffers": 6, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 0.183, + "p95_ms": 0.27, + "buffers": 6, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 0.171, + "p95_ms": 0.215, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 0.165, + "p95_ms": 0.282, + "buffers": 4, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 0.152, + "p95_ms": 0.188, + "buffers": 4, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.958, + 3.204, + 2.822 + ], + "bulk_seconds": 2.958, + "bulk_rows_per_second": 6761, + "bulk_wal_bytes_per_row": 1232, + "single_rows": 1000, + "single_latency_ms_median": 4.679, + "single_latency_ms_p95": 5.922, + "single_wal_bytes_per_row": 557 + } + } + }, + "total_seconds": 87.6 +} diff --git a/evidence/track2-indexes-run1.md b/evidence/track2-indexes-run1.md new file mode 100644 index 00000000..63f31f15 --- /dev/null +++ b/evidence/track2-indexes-run1.md @@ -0,0 +1,34 @@ +# Трек 2: индексы истории (2026-10-29T11:15:19Z) + +PostgreSQL 17.10, shared_buffers 128MB, work_mem 4MB; 105000 сообщений; медиана из 15 замеров, тёплый кэш. + +## Чтение страницы истории (запрос API), медиана мс / буферы + +| чат (сообщений) / страница | none | chat_id | chat_created_id | covering | +| --- | --- | --- | --- | --- | +| huge/first (60000) | 45.406 / 7423 | 47.125 / 7423 | 0.26 / 54 | 0.152 / 5 | +| huge/deep_90pct (60000) | 37.304 / 7365 | 27.676 / 4248 | 0.252 / 54 | 0.182 / 5 | +| medium/first (5000) | 29.434 / 7335 | 3.352 / 379 | 0.201 / 54 | 0.174 / 6 | +| medium/deep_90pct (5000) | 36.372 / 7365 | 2.615 / 379 | 0.233 / 54 | 0.185 / 6 | +| small/first (300) | 26.969 / 7335 | 0.586 / 25 | 0.183 / 53 | 0.183 / 6 | +| small/deep_90pct (300) | 31.33 / 7365 | 0.313 / 25 | 0.177 / 31 | 0.171 / 5 | +| tiny/first (20) | 25.529 / 7335 | 0.169 / 4 | 0.135 / 17 | 0.165 / 4 | +| tiny/deep_90pct (20) | 35.777 / 7365 | 0.175 / 4 | 0.164 / 4 | 0.152 / 4 | +| huge/first/OFFSET (60000) | — | — | 0.249 / 54 | — | +| huge/deep_90pct/OFFSET (60000) | — | — | 262.605 / 7423 | — | + +## Узел плана (глубокая страница самого большого чата) + +- **none**: Limit -> Gather Merge -> Sort -> Seq Scan +- **chat_id**: Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx) +- **chat_created_id**: Limit -> Index Scan (messages_chat_history_idx) +- **covering**: Limit -> Index Only Scan (bench_history_covering_idx) + +## Размер и стоимость записи + +| вариант | индекс, MiB | bulk, строк/с | bulk WAL, байт/строку | одиночный INSERT+COMMIT p50 / p95, мс | одиночный WAL, байт/строку | +| --- | --- | --- | --- | --- | --- | +| none | 0.0 | 7695 | 671 | 4.626 / 5.489 | 313 | +| chat_id | 0.7 | 7438 | 747 | 5.317 / 6.276 | 403 | +| chat_created_id | 5.9 | 7375 | 820 | 4.708 / 6.076 | 457 | +| covering | 29.0 | 6761 | 1232 | 4.679 / 5.922 | 557 | diff --git a/evidence/track2-indexes-run2.json b/evidence/track2-indexes-run2.json new file mode 100644 index 00000000..f2158926 --- /dev/null +++ b/evidence/track2-indexes-run2.json @@ -0,0 +1,385 @@ +{ + "generated_at": "2026-10-29T12:34:53Z", + "database": "messenger_bench", + "postgres_settings": { + "server_version": "17.10", + "shared_buffers": "128MB", + "work_mem": "4MB", + "random_page_cost": "4", + "synchronous_commit": "on" + }, + "messages_total": 105000, + "chat_classes": [ + { + "class": "huge", + "chats": 1, + "messages_each": 60000 + }, + { + "class": "medium", + "chats": 4, + "messages_each": 5000 + }, + { + "class": "small", + "chats": 50, + "messages_each": 300 + }, + { + "class": "tiny", + "chats": 500, + "messages_each": 20 + } + ], + "representative_chats": [ + { + "class": "huge", + "messages": 60000 + }, + { + "class": "medium", + "messages": 5000 + }, + { + "class": "small", + "messages": 300 + }, + { + "class": "tiny", + "messages": 20 + } + ], + "data_loaded_this_run": true, + "load_seconds": 28.3, + "runs_per_query": 15, + "page_limit": 51, + "variants": { + "none": { + "index_bytes": 0, + "table_bytes": 60153856, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 85.401, + "p95_ms": 89.219, + "buffers": 7425, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 79.308, + "p95_ms": 94.264, + "buffers": 7367, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 29.138, + "p95_ms": 31.576, + "buffers": 7337, + "plan": "Limit -> Sort -> Seq Scan" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 82.038, + "p95_ms": 87.422, + "buffers": 7367, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 28.056, + "p95_ms": 39.0, + "buffers": 7337, + "plan": "Limit -> Sort -> Seq Scan" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 83.681, + "p95_ms": 98.374, + "buffers": 7367, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 26.3, + "p95_ms": 36.74, + "buffers": 7337, + "plan": "Limit -> Sort -> Seq Scan" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 78.407, + "p95_ms": 89.693, + "buffers": 7367, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.525, + 2.416, + 2.631 + ], + "bulk_seconds": 2.525, + "bulk_rows_per_second": 7919, + "bulk_wal_bytes_per_row": 673, + "single_rows": 1000, + "single_latency_ms_median": 4.655, + "single_latency_ms_p95": 5.628, + "single_wal_bytes_per_row": 313 + } + }, + "chat_id": { + "index_bytes": 770048, + "table_bytes": 60153856, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 83.848, + "p95_ms": 91.434, + "buffers": 7425, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 29.628, + "p95_ms": 36.168, + "buffers": 4248, + "plan": "Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx)" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 4.607, + "p95_ms": 5.011, + "buffers": 398, + "plan": "Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx)" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 2.937, + "p95_ms": 4.636, + "buffers": 398, + "plan": "Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx)" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 0.614, + "p95_ms": 0.846, + "buffers": 32, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 0.391, + "p95_ms": 0.501, + "buffers": 32, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 0.247, + "p95_ms": 0.443, + "buffers": 4, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 0.171, + "p95_ms": 0.224, + "buffers": 4, + "plan": "Limit -> Sort -> Index Scan (bench_chat_id_idx)" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.817, + 2.826, + 2.826 + ], + "bulk_seconds": 2.826, + "bulk_rows_per_second": 7077, + "bulk_wal_bytes_per_row": 746, + "single_rows": 1000, + "single_latency_ms_median": 5.336, + "single_latency_ms_p95": 6.237, + "single_wal_bytes_per_row": 403 + } + }, + "chat_created_id": { + "index_bytes": 6201344, + "table_bytes": 60153856, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 0.306, + "p95_ms": 0.455, + "buffers": 55, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 0.309, + "p95_ms": 0.361, + "buffers": 54, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 0.319, + "p95_ms": 0.459, + "buffers": 55, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 0.262, + "p95_ms": 0.509, + "buffers": 55, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 0.321, + "p95_ms": 0.381, + "buffers": 53, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 0.269, + "p95_ms": 0.351, + "buffers": 31, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 0.231, + "p95_ms": 0.378, + "buffers": 13, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 0.185, + "p95_ms": 0.225, + "buffers": 4, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "huge/first/OFFSET": { + "chat_messages": 60000, + "median_ms": 0.352, + "p95_ms": 0.476, + "buffers": 55, + "plan": "Limit -> Index Scan (messages_chat_history_idx)" + }, + "huge/deep_90pct/OFFSET": { + "chat_messages": 60000, + "median_ms": 300.29, + "p95_ms": 325.584, + "buffers": 7425, + "plan": "Limit -> Gather Merge -> Sort -> Seq Scan" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 2.929, + 2.957, + 2.978 + ], + "bulk_seconds": 2.957, + "bulk_rows_per_second": 6764, + "bulk_wal_bytes_per_row": 821, + "single_rows": 1000, + "single_latency_ms_median": 5.429, + "single_latency_ms_p95": 6.584, + "single_wal_bytes_per_row": 457 + } + }, + "covering": { + "index_bytes": 30416896, + "table_bytes": 60153856, + "reads": { + "huge/first": { + "chat_messages": 60000, + "median_ms": 0.217, + "p95_ms": 0.289, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "huge/deep_90pct": { + "chat_messages": 60000, + "median_ms": 0.232, + "p95_ms": 0.291, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "medium/first": { + "chat_messages": 5000, + "median_ms": 0.174, + "p95_ms": 0.289, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "medium/deep_90pct": { + "chat_messages": 5000, + "median_ms": 0.206, + "p95_ms": 0.272, + "buffers": 6, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "small/first": { + "chat_messages": 300, + "median_ms": 0.196, + "p95_ms": 0.225, + "buffers": 6, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "small/deep_90pct": { + "chat_messages": 300, + "median_ms": 0.199, + "p95_ms": 0.263, + "buffers": 5, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "tiny/first": { + "chat_messages": 20, + "median_ms": 0.172, + "p95_ms": 0.263, + "buffers": 4, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + }, + "tiny/deep_90pct": { + "chat_messages": 20, + "median_ms": 0.159, + "p95_ms": 0.214, + "buffers": 4, + "plan": "Limit -> Index Only Scan (bench_history_covering_idx)" + } + }, + "writes": { + "bulk_rows": 20000, + "bulk_repeats": 3, + "bulk_seconds_each": [ + 3.179, + 3.103, + 3.091 + ], + "bulk_seconds": 3.103, + "bulk_rows_per_second": 6445, + "bulk_wal_bytes_per_row": 1230, + "single_rows": 1000, + "single_latency_ms_median": 4.845, + "single_latency_ms_p95": 6.264, + "single_wal_bytes_per_row": 558 + } + } + }, + "total_seconds": 125.1 +} diff --git a/evidence/track2-indexes-run2.md b/evidence/track2-indexes-run2.md new file mode 100644 index 00000000..4fe51848 --- /dev/null +++ b/evidence/track2-indexes-run2.md @@ -0,0 +1,34 @@ +# Трек 2: индексы истории (2026-10-29T12:34:53Z) + +PostgreSQL 17.10, shared_buffers 128MB, work_mem 4MB; 105000 сообщений; медиана из 15 замеров, тёплый кэш. + +## Чтение страницы истории (запрос API), медиана мс / буферы + +| чат (сообщений) / страница | none | chat_id | chat_created_id | covering | +| --- | --- | --- | --- | --- | +| huge/first (60000) | 85.401 / 7425 | 83.848 / 7425 | 0.306 / 55 | 0.217 / 5 | +| huge/deep_90pct (60000) | 79.308 / 7367 | 29.628 / 4248 | 0.309 / 54 | 0.232 / 5 | +| medium/first (5000) | 29.138 / 7337 | 4.607 / 398 | 0.319 / 55 | 0.174 / 5 | +| medium/deep_90pct (5000) | 82.038 / 7367 | 2.937 / 398 | 0.262 / 55 | 0.206 / 6 | +| small/first (300) | 28.056 / 7337 | 0.614 / 32 | 0.321 / 53 | 0.196 / 6 | +| small/deep_90pct (300) | 83.681 / 7367 | 0.391 / 32 | 0.269 / 31 | 0.199 / 5 | +| tiny/first (20) | 26.3 / 7337 | 0.247 / 4 | 0.231 / 13 | 0.172 / 4 | +| tiny/deep_90pct (20) | 78.407 / 7367 | 0.171 / 4 | 0.185 / 4 | 0.159 / 4 | +| huge/first/OFFSET (60000) | — | — | 0.352 / 55 | — | +| huge/deep_90pct/OFFSET (60000) | — | — | 300.29 / 7425 | — | + +## Узел плана (глубокая страница самого большого чата) + +- **none**: Limit -> Gather Merge -> Sort -> Seq Scan +- **chat_id**: Limit -> Sort -> Bitmap Heap Scan -> Bitmap Index Scan (bench_chat_id_idx) +- **chat_created_id**: Limit -> Index Scan (messages_chat_history_idx) +- **covering**: Limit -> Index Only Scan (bench_history_covering_idx) + +## Размер и стоимость записи + +| вариант | индекс, MiB | bulk, строк/с | bulk WAL, байт/строку | одиночный INSERT+COMMIT p50 / p95, мс | одиночный WAL, байт/строку | +| --- | --- | --- | --- | --- | --- | +| none | 0.0 | 7919 | 673 | 4.655 / 5.628 | 313 | +| chat_id | 0.7 | 7077 | 746 | 5.336 / 6.237 | 403 | +| chat_created_id | 5.9 | 6764 | 821 | 5.429 / 6.584 | 457 | +| covering | 29.0 | 6445 | 1230 | 4.845 / 6.264 | 558 | diff --git a/evidence/track2-plans.txt b/evidence/track2-plans.txt new file mode 100644 index 00000000..440245ab --- /dev/null +++ b/evidence/track2-plans.txt @@ -0,0 +1,77 @@ +## none: huge chat (60000 msgs), deep page (90%), API query +Limit (cost=9183.85..9189.80 rows=51 width=532) (actual time=67.276..87.978 rows=51 loops=1) + Buffers: shared hit=7367 + -> Gather Merge (cost=9183.85..9751.83 rows=4868 width=532) (actual time=67.273..87.966 rows=51 loops=1) + Workers Planned: 2 + Workers Launched: 2 + Buffers: shared hit=7367 + -> Sort (cost=8183.83..8189.91 rows=2434 width=532) (actual time=13.388..13.393 rows=17 loops=3) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 85kB + Buffers: shared hit=7367 + Worker 0: Sort Method: quicksort Memory: 25kB + Worker 1: Sort Method: quicksort Memory: 25kB + -> Parallel Seq Scan on messages (cost=0.00..8102.62 rows=2434 width=532) (actual time=0.009..12.206 rows=2000 loops=3) + Filter: ((chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 01:41:51.032324+00'::timestamp with time zone, 'db8caccb-93cc-4062-b61e-ddeb6b88f5c4'::uuid))) + Rows Removed by Filter: 33000 + Buffers: shared hit=7337 +Planning Time: 0.290 ms +Execution Time: 88.155 ms + +## chat_id: huge chat (60000 msgs), deep page (90%), API query +Limit (cost=9260.53..9260.66 rows=51 width=532) (actual time=26.160..26.180 rows=51 loops=1) + Buffers: shared hit=4248 + -> Sort (cost=9260.53..9275.84 rows=6124 width=532) (actual time=26.158..26.170 rows=51 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 85kB + Buffers: shared hit=4248 + -> Bitmap Heap Scan on messages (cost=668.24..9056.22 rows=6124 width=532) (actual time=5.633..24.171 rows=5999 loops=1) + Recheck Cond: (chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid) + Filter: (ROW(created_at, id) > ROW('2026-09-28 01:41:51.032324+00'::timestamp with time zone, 'db8caccb-93cc-4062-b61e-ddeb6b88f5c4'::uuid)) + Rows Removed by Filter: 54001 + Heap Blocks: exact=4194 + Buffers: shared hit=4248 + -> Bitmap Index Scan on bench_chat_id_idx (cost=0.00..666.71 rows=60056 width=0) (actual time=4.493..4.493 rows=60000 loops=1) + Index Cond: (chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid) + Buffers: shared hit=54 +Planning Time: 0.143 ms +Execution Time: 26.636 ms + +## chat_created_id: huge chat, OFFSET 54000 (NOT used by the API) +Limit (cost=22459.09..22459.20 rows=1 width=532) (actual time=259.657..291.046 rows=51 loops=1) + Buffers: shared hit=7425, temp read=3869 written=3991 + -> Gather Merge (cost=16653.81..22459.09 rows=49756 width=532) (actual time=171.715..286.418 rows=54051 loops=1) + Workers Planned: 2 + Workers Launched: 2 + Buffers: shared hit=7425, temp read=3869 written=3991 + -> Sort (cost=15653.79..15715.99 rows=24878 width=532) (actual time=124.502..136.749 rows=18090 loops=3) + Sort Key: created_at, id + Sort Method: external merge Disk: 14880kB + Buffers: shared hit=7425, temp read=3869 written=3991 + Worker 0: Sort Method: external merge Disk: 8488kB + Worker 1: Sort Method: external merge Disk: 8472kB + -> Parallel Seq Scan on messages (cost=0.00..7883.88 rows=24878 width=532) (actual time=0.039..16.722 rows=20000 loops=3) + Filter: (chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid) + Rows Removed by Filter: 15000 + Buffers: shared hit=7337 +Planning Time: 0.145 ms +Execution Time: 311.469 ms + +## chat_created_id: huge chat (60000 msgs), deep page (90%), API query +Limit (cost=0.42..125.73 rows=51 width=532) (actual time=0.062..0.155 rows=51 loops=1) + Buffers: shared hit=54 + -> Index Scan using messages_chat_history_idx on messages (cost=0.42..14974.22 rows=6094 width=532) (actual time=0.061..0.147 rows=51 loops=1) + Index Cond: ((chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 01:41:51.032324+00'::timestamp with time zone, 'db8caccb-93cc-4062-b61e-ddeb6b88f5c4'::uuid))) + Buffers: shared hit=54 +Planning Time: 0.188 ms +Execution Time: 0.264 ms + +## covering: huge chat (60000 msgs), deep page (90%), API query +Limit (cost=0.42..8.67 rows=51 width=529) (actual time=0.077..0.104 rows=51 loops=1) + Buffers: shared hit=5 + -> Index Only Scan using bench_history_covering_idx on messages (cost=0.42..986.22 rows=6090 width=529) (actual time=0.076..0.095 rows=51 loops=1) + Index Cond: ((chat_id = '58d533ef-79b6-4078-a5b2-286c4076859e'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 01:41:51.032324+00'::timestamp with time zone, 'db8caccb-93cc-4062-b61e-ddeb6b88f5c4'::uuid))) + Heap Fetches: 0 + Buffers: shared hit=5 +Planning Time: 0.145 ms +Execution Time: 0.187 ms diff --git a/requirements.txt b/requirements.txt index 8bbaec33..086b2bb5 100644 --- a/requirements.txt +++ b/requirements.txt @@ -24,3 +24,4 @@ argon2-cffi-bindings==26.1.0 cffi==2.1.1 pycparser==3.11 PyJWT==2.15.1 +redis==8.0.1 diff --git a/scripts/explain_history.py b/scripts/explain_history.py new file mode 100644 index 00000000..110454ce --- /dev/null +++ b/scripts/explain_history.py @@ -0,0 +1,161 @@ +#!/usr/bin/env python3 +"""EXPLAIN (ANALYZE, BUFFERS) запроса истории сообщений на синтетических данных (уровень 4). + +Создаёт пользователей explain_*, один большой чат (по умолчанию 12 000 сообщений) и несколько +маленьких, затем анализирует ТОТ ЖЕ запрос, что выполняет API (database_functions.history_query): +первая, средняя и последняя страница большого чата, первая страница маленького и, для сравнения, +OFFSET-пагинация до той же глубины. Повторный запуск сначала удаляет данные прошлого запуска. + +Запуск из venv при поднятом PostgreSQL (настройки из .env): + .venv/Scripts/python.exe scripts/explain_history.py --output evidence/explain-history.txt +""" +import argparse +import re +import sys +import uuid +from datetime import datetime, timezone +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'app')) + +from sqlalchemy import text # noqa: E402 +from sqlalchemy.dialects import postgresql # noqa: E402 + +from core.db import engine # noqa: E402 +from database_functions.messages_functions import history_query # noqa: E402 + +PAGE = 50 # limit по умолчанию в API + + +def cleanup(conn): + conn.execute(text(""" + DELETE FROM messages WHERE sender_id IN (SELECT id FROM users WHERE username LIKE 'explain\\_%'); + DELETE FROM chat_members WHERE user_id IN (SELECT id FROM users WHERE username LIKE 'explain\\_%'); + DELETE FROM chats c WHERE NOT EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id) + AND c.title LIKE 'explain %'; + DELETE FROM users WHERE username LIKE 'explain\\_%'; + """)) + + +def create_chat(conn, title, members): + chat_id = conn.scalar(text("INSERT INTO chats (title) VALUES (:t) RETURNING id"), {"t": title}) + for user_id in members: + conn.execute(text("INSERT INTO chat_members (chat_id, user_id) VALUES (:c, :u)"), {"c": chat_id, "u": user_id}) + return chat_id + + +def fill(conn, chat_id, a, b, n): + # Разные created_at (шаг 1 мс), отправители чередуются; id — gen_random_uuid() по умолчанию. + conn.execute(text(""" + INSERT INTO messages (chat_id, sender_id, created_at, text) + SELECT :chat, CASE WHEN g % 2 = 0 THEN CAST(:a AS uuid) ELSE CAST(:b AS uuid) END, + clock_timestamp() - (:n - g) * interval '1 millisecond', 'сообщение ' || g + FROM generate_series(1, :n) AS g + """), {"chat": chat_id, "a": a, "b": b, "n": n}) + + +def position(conn, chat_id, index): + """(created_at, id) сообщения с порядковым номером index (0-based) — то, что лежит в курсоре.""" + row = conn.execute(text(""" + SELECT created_at, id FROM messages WHERE chat_id = :c + ORDER BY created_at, id OFFSET :i LIMIT 1 + """), {"c": chat_id, "i": index}).one() + return row.created_at, row.id + + +def explain(conn, sql, params): + rows = conn.exec_driver_sql("EXPLAIN (ANALYZE, BUFFERS) " + sql, params).all() + return "\n".join(r[0] for r in rows) + + +def app_query(chat_id, after): + compiled = history_query(chat_id, PAGE, after).compile(dialect=postgresql.psycopg.dialect()) + return str(compiled), compiled.params + + +def summarize(plan): + node = re.search(r"(Index Scan using \S+|Index Only Scan using \S+|Seq Scan on \S+|Bitmap Heap Scan on \S+)", plan) + rows_removed = sum(int(x) for x in re.findall(r"Rows Removed by Filter: (\d+)", plan)) + # Первая строка Buffers относится к верхнему узлу плана и включает всё, что под ним. + top = re.search(r"Buffers: ([^\n]*)", plan) + top = top.group(1) if top else "" + hits = sum(int(x) for x in re.findall(r"hit=(\d+)", top)) + reads = sum(int(x) for x in re.findall(r"read=(\d+)", top)) + exec_ms = re.search(r"Execution Time: ([\d.]+) ms", plan) + return {"node": node.group(1) if node else "?", "rows_removed_by_filter": rows_removed, + "top_buffers_hit": hits, "top_buffers_read": reads, + "execution_ms": float(exec_ms.group(1)) if exec_ms else None} + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument('--big', type=int, default=12000, help='сообщений в большом чате') + p.add_argument('--small-chats', type=int, default=20) + p.add_argument('--small', type=int, default=500, help='сообщений в каждом маленьком чате') + p.add_argument('--output', default=str(ROOT / 'evidence' / 'explain-history.txt')) + args = p.parse_args() + + tag = uuid.uuid4().hex[:8] + with engine.begin() as conn: + cleanup(conn) + a = conn.scalar(text("INSERT INTO users (username, display_name, password_hash) " + "VALUES (:u, 'Explain A', 'not-a-login') RETURNING id"), {"u": f"explain_a_{tag}"}) + b = conn.scalar(text("INSERT INTO users (username, display_name, password_hash) " + "VALUES (:u, 'Explain B', 'not-a-login') RETURNING id"), {"u": f"explain_b_{tag}"}) + big = create_chat(conn, "explain big", [a, b]) + fill(conn, big, a, b, args.big) + small = None + for i in range(args.small_chats): + small = create_chat(conn, f"explain small {i}", [a, b]) + fill(conn, small, a, b, args.small) + with engine.begin() as conn: + conn.execute(text("ANALYZE messages")) + + out = [] + with engine.connect() as conn: + total = conn.scalar(text("SELECT count(*) FROM messages")) + size = conn.scalar(text("SELECT pg_size_pretty(pg_total_relation_size('messages'))")) + indexes = conn.execute(text("SELECT indexdef FROM pg_indexes WHERE tablename = 'messages' ORDER BY indexname")).all() + version = conn.scalar(text("SHOW server_version")) + out.append(f"# {datetime.now(timezone.utc):%Y-%m-%dT%H:%M:%SZ} PostgreSQL {version}") + out.append(f"# messages: {total} rows total, {size} with indexes; big chat {args.big}, " + f"{args.small_chats} small chats x {args.small}; ANALYZE done") + out += ["# indexes on messages:"] + ["# " + r[0] for r in indexes] + + cases = [ + ("1. big chat, first page (no cursor)", big, None), + ("2. big chat, middle page (cursor after #%d)" % (args.big // 2), big, position(conn, big, args.big // 2)), + ("3. big chat, last page (cursor after #%d)" % (args.big - PAGE - 1), big, + position(conn, big, args.big - PAGE - 1)), + ("4. small chat, first page", small, None), + ] + summary = [] + for title, chat_id, after in cases: + sql, params = app_query(chat_id, after) + plan = explain(conn, sql, params) + summary.append((title, summarize(plan))) + out += ["", "## " + title, "-- SQL generated by the API (history_query):", sql, "", plan] + + # Для сравнения: та же глубина через OFFSET — так API НЕ делает. + offset_sql = ("SELECT * FROM messages WHERE chat_id = %(c)s ORDER BY created_at, id " + "OFFSET %(o)s LIMIT %(l)s") + plan = explain(conn, offset_sql, {"c": big, "o": args.big - PAGE - 1, "l": PAGE + 1}) + title = "5. for comparison: OFFSET pagination to the same depth as case 3 (NOT used by the API)" + summary.append((title, summarize(plan))) + out += ["", "## " + title, offset_sql, "", plan] + + head = ["", "# SUMMARY (top node, rows removed by filter, buffers of the top node, execution time)"] + for title, s in summary: + head.append(f"# {title}: {s['node']}; removed={s['rows_removed_by_filter']}; " + f"buffers hit={s['top_buffers_hit']} read={s['top_buffers_read']}; {s['execution_ms']} ms") + text_out = "\n".join(out[:5] + head + out[5:]) + "\n" + dest = Path(args.output) + dest.parent.mkdir(parents=True, exist_ok=True) + dest.write_text(text_out, encoding="utf-8") + print("\n".join(head)) + print("written", dest) + + +if __name__ == '__main__': + main() diff --git a/scripts/failure_experiment.py b/scripts/failure_experiment.py new file mode 100644 index 00000000..95c2863d --- /dev/null +++ b/scripts/failure_experiment.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +"""Эксперимент отказа хранилищ под нагрузкой (уровень 4). Стенд должен быть запущен. + + redis Redis останавливается на --down секунд: ожидаем 0 ошибок (сессии из PostgreSQL), + после запуска кэш снова заполняется. + postgres PostgreSQL останавливается: ожидаем быстрый ограниченный 503 (не зависание), живой + /health/live, 503 /health/ready и восстановление без перезапуска API. + +Нагрузка: потоки по кругу делают GET /users/me (путь проверки сессии) и POST сообщения. +Результат (без токенов) пишется в evidence/failure-.json. +""" +import argparse +import json +import math +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) +from client import Client, Failure # noqa: E402 + +REDIS_CLI = 'redis-cli -a "$(cat /run/secrets/redis_password)" --no-auth-warning' + + +def compose(*args, timeout=120): + proc = subprocess.run(['docker', 'compose', *args], cwd=ROOT, capture_output=True, text=True, + encoding='utf-8', errors='replace', timeout=timeout) + return proc.returncode, (proc.stdout + proc.stderr).strip() + + +def redis_keys(): + code, out = compose('exec', '-T', 'redis', 'sh', '-c', REDIS_CLI + ' --scan --pattern "session:*" | wc -l') + return int(out.split()[-1]) if code == 0 and out.split() and out.split()[-1].isdigit() else None + + +def percentile(values, p): + values = sorted(values) + return round(1000 * values[max(0, math.ceil(p * len(values)) - 1)], 1) if values else None + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument('service', choices=['redis', 'postgres']) + p.add_argument('--base-url', default='http://localhost:8080') + p.add_argument('--workers', type=int, default=4) + p.add_argument('--before', type=float, default=5) + p.add_argument('--down', type=float, default=10) + p.add_argument('--after', type=float, default=10) + p.add_argument('--output', default=str(ROOT / 'evidence')) + args = p.parse_args() + + c = Client(args.base_url) + alice, bob, eve, chat = c.bootstrap() + path = '/api/v1/chats/' + chat['id'] + '/messages' + events, lock, stop = [], threading.Lock(), threading.Event() + t0 = time.monotonic() + + def record(kind, start, status): + with lock: + events.append((round(start - t0, 3), round(time.monotonic() - t0, 3), kind, status)) + + def worker(): + local = Client(args.base_url, timeout=5) + while not stop.is_set(): + for kind, call in ( + ('me', lambda: local.call('GET', '/api/v1/users/me', [200, 503], actor=alice)), + ('write', lambda: local.call('POST', path, [201, 503], actor=alice, + body={'text': 'отказ ' + uuid.uuid4().hex})), + ): + start = time.monotonic() + try: + record(kind, start, call()['status']) + except Failure: + record(kind, start, 'error') + + threads = [threading.Thread(target=worker, daemon=True) for _ in range(args.workers)] + for t in threads: + t.start() + time.sleep(args.before) + keys_before = redis_keys() if args.service == 'redis' else None + t_stop = time.monotonic() - t0 + code, out = compose('stop', args.service) + stop_seconds = round(time.monotonic() - t0 - t_stop, 2) + health_down = {} + time.sleep(2) + for name in ('live', 'ready'): + try: + health_down[name] = c.call('GET', '/health/' + name, [200, 503])['status'] + except Failure as exc: + health_down[name] = str(exc) + time.sleep(max(0, args.down - 2)) + t_start = time.monotonic() - t0 + compose('start', args.service) + if args.service == 'postgres': + compose('up', '-d', '--wait', 'postgres', timeout=120) + time.sleep(args.after) + stop.set() + for t in threads: + t.join(timeout=10) + end = time.monotonic() - t0 + keys_after = redis_keys() if args.service == 'redis' else None + _, logs = compose('logs', '--since', '2m', 'api') + warnings = [line.split('] ', 3)[-1] for line in logs.splitlines() if 'Redis недоступен' in line] + + def phase(lo, hi): + sel = [e for e in events if lo <= e[0] < hi] + result = {'seconds': round(hi - lo, 1)} + for kind in ('me', 'write'): + k = [e for e in sel if e[2] == kind] + statuses = {} + for e in k: + statuses[str(e[3])] = statuses.get(str(e[3]), 0) + 1 + ok = [e[1] - e[0] for e in k if e[3] in (200, 201)] + fail = [e[1] - e[0] for e in k if e[3] not in (200, 201)] + result[kind] = {'requests': len(k), 'statuses': statuses, + 'ok_latency_ms_p50': percentile(ok, .5), 'ok_latency_ms_p95': percentile(ok, .95), + 'failed_latency_ms_max': percentile(fail, 1.0)} + return result + + failures_after_start = [e for e in events if e[0] >= t_start and e[3] not in (200, 201)] + first_ok_after_start = min((e[1] for e in events if e[0] >= t_start and e[2] == 'write' + and e[3] == 201), default=None) + first_fail = min((e[1] for e in events if e[0] >= t_stop and e[3] not in (200, 201)), default=None) + report = { + 'service': args.service, + 'method': f'{args.workers} closed-loop workers: GET /users/me + POST message; client timeout 5 s; ' + f'docker compose stop {args.service} at t={t_stop:.1f}s, start at t={t_start:.1f}s', + 'docker_stop_seconds': stop_seconds, + 'health_while_down': health_down, + 'before': phase(0, t_stop), + 'while_down': phase(t_stop, t_start), + 'after_start': phase(t_start, end), + 'first_failure_seconds_after_stop': round(first_fail - t_stop, 2) if first_fail else None, + 'last_failure_seconds_after_start': round(max(e[1] for e in failures_after_start) - t_start, 2) + if failures_after_start else 0.0, + 'first_successful_write_seconds_after_start': round(first_ok_after_start - t_start, 2) + if first_ok_after_start else None, + 'redis_session_keys_before_after': [keys_before, keys_after], + 'api_log_redis_warnings': warnings[:5], + } + out_dir = Path(args.output) + out_dir.mkdir(parents=True, exist_ok=True) + dest = out_dir / f'failure-{args.service}.json' + dest.write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') + print(json.dumps(report, ensure_ascii=False, indent=2)) + print('written', dest) + + +if __name__ == '__main__': + main() diff --git a/scripts/init-secrets.ps1 b/scripts/init-secrets.ps1 index fa3fe6d5..7c325e12 100644 --- a/scripts/init-secrets.ps1 +++ b/scripts/init-secrets.ps1 @@ -16,4 +16,5 @@ function New-Secret($name, $bytes) { New-Secret 'postgres_password' 32 New-Secret 'jwt_secret' 64 +New-Secret 'redis_password' 32 if (-not (Test-Path .env)) { Copy-Item .env.example .env; 'created .env' } diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh index 192ccba3..e37e7d0a 100755 --- a/scripts/init-secrets.sh +++ b/scripts/init-secrets.sh @@ -15,4 +15,5 @@ make_secret() { make_secret postgres_password 32 make_secret jwt_secret 64 +make_secret redis_password 32 [ -f .env ] || { cp .env.example .env; echo "created .env"; } diff --git a/scripts/restart.cmd b/scripts/restart.cmd index 636349c7..c6eb90f1 100644 --- a/scripts/restart.cmd +++ b/scripts/restart.cmd @@ -3,6 +3,6 @@ rem Windows twin of scripts/restart.sh: the test cannot execute .sh on Windows. setlocal cd /d "%~dp0.." -docker compose stop api postgres || exit /b 1 +docker compose stop api postgres redis || exit /b 1 docker compose up -d --wait || exit /b 1 docker compose ps --format "{{.Name}} {{.Status}}" diff --git a/scripts/restart.sh b/scripts/restart.sh index 100578c9..85ca9356 100755 --- a/scripts/restart.sh +++ b/scripts/restart.sh @@ -1,9 +1,9 @@ #!/bin/sh -# Hook для make test-persistence: перезапуск API и PostgreSQL с сохранением volumes. +# Hook для make test-persistence: перезапуск API, PostgreSQL и Redis с сохранением volumes. set -eu cd "$(dirname "$0")/.." -docker compose stop api postgres -# Порядок: postgres (healthy) -> migrate (exit 0) -> api (healthy). +docker compose stop api postgres redis +# Порядок: postgres (healthy), redis (healthy) -> migrate (exit 0) -> api (healthy). docker compose up -d --wait docker compose ps --format '{{.Name}} {{.Status}}' diff --git a/scripts/track2_backup_restore.py b/scripts/track2_backup_restore.py new file mode 100644 index 00000000..2a2c1aa2 --- /dev/null +++ b/scripts/track2_backup_restore.py @@ -0,0 +1,215 @@ +#!/usr/bin/env python3 +"""Трек 2 (оценка «5»), часть 2: backup -> восстановление в НОВОЕ хранилище -> сверка. + +Источник — база messenger_bench (≈105 000 сообщений, см. scripts/track2_indexes.py) в контейнере +postgres из compose.yaml. + 1. «Отпечаток» источника: число строк и md5 содержимого каждой таблицы (строки по PK), + плюс выборка сообщений: первые/последние в чате каждого класса и 20 псевдослучайных. + 2. pg_dump -Fc (согласованный снимок в одной транзакции) -> backups/ (вне Git); время, размер, sha256. + 3. Граница потери данных (RPO): после дампа в источник пишутся ещё 100 сообщений — их в бэкапе нет. + 4. Новое хранилище: отдельный контейнер postgres того же образа со своим пустым volume, без портов + наружу; pg_restore -j 4. Замеряются запуск, восстановление и общее время (RTO). + 5. Сверка восстановленной базы с отпечатком: счётчики, md5 таблиц, выборка сообщений по полям, + версия миграций, индексы и план запроса истории. + 6. Временный контейнер и его volume удаляются (--keep оставляет), 100 «поздних» сообщений + из источника удаляются. + +Запуск (стенд lab2 поднят, данные бенчмарка есть): + python scripts/track2_backup_restore.py +Результаты: evidence/track2-backup-restore.json и .md +""" +import argparse +import hashlib +import json +import secrets +import subprocess +import time +from datetime import datetime, timezone +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +DB = 'messenger_bench' +IMAGE = 'postgres:17.10-alpine@sha256:979c4379dd698aba0b890599a6104e082035f98ef31d9b9291ec22f2b13059ca' +RESTORE_CONTAINER = 'mtusi-lab2-restore-check' +RESTORE_VOLUME = 'mtusi-lab2-restore-check-data' +# Таблица -> порядок строк для контрольной суммы (первичный ключ). +TABLES = { + 'alembic_version': 'version_num', + 'users': 'id', + 'sessions': 'token_hash', + 'chats': 'id', + 'chat_members': 'chat_id, user_id', + 'messages': 'id', +} +CLASSES = ['huge', 'medium', 'small', 'tiny'] + + +def run(args, timeout=600, **kwargs): + proc = subprocess.run(args, cwd=ROOT, capture_output=True, timeout=timeout, **kwargs) + if proc.returncode != 0: + raise SystemExit('FAIL: ' + ' '.join(args[:4]) + ': ' + proc.stderr.decode('utf-8', 'replace')[-400:]) + return proc.stdout + + +def source_container(): + return run(['docker', 'compose', 'ps', '-q', 'postgres']).decode().strip() + + +def psql(container, user, sql): + """Выполнить SQL внутри контейнера (локальный сокет, без пароля); строки с разделителем |.""" + out = run(['docker', 'exec', '-i', container, 'psql', '-U', user, '-d', DB, '-v', 'ON_ERROR_STOP=1', + '-At', '-F', '|', '-c', sql]) + return [line.split('|') for line in out.decode('utf-8').splitlines() if line] + + +def fingerprint(container, user, sample_ids): + counts = {t: int(psql(container, user, f'SELECT count(*) FROM {t}')[0][0]) for t in TABLES} + sums = {t: psql(container, user, f"SELECT coalesce(md5(string_agg(md5(x::text), '' ORDER BY {order})), 'empty')" + f" FROM {t} x")[0][0] for t, order in TABLES.items()} + ids = ",".join(f"'{i}'" for i in sample_ids) + rows = psql(container, user, "SELECT id, chat_id, sender_id, created_at, length(text), md5(text) " + f"FROM messages WHERE id IN ({ids}) ORDER BY id") + return {'counts': counts, 'md5': sums, 'sample': {r[0]: r[1:] for r in rows}} + + +def pick_sample(container, user): + ids = [] + for cls in CLASSES: + chat = psql(container, user, "SELECT c.id FROM chats c JOIN messages m ON m.chat_id = c.id " + f"WHERE c.title LIKE '{cls} %' GROUP BY c.id ORDER BY count(*) DESC LIMIT 1")[0][0] + for direction in ('ASC', 'DESC'): + ids += [r[0] for r in psql(container, user, f"SELECT id FROM messages WHERE chat_id = '{chat}' " + f"ORDER BY created_at {direction}, id {direction} LIMIT 2")] + ids += [r[0] for r in psql(container, user, "SELECT id FROM messages ORDER BY md5(id::text) LIMIT 20")] + return sorted(set(ids)) + + +def wait_ready(container, timeout=120): + """Официальный образ при первом старте поднимает временный сервер для init и перезапускается: + ждём сообщения об окончании init и затем pg_isready.""" + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + proc = subprocess.run(['docker', 'logs', container], capture_output=True) + logs = (proc.stdout + proc.stderr).decode('utf-8', 'replace') + if 'PostgreSQL init process complete' in logs and subprocess.run( + ['docker', 'exec', container, 'pg_isready', '-U', 'postgres'], capture_output=True).returncode == 0: + return + time.sleep(0.5) + raise SystemExit('FAIL: restore container did not become ready') + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument('--keep', action='store_true', help='не удалять временный контейнер восстановления') + p.add_argument('--late-writes', type=int, default=100, help='сообщений, записанных после бэкапа') + p.add_argument('--output', default=str(ROOT / 'evidence')) + args = p.parse_args() + + src = source_container() + if not src: + raise SystemExit('FAIL: postgres from compose.yaml is not running') + sample_ids = pick_sample(src, 'messenger') + before = fingerprint(src, 'messenger', sample_ids) + if before['counts']['messages'] < 100000: + raise SystemExit('FAIL: run scripts/track2_indexes.py first (need ≥100 000 messages)') + + # 1. Backup. + backups = ROOT / 'backups' + backups.mkdir(exist_ok=True) + dump = backups / f'{DB}.dump' + t = time.perf_counter() + with dump.open('wb') as out: + proc = subprocess.run(['docker', 'exec', src, 'pg_dump', '-U', 'messenger', '-d', DB, '-Fc'], + stdout=out, stderr=subprocess.PIPE, timeout=600) + if proc.returncode != 0: + raise SystemExit('FAIL: pg_dump: ' + proc.stderr.decode('utf-8', 'replace')[-400:]) + dump_seconds = time.perf_counter() - t + dump_sha = hashlib.sha256(dump.read_bytes()).hexdigest() + + # 2. Запись после бэкапа: эти сообщения при восстановлении из дампа будут потеряны (RPO). + chat, sender = psql(src, 'messenger', "SELECT chat_id, user_id FROM chat_members LIMIT 1")[0] + psql(src, 'messenger', f"INSERT INTO messages (chat_id, sender_id, text) SELECT '{chat}', '{sender}', " + f"'after-backup ' || g FROM generate_series(1, {args.late_writes}) g") + source_after = int(psql(src, 'messenger', "SELECT count(*) FROM messages")[0][0]) + + # 3. Новое хранилище и восстановление. + subprocess.run(['docker', 'rm', '-f', '-v', RESTORE_CONTAINER], capture_output=True) + subprocess.run(['docker', 'volume', 'rm', RESTORE_VOLUME], capture_output=True) + t_rto = time.perf_counter() + run(['docker', 'run', '-d', '--name', RESTORE_CONTAINER, '-v', f'{RESTORE_VOLUME}:/var/lib/postgresql/data', + '-e', 'POSTGRES_PASSWORD=' + secrets.token_urlsafe(24), IMAGE]) + wait_ready(RESTORE_CONTAINER) + start_seconds = time.perf_counter() - t_rto + t = time.perf_counter() + run(['docker', 'cp', str(dump), f'{RESTORE_CONTAINER}:/tmp/restore.dump']) + run(['docker', 'exec', RESTORE_CONTAINER, 'createdb', '-U', 'postgres', DB]) + run(['docker', 'exec', RESTORE_CONTAINER, 'pg_restore', '-U', 'postgres', '-d', DB, '-j', '4', + '--no-owner', '--no-privileges', '/tmp/restore.dump']) + run(['docker', 'exec', RESTORE_CONTAINER, 'psql', '-U', 'postgres', '-d', DB, '-c', 'ANALYZE']) + restore_seconds = time.perf_counter() - t + rto_seconds = time.perf_counter() - t_rto + + # 4. Сверка. + after = fingerprint(RESTORE_CONTAINER, 'postgres', sample_ids) + count_ok = before['counts'] == after['counts'] + md5_ok = before['md5'] == after['md5'] + sample_ok = before['sample'] == after['sample'] and len(after['sample']) == len(sample_ids) + indexes = [r[0] for r in psql(RESTORE_CONTAINER, 'postgres', + "SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY 1")] + huge = psql(RESTORE_CONTAINER, 'postgres', "SELECT c.id FROM chats c WHERE c.title = 'huge 0'")[0][0] + plan = "\n".join(r[0] for r in psql(RESTORE_CONTAINER, 'postgres', + "EXPLAIN (ANALYZE, BUFFERS) SELECT id, chat_id, sender_id, created_at, text " + f"FROM messages WHERE chat_id = '{huge}' ORDER BY created_at, id LIMIT 51")) + late_in_restore = int(psql(RESTORE_CONTAINER, 'postgres', + "SELECT count(*) FROM messages WHERE text LIKE 'after-backup %'")[0][0]) + restored_size = psql(RESTORE_CONTAINER, 'postgres', f"SELECT pg_size_pretty(pg_database_size('{DB}'))")[0][0] + source_version = psql(src, 'messenger', 'SELECT version_num FROM alembic_version')[0][0] + restored_version = psql(RESTORE_CONTAINER, 'postgres', 'SELECT version_num FROM alembic_version')[0][0] + + # 5. Уборка. + psql(src, 'messenger', "DELETE FROM messages WHERE text LIKE 'after-backup %'") + if not args.keep: + subprocess.run(['docker', 'rm', '-f', '-v', RESTORE_CONTAINER], capture_output=True) + subprocess.run(['docker', 'volume', 'rm', RESTORE_VOLUME], capture_output=True) + + report = { + 'generated_at': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'), + 'source': f'compose service postgres, database {DB}', 'target': f'new container {RESTORE_CONTAINER} ' + f'(same image, empty volume {RESTORE_VOLUME}, no published ports)', + 'backup': {'tool': 'pg_dump -Fc (one consistent snapshot)', 'seconds': round(dump_seconds, 2), + 'bytes': dump.stat().st_size, 'sha256': dump_sha}, + 'restore': {'tool': 'pg_restore -j 4 --no-owner --no-privileges + ANALYZE', + 'container_start_seconds': round(start_seconds, 2), 'restore_seconds': round(restore_seconds, 2), + 'rto_seconds': round(rto_seconds, 2), 'restored_database_size': restored_size}, + 'verification': { + 'row_counts_equal': count_ok, 'table_md5_equal': md5_ok, 'sample_messages_equal': sample_ok, + 'sample_size': len(sample_ids), 'counts': after['counts'], + 'md5_source': before['md5'], 'md5_restored': after['md5'], + 'alembic_version_source': source_version, + 'alembic_version_restored': restored_version, + 'indexes_on_messages': indexes, + 'history_query_plan_on_restored': plan, + }, + 'data_loss_boundary': { + 'messages_in_backup': before['counts']['messages'], + 'messages_written_after_backup': args.late_writes, + 'messages_in_source_at_failure_time': source_after, + 'late_messages_present_in_restore': late_in_restore, + 'lost_if_restored_from_this_backup': source_after - after['counts']['messages'], + }, + } + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + (out / 'track2-backup-restore.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n', + encoding='utf-8') + print(json.dumps({k: report[k] for k in ('backup', 'restore', 'data_loss_boundary')}, ensure_ascii=False, indent=2)) + v = report['verification'] + print('verification:', {k: v[k] for k in ('row_counts_equal', 'table_md5_equal', 'sample_messages_equal', + 'sample_size', 'indexes_on_messages')}) + if not (count_ok and md5_ok and sample_ok): + raise SystemExit('FAIL: restored data differs from the source snapshot') + print('PASS: backup restored into a new storage and verified') + + +if __name__ == '__main__': + main() diff --git a/scripts/track2_indexes.py b/scripts/track2_indexes.py new file mode 100644 index 00000000..1a1051f1 --- /dev/null +++ b/scripts/track2_indexes.py @@ -0,0 +1,314 @@ +#!/usr/bin/env python3 +"""Трек 2 (оценка «5»), часть 1: план запроса истории и стоимость записи для разных индексов. + +Гипотезы + H1. С индексом (chat_id, created_at, id) стоимость страницы истории не зависит ни от размера чата, + ни от глубины страницы; с индексом только по chat_id она растёт с размером чата (сортировка + всего чата), без индекса — с размером всей таблицы. + H2. Каждый индекс удорожает запись; покрывающий индекс с текстом — заметно сильнее остальных + (размер индекса, WAL), а выигрыш на чтении у него мал. + H3. OFFSET-пагинация дорожает с глубиной страницы, keyset — нет. + +Методика (повторяемая, фиксированный seed) + 1. Отдельная база messenger_bench, схема — миграциями Alembic (как в рабочей базе). + 2. ≥100 000 сообщений в чатах неравномерного размера: 1×60 000, 4×5 000, 50×300, 500×20; + случайные отправители из участников, случайное время за 30 дней (куча не упорядочена по времени), + текст 32–500 символов. VACUUM ANALYZE. + 3. Для каждого варианта индекса (единственный вторичный индекс на messages): + none | chat_id | chat_created_id (рабочий) | covering (chat_id, created_at, id) INCLUDE (sender_id, text) + — чтение: ТОТ ЖЕ запрос, что выполняет API (history_query), по чату каждого класса, первая и + «глубокая» (90%) страница; 3 прогона прогрева + N замеров EXPLAIN (ANALYZE, TIMING OFF, BUFFERS), + медиана и p95 Execution Time, буферы, узел плана; + — запись: bulk INSERT 20 000 строк в одной транзакции и 1 000 одиночных INSERT с COMMIT + (как делает API), время и объём WAL; затем вставленное удаляется и VACUUM. + 4. Для рабочего индекса дополнительно OFFSET-пагинация на той же глубине. + +Запуск из venv при поднятом postgres (настройки из .env): + .venv/Scripts/python.exe scripts/track2_indexes.py +Результаты: evidence/track2-indexes.json, evidence/track2-indexes.md, evidence/track2-plans.txt +""" +import argparse +import json +import os +import statistics +import subprocess +import sys +import time +from datetime import datetime, timezone +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +APP = ROOT / 'app' +sys.path.insert(0, str(APP)) + +import psycopg # noqa: E402 +from sqlalchemy.dialects import postgresql # noqa: E402 + +from core.config import settings # noqa: E402 +from database_functions.messages_functions import history_query # noqa: E402 + +BENCH_DB = 'messenger_bench' +PAGE = 50 +CLASSES = [('huge', 1, 60000), ('medium', 4, 5000), ('small', 50, 300), ('tiny', 500, 20)] +VARIANTS = { + 'none': None, + 'chat_id': 'CREATE INDEX bench_chat_id_idx ON messages (chat_id)', + 'chat_created_id': 'CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id)', + 'covering': 'CREATE INDEX bench_history_covering_idx ON messages (chat_id, created_at, id) INCLUDE (sender_id, text)', +} +TEXT_EXPR = "left(md5(g::text) || repeat(' слово', (random() * 80)::int), 500)" + + +def connect(dbname, autocommit=True): + cfg = settings.db + return psycopg.connect(host=cfg.host, port=cfg.port, dbname=dbname, user=cfg.user, + password=cfg.read_password(), autocommit=autocommit) + + +def prepare_database(rebuild): + with connect('postgres') as admin: + exists = admin.execute("SELECT 1 FROM pg_database WHERE datname = %s", (BENCH_DB,)).fetchone() + if exists and rebuild: + admin.execute(f'DROP DATABASE "{BENCH_DB}" WITH (FORCE)') + exists = None + if not exists: + admin.execute(f'CREATE DATABASE "{BENCH_DB}"') + # Схема — теми же миграциями, что и рабочая база. + env = dict(os.environ, APP_CONFIG__DB__NAME=BENCH_DB) + subprocess.run([sys.executable, '-m', 'alembic', 'upgrade', 'head'], cwd=APP, env=env, check=True, + capture_output=True) + + +def load_data(conn): + if conn.execute("SELECT count(*) FROM messages").fetchone()[0] > 0: + return False + conn.execute("SELECT setseed(0.42)") + conn.execute("""INSERT INTO users (username, display_name, password_hash) + SELECT 'bench_u' || g, 'Bench ' || g, 'not-a-login' FROM generate_series(1, 300) g""") + for cls, count, size in CLASSES: + for i in range(count): + chat = conn.execute("INSERT INTO chats (title) VALUES (%s) RETURNING id", (f'{cls} {i}',)).fetchone()[0] + members = 2 + i % 5 + conn.execute("""INSERT INTO chat_members (chat_id, user_id) + SELECT %s, id FROM users ORDER BY random() LIMIT %s""", (chat, members)) + conn.execute(f""" + INSERT INTO messages (chat_id, sender_id, created_at, text) + SELECT %(c)s, m.user_id, + timestamptz '2026-09-01 00:00:00+00' + random() * interval '30 days', {TEXT_EXPR} + FROM generate_series(1, %(n)s) AS g + CROSS JOIN LATERAL (SELECT user_id FROM chat_members + WHERE chat_id = %(c)s ORDER BY random() + g * 0 LIMIT 1) AS m + """, {'c': chat, 'n': size}) + conn.execute("VACUUM ANALYZE") + return True + + +def set_variant(conn, name): + for (index,) in conn.execute("""SELECT indexname FROM pg_indexes + WHERE tablename = 'messages' AND indexname <> 'messages_pkey'""").fetchall(): + conn.execute(f'DROP INDEX "{index}"') + if VARIANTS[name]: + conn.execute(VARIANTS[name]) + conn.execute("VACUUM ANALYZE messages") # visibility map нужна для Index Only Scan + row = conn.execute("""SELECT coalesce(sum(pg_relation_size(indexrelid)), 0) FROM pg_index + WHERE indrelid = 'messages'::regclass AND NOT indisprimary""").fetchone() + return int(row[0]) + + +def representative_chats(conn): + """Самый большой чат каждого класса: (класс, chat_id, число сообщений).""" + result = [] + for cls, _, _ in CLASSES: + row = conn.execute("""SELECT c.id, count(*) FROM chats c JOIN messages m ON m.chat_id = c.id + WHERE c.title LIKE %s GROUP BY c.id ORDER BY count(*) DESC LIMIT 1""", + (cls + ' %',)).fetchone() + result.append((cls, row[0], row[1])) + return result + + +def cursor_at(conn, chat_id, index): + return tuple(conn.execute("""SELECT created_at, id FROM messages WHERE chat_id = %s + ORDER BY created_at, id OFFSET %s LIMIT 1""", (chat_id, index)).fetchone()) + + +def app_sql(chat_id, after): + compiled = history_query(chat_id, PAGE, after).compile(dialect=postgresql.psycopg.dialect()) + return str(compiled), compiled.params + + +def measure(conn, sql, params, runs): + """Медиана/p95 Execution Time (без потаймерного оверхеда узлов), буферы и узел плана.""" + times, plan = [], None + for i in range(3 + runs): + doc = conn.execute("EXPLAIN (ANALYZE, TIMING OFF, BUFFERS, FORMAT JSON) " + sql, params).fetchone()[0][0] + if i >= 3: + times.append(doc['Execution Time']) + plan = doc + top = plan['Plan'] + node, cur = [], top + while cur: + node.append(cur['Node Type'] + (f" ({cur['Index Name']})" if 'Index Name' in cur else '')) + cur = (cur.get('Plans') or [None])[0] + times.sort() + return { + 'median_ms': round(statistics.median(times), 3), + 'p95_ms': round(times[max(0, int(0.95 * len(times)) - 1)], 3), + 'buffers': top.get('Shared Hit Blocks', 0) + top.get('Shared Read Blocks', 0), + 'plan': ' -> '.join(node), + } + + +def text_plan(conn, sql, params): + return "\n".join(r[0] for r in conn.execute("EXPLAIN (ANALYZE, BUFFERS) " + sql, params).fetchall()) + + +def wal_lsn(conn): + return conn.execute("SELECT pg_current_wal_insert_lsn()").fetchone()[0] + + +def wal_bytes(conn, start): + return int(conn.execute("SELECT pg_wal_lsn_diff(pg_current_wal_insert_lsn(), %s)", (start,)).fetchone()[0]) + + +def cleanup_writes(conn): + conn.execute("DELETE FROM messages WHERE text LIKE 'bench_w %'") + conn.execute("VACUUM ANALYZE messages") + + +def write_cost(conn, chat_id, sender_id, bulk_rows, single_rows, bulk_repeats=3): + # Bulk: одна транзакция, как импорт; несколько повторов, берём медиану. + bulk_times, bulk_wals = [], [] + for _ in range(bulk_repeats): + lsn = wal_lsn(conn) + t = time.perf_counter() + with conn.transaction(): + conn.execute(f"""INSERT INTO messages (chat_id, sender_id, created_at, text) + SELECT %s, %s, clock_timestamp(), 'bench_w ' || {TEXT_EXPR} + FROM generate_series(1, %s) AS g""", (chat_id, sender_id, bulk_rows)) + bulk_times.append(time.perf_counter() - t) + bulk_wals.append(wal_bytes(conn, lsn)) + cleanup_writes(conn) + bulk_s = statistics.median(bulk_times) + bulk_wal = statistics.median(bulk_wals) + # Одиночные: INSERT + COMMIT на каждое сообщение, как в API (synchronous_commit по умолчанию). + lsn = wal_lsn(conn) + latencies = [] + for g in range(single_rows): + t = time.perf_counter() + conn.execute("""INSERT INTO messages (chat_id, sender_id, text) + VALUES (%s, %s, 'bench_w одиночное ' || %s)""", (chat_id, sender_id, g)) + latencies.append(time.perf_counter() - t) + single_wal = wal_bytes(conn, lsn) + cleanup_writes(conn) + latencies.sort() + return { + 'bulk_rows': bulk_rows, 'bulk_repeats': bulk_repeats, + 'bulk_seconds_each': [round(x, 3) for x in bulk_times], 'bulk_seconds': round(bulk_s, 3), + 'bulk_rows_per_second': round(bulk_rows / bulk_s), 'bulk_wal_bytes_per_row': round(bulk_wal / bulk_rows), + 'single_rows': single_rows, + 'single_latency_ms_median': round(1000 * statistics.median(latencies), 3), + 'single_latency_ms_p95': round(1000 * latencies[int(0.95 * len(latencies)) - 1], 3), + 'single_wal_bytes_per_row': round(single_wal / single_rows), + } + + +def main(): + p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + p.add_argument('--runs', type=int, default=15, help='замеров на каждый запрос') + p.add_argument('--bulk', type=int, default=20000) + p.add_argument('--single', type=int, default=1000) + p.add_argument('--rebuild', action='store_true', help='пересоздать messenger_bench с нуля') + p.add_argument('--output', default=str(ROOT / 'evidence')) + args = p.parse_args() + + started = time.perf_counter() + prepare_database(args.rebuild) + with connect(BENCH_DB) as conn: + load_seconds = time.perf_counter() + loaded = load_data(conn) + load_seconds = round(time.perf_counter() - load_seconds, 1) + env = {k: conn.execute(f"SHOW {k}").fetchone()[0] + for k in ('server_version', 'shared_buffers', 'work_mem', 'random_page_cost', 'synchronous_commit')} + total = conn.execute("SELECT count(*) FROM messages").fetchone()[0] + chats = representative_chats(conn) + sender = conn.execute("SELECT user_id FROM chat_members WHERE chat_id = %s LIMIT 1", + (chats[0][1],)).fetchone()[0] + cursors = {cls: cursor_at(conn, chat, int(n * 0.9)) for cls, chat, n in chats} + + results, plans = {}, [] + for variant in VARIANTS: + index_bytes = set_variant(conn, variant) + table_bytes = conn.execute("SELECT pg_table_size('messages')").fetchone()[0] + reads = {} + for cls, chat, n in chats: + for page, after in (('first', None), ('deep_90pct', cursors[cls])): + sql, params = app_sql(chat, after) + reads[f'{cls}/{page}'] = {'chat_messages': n, **measure(conn, sql, params, args.runs)} + if variant == 'chat_created_id': + cls, chat, n = chats[0] + offset_sql = ("SELECT id, chat_id, sender_id, created_at, text FROM messages WHERE chat_id = %(c)s " + "ORDER BY created_at, id OFFSET %(o)s LIMIT %(l)s") + for page, depth in (('first', 0), ('deep_90pct', int(n * 0.9))): + reads[f'{cls}/{page}/OFFSET'] = { + 'chat_messages': n, **measure(conn, offset_sql, {'c': chat, 'o': depth, 'l': PAGE + 1}, args.runs)} + plans.append(f"## chat_created_id: huge chat, OFFSET {int(n * 0.9)} (NOT used by the API)\n" + + text_plan(conn, offset_sql, {'c': chat, 'o': int(n * 0.9), 'l': PAGE + 1})) + sql, params = app_sql(chats[0][1], cursors['huge']) + plans.append(f"## {variant}: huge chat ({chats[0][2]} msgs), deep page (90%), API query\n" + + text_plan(conn, sql, params)) + writes = write_cost(conn, chats[0][1], sender, args.bulk, args.single) + results[variant] = {'index_bytes': index_bytes, 'table_bytes': table_bytes, 'reads': reads, 'writes': writes} + print(f"{variant}: index {index_bytes / 2**20:.1f} MiB, huge deep {reads['huge/deep_90pct']['median_ms']} ms, " + f"bulk {writes['bulk_rows_per_second']} rows/s, single p50 {writes['single_latency_ms_median']} ms") + set_variant(conn, 'chat_created_id') # оставить базу с рабочим индексом + + report = { + 'generated_at': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'), + 'database': BENCH_DB, 'postgres_settings': env, 'messages_total': total, + 'chat_classes': [{'class': c, 'chats': k, 'messages_each': s} for c, k, s in CLASSES], + 'representative_chats': [{'class': c, 'messages': n} for c, _, n in chats], + 'data_loaded_this_run': loaded, 'load_seconds': load_seconds if loaded else None, + 'runs_per_query': args.runs, 'page_limit': PAGE + 1, + 'variants': results, 'total_seconds': round(time.perf_counter() - started, 1), + } + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + (out / 'track2-indexes.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') + (out / 'track2-plans.txt').write_text("\n\n".join(plans) + "\n", encoding='utf-8') + (out / 'track2-indexes.md').write_text(markdown(report), encoding='utf-8') + print(markdown(report)) + + +def markdown(r): + v = r['variants'] + lines = [f"# Трек 2: индексы истории ({r['generated_at']})", "", + f"PostgreSQL {r['postgres_settings']['server_version']}, shared_buffers {r['postgres_settings']['shared_buffers']}, " + f"work_mem {r['postgres_settings']['work_mem']}; {r['messages_total']} сообщений; " + f"медиана из {r['runs_per_query']} замеров, тёплый кэш.", "", + "## Чтение страницы истории (запрос API), медиана мс / буферы", "", + "| чат (сообщений) / страница | " + " | ".join(v) + " |", + "| --- |" + " --- |" * len(v)] + keys = [k for k in v['chat_created_id']['reads']] + for key in keys: + cells = [] + for name in v: + m = v[name]['reads'].get(key) + cells.append(f"{m['median_ms']} / {m['buffers']}" if m else "—") + n = v['chat_created_id']['reads'][key]['chat_messages'] + lines.append(f"| {key} ({n}) | " + " | ".join(cells) + " |") + lines += ["", "## Узел плана (глубокая страница самого большого чата)", ""] + for name in v: + lines.append(f"- **{name}**: {v[name]['reads']['huge/deep_90pct']['plan']}") + lines += ["", "## Размер и стоимость записи", "", + "| вариант | индекс, MiB | bulk, строк/с | bulk WAL, байт/строку | одиночный INSERT+COMMIT p50 / p95, мс | одиночный WAL, байт/строку |", + "| --- | --- | --- | --- | --- | --- |"] + for name in v: + w = v[name]['writes'] + lines.append(f"| {name} | {v[name]['index_bytes'] / 2**20:.1f} | {w['bulk_rows_per_second']} | " + f"{w['bulk_wal_bytes_per_row']} | {w['single_latency_ms_median']} / {w['single_latency_ms_p95']} | " + f"{w['single_wal_bytes_per_row']} |") + return "\n".join(lines) + "\n" + + +if __name__ == '__main__': + main() diff --git a/student-tests/conftest.py b/student-tests/conftest.py index 8043a3b6..138748ab 100644 --- a/student-tests/conftest.py +++ b/student-tests/conftest.py @@ -5,6 +5,8 @@ from pathlib import Path # Отдельная тестовая база; задаётся до импорта приложения (настройки читаются при импорте). TEST_DB_NAME = "messenger_test" os.environ["APP_CONFIG__DB__NAME"] = TEST_DB_NAME +# Отдельная база Redis для тестов: FLUSHDB не трогает кэш рабочего стенда (база 0). +os.environ["APP_CONFIG__REDIS__DB"] = "15" import pytest from alembic import command @@ -13,6 +15,7 @@ from fastapi.testclient import TestClient from sqlalchemy import create_engine, text from core.db import build_url, engine +from core.redis_client import redis_client from main import app APP_DIR = Path(__file__).resolve().parents[1] / "app" @@ -38,6 +41,9 @@ def test_database(): def clean_database(): with engine.begin() as connection: connection.execute(text("TRUNCATE users, sessions, chats, chat_members, messages")) + # Кэш тоже чистый; если Redis не запущен, тесты идут через базу (тесты кэша это проверят). + redis_client.reset() + redis_client.run(lambda r: r.flushdb()) @pytest.fixture diff --git a/student-tests/test_failures_api.py b/student-tests/test_failures_api.py new file mode 100644 index 00000000..d6811205 --- /dev/null +++ b/student-tests/test_failures_api.py @@ -0,0 +1,99 @@ +import uuid +from concurrent.futures import ThreadPoolExecutor + +import pytest +from fastapi.testclient import TestClient +from sqlalchemy import create_engine, text +from sqlalchemy.orm import Session, sessionmaker + +import core.db +from conftest import PASSWORD, assert_error, bearer +from core.db import build_url, engine +from core.redis_client import redis_client +from main import app + + +def count_rows(sql, **params): + with engine.connect() as connection: + return connection.scalar(text(sql), params) + + +# ---------- гонка регистрации ---------- + +def test_parallel_registration_of_same_username_creates_one_user(): + def register(i): + # Отдельный клиент на поток (без `with`: lifespan закрыл бы общий пул соединений). + return TestClient(app).post("/api/v1/users", json={ + "username": "racer", "display_name": f"Гонщик {i}", "password": PASSWORD + str(i)}) + + with ThreadPoolExecutor(max_workers=12) as pool: + responses = list(pool.map(register, range(12))) + + statuses = sorted(r.status_code for r in responses) + assert statuses.count(201) == 1 and statuses.count(409) == 11 + for r in responses: + if r.status_code == 409: + assert r.json()["error"]["code"] == "conflict" + assert count_rows("SELECT count(*) FROM users WHERE username = 'racer'") == 1 + + +# ---------- откат составной операции ---------- + +def test_chat_creation_rolls_back_when_member_insert_fails(client, alice, monkeypatch): + ghost = str(uuid.uuid4()) + original_scalar = Session.scalar + + def member_check_passes(self, statement, *args, **kwargs): + # Имитация гонки: проверка «все участники существуют» прошла, а участника удалили до COMMIT. + if "count" in str(statement) and "users" in str(statement): + return 2 + return original_scalar(self, statement, *args, **kwargs) + + monkeypatch.setattr(Session, "scalar", member_check_passes) + response = client.post("/api/v1/chats", headers=alice["auth"], + json={"title": "Половинчатый", "member_ids": [alice["id"], ghost]}) + + # В одной транзакции INSERT chats прошёл, INSERT chat_members упал на FK -> откат всего. + assert_error(response, 400, "invalid_request") + assert count_rows("SELECT count(*) FROM chats") == 0 + assert count_rows("SELECT count(*) FROM chat_members") == 0 + + +# ---------- недоступность PostgreSQL ---------- + +@pytest.fixture +def database_down(monkeypatch): + """PostgreSQL «упал»: новые соединения идут на закрытый порт.""" + dead = create_engine(build_url().set(port=1), pool_pre_ping=True, connect_args={"connect_timeout": 1}) + monkeypatch.setattr(core.db, "engine", dead) + monkeypatch.setattr(core.db, "SessionLocal", sessionmaker(bind=dead, expire_on_commit=False)) + yield + dead.dispose() + + +def assert_limited_503(response): + assert_error(response, 503, "unavailable") + body = response.text.lower() + # Без подробностей: ни драйвера, ни адреса, ни SQL. + for leak in ("psycopg", "sqlalchemy", "127.0.0.1", "port", "select", "traceback"): + assert leak not in body + + +def test_database_down_gives_limited_503_and_no_anonymous_access(client, alice, database_down): + redis_client.run(lambda r: r.flushdb()) # кэш пуст: проверка токена тоже требует базы + + assert client.get("/health/live").status_code == 200 # процесс жив + assert_limited_503(client.get("/health/ready")) + assert_limited_503(client.get("/api/v1/chats", headers=alice["auth"])) + assert_limited_503(client.post("/api/v1/users", json={ + "username": "late", "display_name": "L", "password": PASSWORD})) + + # Аноним и поддельный токен не становятся «доверенными» из-за отказа базы. + assert_error(client.get("/api/v1/users/me"), 401, "unauthorized") + assert_error(client.get("/api/v1/users/me", headers=bearer("not-a-jwt")), 401, "unauthorized") + + +def test_database_down_cached_session_still_authenticates(client, alice, database_down): + # Сессия в кэше: личность подтверждается без базы, но данные из базы всё равно недоступны. + assert client.get("/api/v1/users/me", headers=alice["auth"]).json()["id"] == alice["id"] + assert_limited_503(client.get("/api/v1/chats", headers=alice["auth"])) diff --git a/student-tests/test_session_cache.py b/student-tests/test_session_cache.py new file mode 100644 index 00000000..0d8c99df --- /dev/null +++ b/student-tests/test_session_cache.py @@ -0,0 +1,142 @@ +import json +import time + +import pytest + +import api.dependencies +from conftest import PASSWORD, assert_error, bearer, login +from core.config import settings +from core.db import SessionLocal +from core.redis_client import redis_client +from database_functions.sessions_cache import REVOKED, cache_key, store_session +from database_functions.sessions_functions import get_active_session +from utils.security import token_hash + + +@pytest.fixture +def redis(): + """Прямой доступ к Redis для проверок; тесты кэша требуют запущенного Redis.""" + client = redis_client.run(lambda r: r) + assert client is not None and client.ping(), "Redis не запущен: docker compose up -d redis" + return client + + +@pytest.fixture +def no_database_lookup(monkeypatch): + """Если запрос пойдёт за сессией в PostgreSQL, тест упадёт.""" + def forbidden(*args, **kwargs): + raise AssertionError("сессия читалась из PostgreSQL, а должна была из кэша") + monkeypatch.setattr(api.dependencies, "get_active_session", forbidden) + + +@pytest.fixture +def count_database_lookups(monkeypatch): + calls = [] + + def counting(db, digest): + calls.append(digest) + return get_active_session(db, digest) + monkeypatch.setattr(api.dependencies, "get_active_session", counting) + return calls + + +def test_login_puts_session_into_cache_without_secrets(client, alice, redis): + key = cache_key(token_hash(alice["token"])) + raw = redis.get(key) + assert raw is not None + data = json.loads(raw) + assert data["user_id"] == alice["id"] and data["username"] == "alice" + # Ни токена, ни хеша пароля в кэше. + assert alice["token"] not in raw and "argon2" not in raw and "password" not in raw + # Запись не переживёт ни сессию, ни верхнюю границу кэша. + assert 0 < redis.ttl(key) <= min(settings.jwt.session_ttl_seconds, settings.redis.max_ttl_seconds) + + +def test_cached_session_is_served_without_database(client, alice, redis, no_database_lookup): + response = client.get("/api/v1/users/me", headers=alice["auth"]) + assert response.status_code == 200 + assert response.json() == {k: alice[k] for k in ("id", "username", "display_name", "created_at")} + + +def test_cache_miss_reads_database_once_and_fills_cache(client, alice, redis, count_database_lookups): + redis.flushdb() # например, Redis перезапустили + for _ in range(3): + assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200 + assert len(count_database_lookups) == 1 # первый запрос — из базы, дальше из кэша + assert redis.get(cache_key(token_hash(alice["token"]))) is not None + + +def test_logout_revokes_cached_session(client, alice, redis): + assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200 + assert client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]).status_code == 204 + key = cache_key(token_hash(alice["token"])) + assert redis.get(key) == REVOKED + assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized") + + +def test_slow_reader_cannot_resurrect_session_after_logout(client, alice, redis): + digest = token_hash(alice["token"]) + # «Медленный» запрос успел прочитать сессию из базы до logout... + with SessionLocal() as db: + stale = get_active_session(db, digest) + user, expires_at = stale.user, stale.expires_at + assert client.delete("/api/v1/auth/sessions/current", headers=alice["auth"]).status_code == 204 + # ...и пытается положить её в кэш уже после logout: SET NX не перезаписывает метку отзыва. + assert store_session(digest, user, expires_at) is False + assert_error(client.get("/api/v1/users/me", headers=alice["auth"]), 401, "unauthorized") + + +def test_revoked_token_from_database_is_not_cached(client, alice, redis): + other = login(client, "alice")["token"] + redis.flushdb() + client.delete("/api/v1/auth/sessions/current", headers=bearer(other)) + redis.flushdb() + # Отозванный токен с верной подписью: в базе его нет, кэш не должен его запомнить. + assert_error(client.get("/api/v1/users/me", headers=bearer(other)), 401, "unauthorized") + assert redis.get(cache_key(token_hash(other))) is None + + +@pytest.fixture +def redis_down(monkeypatch): + """Redis «упал»: подключение идёт на закрытый порт.""" + monkeypatch.setattr(settings.redis, "port", 1) + redis_client.reset() + + +def test_redis_down_falls_back_to_database(client, redis_down): + client.post("/api/v1/users", json={"username": "dora", "display_name": "D", "password": PASSWORD}) + token = login(client, "dora")["token"] # вход работает без кэша + headers = bearer(token) + assert client.get("/api/v1/users/me", headers=headers).json()["username"] == "dora" + assert client.delete("/api/v1/auth/sessions/current", headers=headers).status_code == 204 + # Отзыв работает через базу, аноним и отозванный токен не проходят. + assert_error(client.get("/api/v1/users/me", headers=headers), 401, "unauthorized") + assert_error(client.get("/api/v1/users/me"), 401, "unauthorized") + + +def test_redis_down_does_not_slow_every_request(client, alice, redis_down, count_database_lookups): + started = time.monotonic() + for _ in range(10): + assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200 + # Таймаут Redis (0.25 с) платится максимум один раз; дальше запросы Redis не трогают, + # доступность проверяет фоновый поток. + assert time.monotonic() - started < 10 * settings.redis.timeout_seconds + assert len(count_database_lookups) == 10 + + +def test_cache_comes_back_after_redis_recovers(client, alice, redis, monkeypatch, count_database_lookups): + monkeypatch.setattr(settings.redis, "retry_after_seconds", 0.2) + real_port = settings.redis.port + monkeypatch.setattr(settings.redis, "port", 1) # Redis «упал» + redis_client.reset() + assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200 + monkeypatch.setattr(settings.redis, "port", real_port) # Redis «поднялся» + deadline = time.monotonic() + 3 + while redis_client.run(lambda r: r.ping()) is None: # фоновая проверка включит кэш сама + assert time.monotonic() < deadline, "кэш не восстановился после возврата Redis" + time.sleep(0.05) + for _ in range(3): + assert client.get("/api/v1/users/me", headers=alice["auth"]).status_code == 200 + # Из базы читал только запрос во время отказа; после возврата Redis — снова из кэша + # (запись положена при входе и в «упавшем» по настройкам, но живом Redis сохранилась). + assert len(count_database_lookups) == 1 -- 2.54.0