ЛР 2 — БПИ2302 — Мякишев — на 3 #59

Closed
vest1ter wants to merge 3 commits from vest1ter/mtusi2026lab2:solution/bpi2302-myakishev into master
76 changed files with 4861 additions and 27 deletions
+17 -1
View File
@@ -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
+31 -10
View File
@@ -1,11 +1,32 @@
# 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),
# 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
# 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
# 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
+2
View File
@@ -0,0 +1,2 @@
*.sh text eol=lf
*.cmd text eol=crlf
+3
View File
@@ -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.
+22
View File
@@ -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"]
+13 -1
View File
@@ -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
+198 -15
View File
@@ -1,37 +1,220 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Мякишев Владислав, БПИ2302
- Целевая оценка: **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
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужно: 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 -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`, `secrets/redis_password` (случайные, не выводятся, вне Git) и `.env` из `.env.example`. Существующие файлы не перезаписываются.
- Миграции применяет разовый сервис `migrate` (`alembic upgrade head`) при каждом `up`; повторный запуск ничего не меняет.
- Остановка без потери данных: `docker compose down`. Намеренное удаление учебных данных: `docker compose down -v`.
- Свои тесты (нужны запущенные `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`.
- Эксперименты уровня 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; временный контейнер восстановления удаляется).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → 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` (проверяет БД; 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`, затем по кэшу или таблице `sessions`; logout удаляет сессию. `X-User-Id` не читается.
### Redis: кэш сессий (cache-aside)
| | Решение |
| --- | --- |
| Источник истины | таблица `sessions` в PostgreSQL. Redis хранит только копию, поэтому persistence Redis выключен (`--save "" --appendonly no`): рестарт или отказ Redis не теряет ни одной сессии |
| Что в Redis | ключ `session:<sha256 токена>` → 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 | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный 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` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Нагрузка `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 с в обоих случаях.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `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` (особенно построение индексов) растёт, и логический дамп перестаёт подходить. Тогда нужны физические бэкапы.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Один экземпляр 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` есть).
- Измерения — по одному прогону, клиент на той же машине.
- Следующие шаги: регулярный `pg_dump` или WAL-архивирование для рабочей базы с хранением вне хоста; периодическая очистка истёкших сессий.
+43
View File
@@ -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
+65
View File
@@ -0,0 +1,65 @@
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_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
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)
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)
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) — по Redis, а при промахе по таблице sessions.
payload = decode_access_token(token)
if payload is None:
raise unauthorized()
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
def get_current_user(auth_session: AuthSession = Depends(get_current_session)) -> User:
return auth_session.user
+20
View File
@@ -0,0 +1,20 @@
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. Redis сюда намеренно не входит:
# это кэш, без него API работает (сессии читаются из базы).
@router.get("/ready", response_model=HealthResponse)
def ready_api():
if not check_database():
raise HTTPException(status_code=503, detail="База данных недоступна")
return HealthResponse(status="ok")
+73
View File
@@ -0,0 +1,73 @@
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, require_empty_body
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
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, 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)
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)
# Сразу в кэш (после 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)
+54
View File
@@ -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)
+46
View File
@@ -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)
+31
View File
@@ -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)
+105
View File
@@ -0,0 +1,105 @@
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)
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
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()
redis: RedisConfig = RedisConfig()
settings = Settings()
+57
View File
@@ -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)}")
+15
View File
@@ -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()
+99
View File
@@ -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()
+50
View File
@@ -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))
@@ -0,0 +1,32 @@
import uuid
from sqlalchemy import Select, 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 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)
.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 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)))
+68
View File
@@ -0,0 +1,68 @@
"""Кэш сессий в Redis (cache-aside).
Источник истины — таблица sessions. В Redis по ключу session:<sha256 токена> лежит
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)))
@@ -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
+30
View File
@@ -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))
+50
View File
@@ -0,0 +1,50 @@
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 core.redis_client import redis_client
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()
redis_client.reset()
logger.info("Соединения с базой данных и Redis закрыты")
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
)
+52
View File
@@ -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()
+28
View File
@@ -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"}
@@ -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 ###
+8
View File
@@ -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"]
+15
View File
@@ -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)
+35
View File
@@ -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)
+30
View File
@@ -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)
+25
View File
@@ -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")
+21
View File
@@ -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()"))
+13
View File
@@ -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
+38
View File
@@ -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
+11
View File
@@ -0,0 +1,11 @@
from pydantic import BaseModel
class ErrorBody(BaseModel):
code: str
message: str
request_id: str
class ErrorResponse(BaseModel):
error: ErrorBody
+7
View File
@@ -0,0 +1,7 @@
from typing import Literal
from pydantic import BaseModel
class HealthResponse(BaseModel):
status: Literal["ok"]
+33
View File
@@ -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
+29
View File
@@ -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
+18
View File
@@ -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)]
+50
View File
@@ -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)
+27
View File
@@ -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
+35
View File
@@ -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
+63
View File
@@ -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()
+110
View File
@@ -0,0 +1,110 @@
# 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
# Кэш сессий. Источник истины — таблица 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: .
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__REDIS__HOST: redis
APP_CONFIG__REDIS__PASSWORD_FILE: /run/secrets/redis_password
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
# Имя остановленного контейнера (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
restart: unless-stopped
volumes:
postgres_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
jwt_secret:
file: ./secrets/jwt_secret
redis_password:
file: ./secrets/redis_password
+90
View File
@@ -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
@@ -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 с"
]
}
+82
View File
@@ -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": []
}
+82
View File
@@ -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 с"
]
}
+17
View File
@@ -0,0 +1,17 @@
# 2026-10-29T13:56:19 persistence: restart api, postgres, redis with volumes kept; same bearer token after restart
## containers BEFORE
/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.
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
+57
View File
@@ -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
+7
View File
@@ -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
+62
View File
@@ -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
}
}
+385
View File
@@ -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
}
+34
View File
@@ -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 |
+385
View File
@@ -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
}
+34
View File
@@ -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 |
+77
View File
@@ -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
+5
View File
@@ -0,0 +1,5 @@
[pytest]
testpaths = student-tests
pythonpath = app
filterwarnings =
ignore:Using .httpx. with .starlette.testclient. is deprecated
+3
View File
@@ -0,0 +1,3 @@
-r requirements.txt
pytest==9.1.1
httpx==0.28.1
+27
View File
@@ -0,0 +1,27 @@
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
redis==8.0.1
+161
View File
@@ -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()
+154
View File
@@ -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-<service>.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()
+20
View File
@@ -0,0 +1,20 @@
# 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
New-Secret 'redis_password' 32
if (-not (Test-Path .env)) { Copy-Item .env.example .env; 'created .env' }
+19
View File
@@ -0,0 +1,19 @@
#!/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
make_secret redis_password 32
[ -f .env ] || { cp .env.example .env; echo "created .env"; }
+8
View File
@@ -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 redis || exit /b 1
docker compose up -d --wait || exit /b 1
docker compose ps --format "{{.Name}} {{.Status}}"
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
# Hook для make test-persistence: перезапуск API, PostgreSQL и Redis с сохранением volumes.
set -eu
cd "$(dirname "$0")/.."
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}}'
+215
View File
@@ -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()
+314
View File
@@ -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()
+108
View File
@@ -0,0 +1,108 @@
import base64
import os
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
from alembic.config import Config
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"
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"))
# Кэш тоже чистый; если Redis не запущен, тесты идут через базу (тесты кэша это проверят).
redis_client.reset()
redis_client.run(lambda r: r.flushdb())
@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"]
+106
View File
@@ -0,0 +1,106 @@
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):
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_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})
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")
+54
View File
@@ -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")
+99
View File
@@ -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"]))
+66
View File
@@ -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")
+142
View File
@@ -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
+69
View File
@@ -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")