ЛР 2 — БПИ2302 — Мякишев — на 3 #59
+17
-1
@@ -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
@@ -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
|
||||
|
||||
@@ -0,0 +1,2 @@
|
||||
*.sh text eol=lf
|
||||
*.cmd text eol=crlf
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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
|
||||
|
||||
@@ -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-архивирование для рабочей базы с хранением вне хоста; периодическая очистка истёкших сессий.
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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")
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)}")
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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)))
|
||||
@@ -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
|
||||
@@ -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
@@ -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
|
||||
)
|
||||
@@ -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()
|
||||
@@ -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 ###
|
||||
@@ -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"]
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
@@ -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()"))
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -0,0 +1,11 @@
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class ErrorBody(BaseModel):
|
||||
code: str
|
||||
message: str
|
||||
request_id: str
|
||||
|
||||
|
||||
class ErrorResponse(BaseModel):
|
||||
error: ErrorBody
|
||||
@@ -0,0 +1,7 @@
|
||||
from typing import Literal
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
|
||||
class HealthResponse(BaseModel):
|
||||
status: Literal["ok"]
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)]
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
@@ -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
|
||||
@@ -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 с"
|
||||
]
|
||||
}
|
||||
@@ -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": []
|
||||
}
|
||||
@@ -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 с"
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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 |
|
||||
@@ -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
|
||||
}
|
||||
@@ -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 |
|
||||
@@ -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
|
||||
@@ -0,0 +1,5 @@
|
||||
[pytest]
|
||||
testpaths = student-tests
|
||||
pythonpath = app
|
||||
filterwarnings =
|
||||
ignore:Using .httpx. with .starlette.testclient. is deprecated
|
||||
@@ -0,0 +1,3 @@
|
||||
-r requirements.txt
|
||||
pytest==9.1.1
|
||||
httpx==0.28.1
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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' }
|
||||
Executable
+19
@@ -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"; }
|
||||
@@ -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}}"
|
||||
Executable
+9
@@ -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}}'
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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"]
|
||||
@@ -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")
|
||||
@@ -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")
|
||||
@@ -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"]))
|
||||
@@ -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")
|
||||
@@ -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
|
||||
@@ -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")
|
||||
Reference in New Issue
Block a user