ЛР 2 — БПИ2302 — Григорьев — на 5 #136

Closed
Pavel_Grigoriev wants to merge 8 commits from Pavel_Grigoriev/mtusi2026lab2:solution/bpi2302-grigoriev into master
50 changed files with 4108 additions and 20 deletions
+12
View File
@@ -18,3 +18,15 @@ __pycache__
node_modules
evidence
.DS_Store
tests
student-tests
contracts
scripts
examples
*.md
Makefile
lab.json
requirements-dev.txt
Dockerfile*
.dockerignore
.gitignore
+11 -4
View File
@@ -3,9 +3,16 @@
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
APP_SHUTDOWN_TIMEOUT=5
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
# Credentials are generated locally by: python scripts/init_secrets.py
# 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
# Sessions: PostgreSQL is the source of truth, Valkey is a read-through cache.
CACHE_URL=redis://valkey:6379/0
SESSION_CACHE_TTL_SECONDS=60
DB_POOL_MIN=1
DB_POOL_MAX=10
DB_POOL_TIMEOUT_SECONDS=2
DB_STATEMENT_TIMEOUT_MS=3000
DB_REQUEST_TIMEOUT_SECONDS=4
+26
View File
@@ -0,0 +1,26 @@
name: Application
on: [push, pull_request]
permissions:
contents: read
jobs:
stack:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: cp .env.example .env
- run: python scripts/init_secrets.py
- run: docker compose config --quiet
- run: docker compose up -d --build --wait
- run: make test BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: make student-test BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: python student-tests/expiry_check.py --ttl 2
- run: python student-tests/failure_check.py
- if: failure()
run: docker compose ps -a && docker compose logs --no-color
- if: always()
run: docker compose down -v
+25
View File
@@ -0,0 +1,25 @@
FROM python:3.12.15-slim-trixie@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1 \
PIP_ROOT_USER_ACTION=ignore
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY migrations/ ./migrations/
COPY src/ ./src/
RUN useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin app
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT', '8080'), timeout=2)"]
CMD ["python", "src/main.py"]
+4 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence
.PHONY: help check validate test load test-persistence student-test
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -18,6 +18,9 @@ validate:
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
student-test:
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
+196 -15
View File
@@ -1,37 +1,218 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Григорьев Павел, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: 5, трек 2 «План запроса и восстановление»
- Commit/PR: ветка `solution/bpi2302-grigoriev`; ссылка на PR — после публикации
- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.3.6 + psycopg-pool 3.3.3, argon2-cffi 25.1.0, redis-py 8.1.0 (полный список — `requirements.txt`); PostgreSQL 17.11, Valkey 8.1.11; документация PostgreSQL (transactions, EXPLAIN, pg_dump), Valkey (persistence, eviction), RFC 7617, RFC 6750, RFC 9106, OWASP Password Storage Cheat Sheet. При разработке использовался ИИ-ассистент.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требования: Docker Engine 27.x с Compose v2 (проверено: Docker Desktop, Engine 27.2.0, WSL2 на Windows 10); Python 3.9+ только для тестов и скриптов (стандартная библиотека). `make` необязателен — ниже прямые команды.
Образы закреплены тегом и digest: `python:3.12.15-slim-trixie@sha256:a6e34c59…`, `postgres:17.11-alpine@sha256:266d3c25…`, `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`. Зависимости Python — `==` для всех пакетов, включая транзитивные.
```sh
git clone <URL fork> mtusi2026lab2 && cd mtusi2026lab2
git switch solution/bpi2302-grigoriev
cp .env.example .env # несекретная конфигурация
python scripts/init_secrets.py # secrets/postgres_password, database_url, database_url_restore (вне Git)
docker compose config --quiet
docker compose up -d --build --wait # postgres, valkey → migrate (exit 0) → api healthy
docker compose ps -a
python tests/smoke.py --base-url http://127.0.0.1:8080 # make test
python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
# на Windows: --action-script scripts/restart.cmd (Python на Windows не исполняет .sh)
python -m unittest discover -s student-tests -v # make student-test
python student-tests/expiry_check.py --ttl 2
python student-tests/failure_check.py
```
Bootstrap/миграции: одноразовый сервис `migrate` применяет `migrations/*.sql` по порядку под `pg_advisory_lock`, записывая версии в `schema_migrations`; API стартует только после его успешного завершения. Миграции: `0001_init` (схема), `0002_unicode_text` (свободный текст в `bytea`, см. ниже), `0003_session_revocations` (устойчивые отзывы сессий); применяются и к пустой БД, и поверх уже существующей. Повтор безопасен: `docker compose run --rm migrate` → `skip … already applied`.
На Windows используйте `127.0.0.1`, а не `localhost`: Docker Desktop не слушает `::1`, и каждый запрос к `localhost` ждёт ~2 с перед переходом на IPv4.
Остановка без потери данных: `docker compose stop` (или `docker compose down` — контейнеры удаляются, volume `pgdata` остаётся). **Намеренное удаление учебных данных:** `docker compose --profile restore down -v` (удаляет `grigoriev-lab2_pgdata` и `grigoriev-lab2_pgdata_restore`). Только данные эксперимента трека 2: `docker compose exec postgres psql -U messenger -c "DROP DATABASE bench"`; дампы — каталог `backups/` (в `.gitignore`).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──HTTP 127.0.0.1:8080──► api (uvicorn + FastAPI, stateless)
│ пул psycopg (1..10, wait 2 s), общий срок работы с БД на запрос 4 s, statement_timeout 3 s
├──────────► postgres:17 — источник истины: users, chats, chat_members, messages, sessions, session_revocations
│ volume pgdata
└──────────► valkey:8 — кэш проверки сессии (TTL ≤ 60 s), persistence выключена
migrate (one-shot) ──► postgres сеть backend: internal, порты БД/кэша не публикуются
```
| Роль | Service | Версия/digest | Health/readiness | Volume | Сеть/порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| api | `api` | сборка из `Dockerfile` | `GET /health/ready` (проверяет PostgreSQL) | — | frontend+backend, `127.0.0.1:8080` | secret `database_url` |
| миграции | `migrate` | тот же образ | exit 0 | — | backend | secret `database_url` |
| postgres | `postgres` | 17.11-alpine@sha256:266d… | `pg_isready` | `pgdata` | backend | `POSTGRES_PASSWORD_FILE` (secret) |
| redis_or_valkey | `valkey` | 8.1.11-alpine@sha256:2602… | `valkey-cli ping` | — (кэш) | backend | нет: только внутренняя сеть (учебное упрощение, hardening в lab7) |
| эксперимент restore | `postgres-restore`, `api-restore` (profile `restore`) | те же | те же | `pgdata_restore` | backend, `127.0.0.1:${RESTORE_API_PORT:-8081}` | secret `database_url_restore` |
**Источник истины** — PostgreSQL. Схема (`migrations/0001…0003`):
| Таблица | Ключи и ограничения | Индексы под запросы |
| --- | --- | --- |
| `users` | PK id; `username` text, UNIQUE + CHECK `^[a-z0-9_]{3,32}$`; `display_name` bytea (UTF-8, ≤ 400 байт); `password_hash` (Argon2id) | UNIQUE(username) — вход и гонка регистрации |
| `chats` | PK id; `title` bytea (UTF-8, ≤ 400 байт); `created_by` FK → users | — |
| `chat_members` | PK (chat_id, user_id); FK → chats, users; `position` (порядок member_ids), UNIQUE(chat_id, position) | PK — проверка членства; `(user_id, chat_id)` — список чатов |
| `messages` | PK id; FK (chat_id, sender_id) → chat_members (отправитель — участник); `text` bytea (UTF-8, 1–16 000 байт) | `(chat_id, created_at, id)` — история keyset |
| `sessions` | PK `token_hash` (sha256, 32 байта); FK user_id; `expires_at > created_at` | `(user_id)`, `(expires_at)` |
| `session_revocations` | PK `token_hash`; `expires_at` — до какого момента отзыв надо переносить в кэш | `(expires_at)` |
`id` и `created_at` назначает БД (`gen_random_uuid()`, `clock_timestamp()`), сессия БД в UTC.
**Хранение текста.** Тип `text` в PostgreSQL не может содержать U+0000, а по контракту это допустимый code point. Поэтому `messages.text`, `chats.title` и `users.display_name` хранятся как `bytea` с UTF-8 (`0002_unicode_text`): любая строка сохраняется и читается без изменений, в том числе `"a\u0000b"`. Длину в code points (1–4000 / 1–100) проверяет приложение, БД ограничивает размер в байтах (×4). Строки с одиночными суррогатами (`\ud800`) не кодируются в UTF-8 и получают 400. `username` остаётся `text`: regex допускает только `[a-z0-9_]`. В psql текст читается как `convert_from(text, 'UTF8')`.
**Транзакционные границы.** Регистрация — один INSERT, гонку решает UNIQUE (`unique_violation` → 409). Вход — удаление истёкших сессий пользователя и вставка новой в одной транзакции. **Создание чата** — `INSERT chats` и `INSERT chat_members … FROM unnest(...) WITH ORDINALITY` в одной явной транзакции; неизвестный участник вызывает `foreign_key_violation`, откатывается всё (→ 400). Сообщение — один `INSERT … SELECT … WHERE EXISTS(членство)`, проверка доступа и запись атомарны. Чтение истории — проверка членства и keyset-SELECT на одном соединении. Все запросы параметризованы.
**Сессии.** `POST /auth/sessions` принимает только `Authorization: Basic` без тела; username по regex, пароль 12–128 code points, разделение по первому `:`. Пароль сверяется Argon2id (`t=2, m=19 MiB, p=1`, параметры OWASP); для несуществующего пользователя вычисляется хеш-пустышка, ответ — одинаковый 401 с `WWW-Authenticate: Basic realm="messenger", charset="UTF-8"`. Токен — `secrets.token_urlsafe(32)` (256 бит), в БД хранится только `sha256(token)` и абсолютный `expires_at = now() + SESSION_TTL_SECONDS` — рестарт не продлевает TTL. Все остальные endpoint требуют `Bearer`; нет/истёк/отозван/Basic → 401 с `WWW-Authenticate: Bearer realm="messenger"`; `X-User-Id` не читается. Аутентификация проверяется раньше валидации тела: аноним с некорректным JSON на защищённом endpoint получает 401, а не 400. Logout удаляет строку сессии, сохраняет отзыв и записывает его в Valkey (204), повтор — 401 (см. «Роль Valkey»).
**Роль Valkey (уровень 4): кэш сессий.** Ключ `session:<hex sha256>`, значение `{user, expires_at}`. Пишется при входе (write-through) и при промахе (cache-aside) командой `SET … NX`. TTL = `min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии)`, при чтении `expires_at` проверяется повторно — кэш не может продлить сессию. **Инвалидация (устойчивая).** Logout одной транзакцией удаляет строку `sessions` и записывает отзыв в `session_revocations` с `expires_at = now() + 65 с` (TTL кэша + запас); затем записывает в Valkey tombstone `revoked` с TTL 60 с — даже в окне обхода кэша. Если tombstone записан, строка отзыва удаляется; если Valkey недоступен, она остаётся в PostgreSQL, и logout всё равно отвечает 204. Положительным записям кэша процесс API доверяет только в состоянии «сверено»: после старта и после любой ошибки Valkey он сначала переносит все неистёкшие отзывы из `session_revocations` в Valkey и лишь затем снова читает кэш; до этого сессия проверяется в PostgreSQL. Отзыв поэтому переживает и недоступность Valkey, и рестарт API. Через 65 с строка отзыва больше не нужна: любая положительная запись, созданная до logout, к этому моменту истекла по абсолютному времени Valkey. Tombstone → сразу 401, а `SET NX` не даёт запоздавшему запросу, прочитавшему сессию до удаления, затереть его положительной записью. Flush/restart Valkey — только промахи; persistence не нужна (`--save "" --appendonly no`), `maxmemory 64mb`, `volatile-ttl`. Отказ Valkey: socket timeout 200 мс, после ошибки кэш 5 с не опрашивается (circuit breaker), запросы идут в PostgreSQL. В API `dns_opt timeout:1 attempts:1`: имя остановленного контейнера пропадает из DNS Docker, и без опции резолв занимал 8 с.
**Readiness.** Критична только PostgreSQL (`SELECT 1` за ≤ 1 с); Valkey некритичен. Запрос без проверенной сессии никогда не получает 200.
**Сроки ожидания БД.** `connect_timeout` (3 с) действует только при установке соединения, а `statement_timeout` (3 с) исполняет сам сервер — ни тот, ни другой не спасают, если сервер завис или заморожен (`docker compose pause postgres`): соединение открыто, ответа нет. Поэтому у каждого HTTP-запроса есть общий бюджет работы с БД `DB_REQUEST_TIMEOUT_SECONDS=4` (contextvar, выставляется в middleware): ожидание соединения из пула ограничено остатком бюджета, а отдельный поток-сторож (`src/db.py`) закрывает сокет соединения, если запрос к БД не уложился в остаток; проверка соединения при выдаче из пула ограничена 1 с так же. Заблокированный вызов сразу получает `OperationalError` → 503 `unavailable`, незавершённая транзакция откатывается сервером, битое соединение выбрасывается из пула. Отказ или заморозка БД: 503 за ≈ 2 с (срок ожидания пула), зависший запрос — за 4 с.
**Перенесено из lab1:** middleware `X-Request-Id`, формат ошибок, pydantic-модели (strict, extra forbid), формат cursor, Dockerfile (non-root, healthcheck, exec CMD), student-tests (переведены на Bearer). **Изменено:** хранилище in-memory → PostgreSQL, `X-User-Id` → Basic/Bearer, `CreateUser.password`, keyset теперь в SQL, монотонные метки времени процесса заменены временем БД (порядок задаёт `(created_at, id)`).
Соответствие `.env.example`:
| Переменная | Где используется | По умолчанию |
| --- | --- | --- |
| `APP_HOST`, `APP_PORT` | uvicorn в контейнере | `0.0.0.0`, `8080` |
| `APP_ENV` | лог старта | `lab` |
| `APP_SHUTDOWN_TIMEOUT` | graceful shutdown uvicorn | `5` |
| `SESSION_TTL_SECONDS` | срок сессии | `3600` |
| `DATABASE_URL_FILE` | файл secret с DSN | `/run/secrets/database_url` |
| `CACHE_URL` | адрес Valkey (пусто — кэш выключен) | `redis://valkey:6379/0` |
| `SESSION_CACHE_TTL_SECONDS` | верхняя граница TTL кэша | `60` |
| `DB_POOL_MIN`, `DB_POOL_MAX`, `DB_POOL_TIMEOUT_SECONDS`, `DB_STATEMENT_TIMEOUT_MS` | пул и таймауты | `1`, `10`, `2`, `3000` |
| `DB_REQUEST_TIMEOUT_SECONDS` | общий бюджет работы с БД на один HTTP-запрос | `4` |
`SESSION_STORE` из skeleton не используется: сессии всегда в PostgreSQL.
## Доказательства критериев
Все файлы — `evidence/`, получены на стенде из раздела «Эксперименты» (последний полный прогон — 2026-11-06).
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `python tests/smoke.py` (`make test`) | `PASS: lab2 public API scenario` | `smoke.txt` |
| 3: данные и сессии переживают рестарт API и хранилищ без удаления volumes | `tests/resilience.py --mode persistence` с `scripts/restart.cmd` (= `restart.sh`) | PASS; `ps` до/после: postgres, valkey, api перезапущены; в логах `database system is shut down` → `ready to accept connections`; volumes на месте | `persistence.txt` |
| 3: PostgreSQL с PK/FK, UNIQUE username, миграции с нуля и повторно без дублей | `migrations/*.sql`; `test_migrations_are_idempotent`; запуск на пустом volume | повторный `migrate` → `skip … already applied`, `schema_migrations` и данные не изменились | `student-tests.txt` |
| 3: создание чата атомарно | `test_chat_creation_is_rolled_back` | в логе PostgreSQL FK-ошибка с UUID несуществующего участника, количество строк chats/chat_members не изменилось | `student-tests.txt` |
| 3: Basic только на входе, Bearer на остальном, X-User-Id не даёт доступ, expiry и logout, KDF | `test_auth.py`, `test_db.py` | Basic/X-User-Id/мусор → 401 Bearer; X-User-Id не подменяет пользователя; logout → 204, повтор 401; `password_hash` начинается с `$argon2id$`, в sessions — sha256 токена | `student-tests.txt` |
| 3: secrets/volumes не в Git | `git status --ignored` | `.env`, `secrets/`, `backups/` игнорируются | `.gitignore` |
| 4: Valkey с ролью, TTL, политикой инвалидации | раздел «Архитектура»; `expiry_check.py`; `failure_check.py` (1б, 1в) | TTL ключа сессии в Valkey ≤ TTL сессии; logout при `pause valkey` → 204, после unpause токен → 401; logout при `pause valkey` → рестарт API → unpause → токен 401 на /users/me и на отправку сообщения | `expiry.txt`, `failure.txt` |
| 4: параметризованные запросы, ограниченный пул, таймауты | `src/store.py`, `src/db.py`; `failure_check.py` (4) | `%s`-параметры везде; пул 1..10, wait 2 с, connect 3 с, statement_timeout 3 с, общий срок на запрос 4 с со сторожем; при `pause postgres` история, отправка, вход → 503 за ≈ 2 с вместо зависания | код, `failure.txt` |
| 4: гонка регистрации одного username | `test_parallel_registration_of_same_username` | 20 одновременных: 1×201 + 19×409; вход только с паролем победителя | `student-tests.txt` |
| 4: rollback составной операции | см. «создание чата атомарно» | — | `student-tests.txt` |
| 4: индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений, без полного scan | `python research/track2.py explain` | 200 000 сообщений; `Limit → Index Scan using messages_chat_history_idx`, без Sort; 9–13 буферов на первой и на 90%-й странице чата из 100 000 | `explain-history.txt` |
| 4: expiry при коротком SESSION_TTL_SECONDS | `python student-tests/expiry_check.py --ttl 2` | сразу 200, через 3,5 с 401 с Bearer challenge, logout истёкшим → 401 | `expiry.txt` |
| 4: logout, неверный пароль | `test_auth.py` | см. выше; неверный пароль и несуществующий логин — одинаковый 401 | `student-tests.txt` |
| 4: недоступность Redis/БД | `python student-tests/failure_check.py` | Valkey stop: всё 2xx через PostgreSQL (первый запрос 1,0 с, далее ≤ 0,03 с), logout 204 → токен 401; Valkey pause: logout 204, после unpause токен 401; PostgreSQL stop и pause: 503 за ≈ 2,0 с, неизвестный токен → 503 (не 200), вход → 503, live 200, ready 503; после старта/unpause тот же токен и данные | `failure.txt` |
| контракт: U+0000 — допустимый символ | `test_nul_character_is_preserved`, `test_lone_surrogate_is_rejected` | `"a\u0000b"` в сообщении, title и display_name → 201 и читается без изменений; одиночный суррогат → 400 | `student-tests.txt` |
| 4 (из lab1): SIGTERM | `student-tests/sigterm_check.py` | `docker stop` 0,48 с, exit 0, 5xx — 0 | `sigterm.txt` |
| 5, трек 2 | `python research/track2.py all` | см. следующий раздел | `track2/` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Стенд: Windows 10 Pro 19045, Docker Desktop (Engine 27.2.0, WSL2), VM Docker: 12 CPU, 1,9 GiB RAM; лимиты контейнерам не заданы; клиент на той же машине. PostgreSQL 17.11, `shared_buffers=128MB`, остальное по умолчанию, `track_io_timing=on`.
Нагрузка (`python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json`, closed loop, POST в один новый чат — история растёт от 0 до ~8 500 сообщений; без прогрева): 8 513 успешных, 0 ошибок, **283 RPS**, p50 12,0 / p95 32,0 / p99 36,3 мс. После прогона: api 76 MiB, postgres 36 MiB, valkey 8 MiB. Предыдущий прогон на схеме с `text`: 309 RPS, p95 30,8 мс — разница в пределах разброса одного короткого прогона. Генератор closed-loop (coordinated omission), клиент делит CPU с сервером — это не предел пропускной способности.
### Трек 2. План запроса истории и восстановление
**Гипотезы.**
1. Запрос страницы истории `WHERE chat_id = ? [AND (created_at, id) > cursor] ORDER BY created_at, id LIMIT 51` с индексом `(chat_id, created_at, id)` читает O(limit) страниц **независимо от размера чата и глубины страницы**. Индексы `(chat_id)` или `(created_at, id)` проигрывают на части чатов из-за неравномерности размеров. OFFSET растёт линейно с глубиной.
2. Составной индекс увеличивает стоимость записи заметно меньше, чем ускоряет чтение.
3. `pg_dump` даёт согласованный снимок на момент начала: восстановление в новое хранилище воспроизводит все данные до снимка (count и контрольные суммы), записи после начала дампа теряются (RPO = момент начала дампа).
**Методика** (`research/track2.py`, `research/seed.sql`, повторяемо: `python research/track2.py all`).
- Отдельная БД `bench` со схемой из тех же миграций (0001–0003, текст в `bytea`). 200 000 сообщений, `setseed(0.42)`: 1 чат × 100 000, 20 × 3 000, 4 000 × 10 (сильный перекос). Длина текста 20–400 символов, времена равномерно за 30 дней, вставка в порядке времени — физический порядок таблицы не совпадает с chat_id, как в реальной переписке. Таблица 96 MB.
- Варианты индекса истории: `pk_only`, `(chat_id)`, `(created_at, id)`, `(chat_id, created_at, id)` (рабочий). Перед каждым вариантом остальные индексы удаляются, затем `ANALYZE`.
- Запросы — точная форма из приложения, `LIMIT 51`: первая страница, keyset и OFFSET на глубине 50% и 90%, для большого, среднего и маленького чата. По 3 прогрева + 15 замеров `EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)`, медиана и p95 времени, буферы, форма плана.
- Запись: (а) `EXPLAIN ANALYZE INSERT` 20 000 строк в транзакции с ROLLBACK после `CHECKPOINT`, медиана из 5 — время узла Insert (таблица + индексы), время FK-триггера, WAL на строку, без шума commit-fsync; (б) `pgbench` с одной вставкой на транзакцию, 4 клиента, 10 с × 5 повторов.
- Восстановление: пустой volume `pgdata_restore` → `pg_dump -Fc` БД `bench` и `messenger` **во время** параллельной записи pgbench (маркер `during dump`) → `docker compose cp` → `pg_restore -j 4` в `postgres-restore` → `ANALYZE` → сверка count и md5 (все сообщения по id, первая и 90%-я страница большого чата, весь маленький чат) → `api-restore` на восстановленной `messenger` с **прежним токеном**.
**Результаты чтения** (медиана, мс; в скобках — буферы shared hit+read). Полностью — `evidence/track2/results.md`, `reads.json`.
| запрос | pk_only | (chat_id) | (created_at, id) | **(chat_id, created_at, id)** |
| --- | --- | --- | --- | --- |
| большой чат, первая страница | 29,9 (12 361) | 28,5 (12 361) | 0,066 (9) | **0,041 (9)** |
| большой, keyset 90% | 24,2 (12 303) | 24,5 (12 303) | 0,053 (17) | **0,074 (11)** |
| большой, OFFSET 90% | 95,2 | 99,0 | 42,0 (17 650) | 123,0 (12 361) Seq Scan + Sort на диск |
| средний (3 000), keyset 90% | 22,1 | 3,2 (2 694) | 0,371 (314) | **0,067 (49)** |
| маленький (10), первая | 20,5 | 0,057 (13) | 21,0 (12 361) | **0,037 (13)** |
| маленький, keyset 50% | 21,8 | 0,046 (13) | 22,4 (12 273) | **0,054 (8)** |
- Рабочий индекс: все страницы всех чатов — 0,04–0,07 мс и 4–13 буферов, план `Limit → Index Scan`, без Sort. **Гипотеза 1 подтверждена.** Число буферов во всех ячейках совпало с предыдущим прогоном на схеме с `text` — форма планов воспроизводится.
- `(chat_id)`: маленький чат быстро, но большой — Seq Scan (индекс невыгоден при 50% таблицы), средний — Bitmap + Sort всех 3 000 строк.
- `(created_at, id)`: идеален для большого чата (его сообщения — половина таблицы, первые 51 по времени находятся сразу), но для маленького чата пришлось бы пройти весь индекс до 10 нужных строк — планировщик выбирает Seq Scan (21 мс). Именно неравномерность размеров отличает эти варианты.
- OFFSET: даже с рабочим индексом на глубине 90 000 планировщик выбрал Parallel Seq Scan + внешнюю сортировку (≈ 15 MB на диск на каждый процесс), 96–123 мс против 0,07 мс у keyset — в ~1 500 раз. Доп. замер (`planner_random_page_cost_*.json`): при `random_page_cost=1.1` (значение для SSD вместо HDD-значения 4) план становится Index Scan, 22,9 мс — всё равно в ~300 раз медленнее keyset и линейно растёт с глубиной (OFFSET 50% — 12 мс).
**Результаты записи** (`writes.json`):
| вариант | INSERT, мс/1000 строк | FK-проверка, мс/1000 | WAL, байт/строку | размер индексов, MiB | pgbench TPS медиана [min..max] |
| --- | --- | --- | --- | --- | --- |
| pk_only | 9,70 | 20,9 | 2 792 | 0 | 628 [420..3 444] |
| (chat_id) | 10,18 | 22,0 | 2 950 | 1,5 | 3 483 [2 961..3 664] |
| (created_at, id) | 8,60 | 21,0 | 2 877 | 7,8 | 790 [490..3 691] |
| **(chat_id, created_at, id)** | **10,71** | 19,9 | **3 035** | 11,2 | 3 376 [2 738..3 603] |
| рабочий + (created_at, id) | 11,44 | 20,5 | 3 120 | ≈ 19 (11,2 + 7,8) | 3 566 [2 643..3 651] |
- **WAL на строку** — детерминированная метрика, в обоих прогонах монотонна: рабочий индекс +243 байта (+8,7%), два индекса +328 (+11,7%); плюс 11,2 MiB на 200 000 строк. **Время узла INSERT** различается на 1–2 мс на 1000 строк, и в этом прогоне порядок вариантов не монотонен (`(created_at, id)` быстрее `pk_only`), тогда как в предыдущем был монотонен (9,8 → 11,8 → 12,8): разница меньше шума между прогонами. Вывод: цена рабочего индекса на запись — проценты (WAL, место), выигрыш чтения — сотни–тысячи раз. **Гипотеза 2 подтверждена.**
- Неожиданно: ~⅔ времени вставки — проверка составного FK `messages(chat_id, sender_id) → chat_members` (20 из 31 мс на 1000 строк), а не индексы.
- pgbench (commit на каждую строку) не различает варианты: пропускная способность упирается в fsync WAL виртуального диска Docker Desktop, у которого время `sync` скачет 0,01–1,7 с; отдельные прогоны падают до ~400–800 TPS в любом варианте (у `pk_only` и `(created_at, id)` — по 3 таких прогона из 5, поэтому их медианы низкие). Вывод о стоимости индекса делаем по пакетному замеру и WAL.
**Результаты восстановления** (`restore.json`):
| этап | с |
| --- | --- |
| `pg_dump -Fc bench` (200 000 сообщений, 14,3 MiB) | 1,89 |
| `pg_dump -Fc messenger` | 0,45 |
| копирование дампов через хост | 1,52 |
| `pg_restore -j 4` bench (данные + индексы + FK) | 2,11 |
| `pg_restore` messenger | 0,40 |
| `ANALYZE` | 0,67 |
| запуск и readiness `api-restore` | 6,66 |
| **RTO на этом стенде** | **≈ 14** (13,7) |
- Count всех таблиц и все md5 совпали (`mismatches: []`). `api-restore` на восстановленной БД: `GET /users/me` с **прежним** токеном → 200, история чата совпадает с исходной.
- Запись во время дампа: всего закоммичено 11 219 строк-маркеров, в backup — 4 329 (закоммиченные до снимка; до старта `pg_dump` их было ≥ 3 694), **6 890 после начала снимка потеряны** при восстановлении из этого дампа. **Гипотеза 3 подтверждена:** RPO логического backup = момент начала `pg_dump`. В предыдущем прогоне — 4 482 / 6 690 и RTO 14 с: порядок величин воспроизводится.
**Обсуждение и ограничения.**
- Все замеры «тёплые» (данные в shared buffers/кэше ОС); холодный кэш на Docker Desktop честно не воспроизводится (кэш ОС VM не сбрасывается). Буферы и форма плана — основная метрика, миллисекунды — ориентир для этого ноутбука.
- Запросы с литералами; приложение через psycopg после 5 повторов использует prepared statements, и PostgreSQL может выбрать generic plan. Для рабочего индекса он тот же (Index Scan), для OFFSET/перекошенных данных может отличаться.
- `random_page_cost=4` оставлен по умолчанию; рекомендация для SSD — 1.1, но keyset от этого не зависит.
- RTO растёт примерно линейно с объёмом (restore + построение индексов): при 13 MiB дампа — секунды, на гигабайтах — минуты–часы; ускоряют `-j`, физический backup (`pg_basebackup`). RPO логического дампа = период между дампами; для секундного RPO нужен PITR (архив WAL + базовая копия) — не реализован.
- `pg_dump` одной БД не содержит роли/глобальные объекты (`pg_dumpall --globals-only`); у нас роль создаётся образом при init.
- Backup содержит хеши паролей и хеши действующих сессий — восстановленная копия принимает старые токены; дамп нужно хранить как секрет (`backups/` вне Git).
- Один Docker-host: нет защиты от потери хоста/диска, backup хранится на той же машине.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| restart api + postgres + valkey (`restart.sh`) | данные и прежний токен сохраняются | PASS, тот же токен | ≈ 10 с до ready; потерь нет |
| `docker compose stop valkey` | обход кэша, всё работает | 2xx; первый запрос 1,0 с, далее ≤ 0,03 с; logout 204 → 401 | мгновенно; потерь нет |
| `docker compose pause valkey` + logout + unpause | отозванный токен не работает | logout 204; через 6 с после unpause /users/me и сообщение → 401 | — |
| `pause valkey` + logout + рестарт API + unpause | отзыв переживает рестарт процесса | /users/me и сообщение → 401 | — |
| `docker compose stop postgres` | ограниченный 503, анонимный не проходит | 503 за ≈ 2 с, неизвестный токен 503, ready 503, live 200 | ready через ≈ 15 с после stop (включая ~12 с проверок во время отказа); потерь нет |
| `docker compose pause postgres` | ограниченный 503 вместо зависания | история, отправка, вход, неизвестный токен → 503 за ≈ 2 с; ready 503 за 1 с; live 200 | готовность через < 1 с после unpause; потерь нет |
| SESSION_TTL_SECONDS=2 | истечение сессии | 401 через 3,5 с | — |
| SIGTERM api | корректная остановка | 0,48 с, exit 0 | — |
| backup → restore в новый volume | совпадение данных | count и md5 совпали, API со старым токеном | RTO ≈ 14 с; потеряны записи после начала дампа (6 890) |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Выдерживается: рестарт любого контейнера, отказ Valkey (деградация без ошибок), временный отказ PostgreSQL (503 и восстановление). Не выдерживается: потеря volume/хоста без backup; единственная БД — точка отказа.
- Сверку отзывов с кэшем запускает процесс, который сам увидел ошибку Valkey или только что стартовал. В lab3 реплика, не видевшая отказа Valkey, может читать кэш до того, как другая реплика перенесёт туда отзыв; для нескольких реплик сверку нужно запускать периодически или по общему признаку в PostgreSQL.
- Если запрос к замороженной БД прерван уже после отправки COMMIT, клиент получит 503, а транзакция может оказаться применённой — исход неопределён; идемпотентность записи появится в lab3 (`Idempotency-Key`).
- Valkey без пароля и TLS — допустимо только во внутренней сети учебного стенда; TLS для внешнего API появится в lab7, Basic по HTTP — только локально.
- Rate limiting входа (защита от перебора паролей) не реализован.
- Истёкшие сессии удаляются при следующем входе пользователя; фоновой чистки нет (индекс `expires_at` готов для неё).
- Для lab3: API stateless, сессии общие (PostgreSQL), миграции вынесены — готово к нескольким репликам; добавятся `Idempotency-Key` и `X-Instance-Id`.
+126
View File
@@ -0,0 +1,126 @@
name: grigoriev-lab2
x-app-env: &app-env
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: ${APP_ENV:-lab}
APP_SHUTDOWN_TIMEOUT: ${APP_SHUTDOWN_TIMEOUT:-5}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
DB_POOL_MIN: ${DB_POOL_MIN:-1}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-2}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-3000}
DB_REQUEST_TIMEOUT_SECONDS: ${DB_REQUEST_TIMEOUT_SECONDS:-4}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL: ${CACHE_URL:-redis://valkey:6379/0}
x-dns-opt: &dns-opt
- timeout:1
- attempts:1
x-postgres: &postgres
image: postgres:17.11-alpine@sha256:266d3c257594e195b309ae9d1805e54c788f1d7b375f56bf6c367aac6c917e7b
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
command: ["postgres", "-c", "track_io_timing=on"]
secrets: [postgres_password]
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 12
start_period: 10s
stop_grace_period: 30s
networks: [backend]
restart: unless-stopped
services:
postgres:
<<: *postgres
volumes:
- pgdata:/var/lib/postgresql/data
valkey:
image: valkey/valkey:8.1.11-alpine@sha256:2602ace2be6569bc2bbb06f873776516ab9089821525be34f4305c67eb9db02a
command: ["valkey-server", "--save", "", "--appendonly", "no",
"--maxmemory", "64mb", "--maxmemory-policy", "volatile-ttl"]
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 12
networks: [backend]
restart: unless-stopped
migrate:
build: .
image: mtusi-messenger:lab2
command: ["python", "src/migrate.py"]
environment: *app-env
secrets: [database_url]
depends_on:
postgres:
condition: service_healthy
networks: [backend]
restart: "no"
api:
build: .
image: mtusi-messenger:lab2
environment: *app-env
secrets: [database_url]
ports:
- "127.0.0.1:8080:8080"
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
valkey:
condition: service_started
dns_opt: *dns-opt
stop_grace_period: 10s
networks: [frontend, backend]
restart: unless-stopped
postgres-restore:
<<: *postgres
profiles: [restore]
volumes:
- pgdata_restore:/var/lib/postgresql/data
api-restore:
image: mtusi-messenger:lab2
profiles: [restore]
environment:
<<: *app-env
DATABASE_URL_FILE: /run/secrets/database_url_restore
CACHE_URL: ""
dns_opt: *dns-opt
secrets: [database_url_restore]
ports:
- "127.0.0.1:${RESTORE_API_PORT:-8081}:8080"
depends_on:
postgres-restore:
condition: service_healthy
networks: [frontend, backend]
volumes:
pgdata:
pgdata_restore:
networks:
frontend:
backend:
internal: true
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
database_url_restore:
file: ./secrets/database_url_restore
+14
View File
@@ -3,3 +3,17 @@
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
## Файлы этого решения (последний прогон 2026-11-06 со свежих volumes, Windows 10 + Docker Desktop 27.2.0, VM 12 CPU / 1,9 GiB)
| Файл | Команда | Что показывает |
| --- | --- | --- |
| `smoke.txt` | `python tests/smoke.py --base-url http://127.0.0.1:8080` | публичный сценарий lab2 |
| `persistence.txt` | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS + `docker compose ps` до/после, строки остановки/старта из логов, volumes |
| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 38 собственных тестов: API (включая U+0000), аутентификация, гонки, rollback, миграции |
| `expiry.txt` | `python student-tests/expiry_check.py --ttl 2` | истечение сессии и TTL ключа в Valkey |
| `failure.txt` | `python student-tests/failure_check.py` | отказ Valkey (stop; pause с logout; pause с logout и рестартом API) и PostgreSQL (stop и pause) |
| `sigterm.txt` | `python student-tests/sigterm_check.py` | остановка API по SIGTERM |
| `load.json` | `python tests/load.py --duration 30 --concurrency 4` | базовая нагрузка |
| `explain-history.txt` | `python research/track2.py explain` | EXPLAIN (ANALYZE, BUFFERS) истории на 200 000 сообщений |
| `track2/*.json`, `track2/results.md` | `python research/track2.py all` | трек 2: чтение, запись, backup/restore |
+10
View File
@@ -0,0 +1,10 @@
# python student-tests/expiry_check.py --ttl 2
# date: 2026-11-06T09:35:40Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM
пересоздаю api с SESSION_TTL_SECONDS=2
сразу после входа: /users/me -> 200
TTL ключа этой сессии в Valkey: 1 с (-2 = ключа нет)
через 3.5 с: /users/me -> 401, WWW-Authenticate: Bearer realm="messenger"
logout истёкшим токеном -> 401
PASS: сессия истекла по SESSION_TTL_SECONDS=2, кэш не продлил её
возвращаю api с TTL из .env
+65
View File
@@ -0,0 +1,65 @@
# EXPLAIN (ANALYZE, BUFFERS): история сообщений, рабочий индекс messages_chat_history_idx
# {"date": "2026-11-06T09:31:42Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"}
# messages: 200000; big chat: 100000, medium: 3000, small: 10
## big_first
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2' ORDER BY created_at, id LIMIT 51
Limit (cost=0.42..27.64 rows=51 width=462) (actual time=0.023..0.043 rows=51 loops=1)
Buffers: shared hit=9
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..53519.06 rows=100267 width=462) (actual time=0.022..0.038 rows=51 loops=1)
Index Cond: (chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2'::uuid)
Buffers: shared hit=9
Planning:
Buffers: shared hit=139
Planning Time: 1.200 ms
Execution Time: 0.107 ms
## big_d90_keyset
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2' AND (created_at, id) > ('2026-09-28 00:28:21.157057+00', '68768260-63ef-498c-a995-6183f15116f1') ORDER BY created_at, id LIMIT 51
Limit (cost=0.42..143.21 rows=51 width=462) (actual time=0.031..0.056 rows=51 loops=1)
Buffers: shared hit=11
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..28399.10 rows=10143 width=462) (actual time=0.030..0.052 rows=51 loops=1)
Index Cond: ((chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2'::uuid) AND (ROW(created_at, id) > ROW('2026-09-28 00:28:21.157057+00'::timestamp with time zone, '68768260-63ef-498c-a995-6183f15116f1'::uuid)))
Buffers: shared hit=11
Planning:
Buffers: shared hit=138
Planning Time: 0.939 ms
Execution Time: 0.128 ms
## big_d90_offset
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2' ORDER BY created_at, id OFFSET 90000 LIMIT 51
Limit (cost=36336.63..36336.74 rows=1 width=462) (actual time=86.122..93.620 rows=51 loops=1)
Buffers: shared hit=12716, temp read=5489 written=5853
I/O Timings: temp read=6.704 write=28.200
-> Gather Merge (cost=26587.75..36336.63 rows=83556 width=462) (actual time=57.285..91.018 rows=90051 loops=1)
Workers Planned: 2
Workers Launched: 2
Buffers: shared hit=12716, temp read=5489 written=5853
I/O Timings: temp read=6.704 write=28.200
-> Sort (cost=25587.72..25692.17 rows=41778 width=462) (actual time=52.688..58.040 rows=30085 loops=3)
Sort Key: created_at, id
Sort Method: external merge Disk: 15856kB
Buffers: shared hit=12716, temp read=5489 written=5853
I/O Timings: temp read=6.704 write=28.200
Worker 0: Sort Method: external merge Disk: 15016kB
Worker 1: Sort Method: external merge Disk: 15816kB
-> Parallel Seq Scan on messages (cost=0.00..13669.67 rows=41778 width=462) (actual time=0.009..16.948 rows=33333 loops=3)
Filter: (chat_id = 'bab8f878-617d-4988-a42a-c28b81490ed2'::uuid)
Rows Removed by Filter: 33333
Buffers: shared hit=12628
Planning:
Buffers: shared hit=139
Planning Time: 1.009 ms
Execution Time: 95.985 ms
## small_first
SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = 'fb9c80b1-749e-4946-aec5-cd8b3ab4eab1' ORDER BY created_at, id LIMIT 51
Limit (cost=0.42..51.00 rows=12 width=462) (actual time=0.034..0.078 rows=10 loops=1)
Buffers: shared hit=13
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..51.00 rows=12 width=462) (actual time=0.033..0.075 rows=10 loops=1)
Index Cond: (chat_id = 'fb9c80b1-749e-4946-aec5-cd8b3ab4eab1'::uuid)
Buffers: shared hit=13
Planning:
Buffers: shared hit=139
Planning Time: 0.955 ms
Execution Time: 0.145 ms
+40
View File
@@ -0,0 +1,40 @@
# python student-tests/failure_check.py
# date: 2026-11-06T09:35:49Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM
1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL
первый запрос: обнаружение отказа кэша -> 200 за 1.01 с OK
GET /users/me действующим токеном -> 200 за 0.01 с OK
POST сообщение -> 201 за 0.01 с OK
неизвестный токен -> 401 за 0.00 с OK
без Authorization -> 401 за 0.00 с OK
/health/ready (Valkey некритичен) -> 200 за 0.00 с OK
регистрация и вход без кэша -> 200 за 0.07 с OK
logout без кэша -> 204 за 1.01 с OK
отозванный токен -> 401 за 0.01 с OK
1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша
logout при паузе Valkey -> 204 за 0.42 с OK
через 6 с после unpause: /users/me -> 401 за 0.01 с OK
через 6 с после unpause: сообщение -> 401 за 0.00 с OK
1в. Valkey на паузе: logout, рестарт API, unpause — отзыв переживает рестарт процесса
logout при паузе Valkey -> 204 за 0.41 с OK
после рестарта API и unpause: /users/me -> 401 за 0.02 с OK
после рестарта API и unpause: сообщение -> 401 за 0.00 с OK
2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит
GET история -> 503 за 2.00 с OK
POST сообщение -> 503 за 2.01 с OK
неизвестный токен (не 200!) -> 503 за 2.00 с OK
без Authorization -> 401 за 0.00 с OK
вход по Basic верным паролем -> 503 за 2.00 с OK
/health/live -> 200 за 0.00 с OK
/health/ready -> 503 за 1.00 с OK
3. PostgreSQL запущен: готовность через 15.1 с после остановки
прежний токен -> 200; история: ['до отказа', 'без кэша']
4. PostgreSQL заморожен (pause): запросы получают 503 в пределах общего срока, а не зависают
GET история -> 503 за 2.92 с OK
POST сообщение -> 503 за 2.01 с OK
неизвестный токен (не 200!) -> 503 за 2.00 с OK
вход по Basic -> 503 за 2.01 с OK
/health/ready -> 503 за 1.01 с OK
/health/live -> 200 за 0.00 с OK
готовность через 0.0 с после unpause; история: ['до отказа', 'без кэша']
PASS: отказы Valkey и PostgreSQL обработаны
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 2,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.08,
"concurrency": 4,
"successful_requests": 8513,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 283.007,
"successful_latency_ms": {
"p50": 11.961,
"p95": 32.043,
"p99": 36.317
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+32
View File
@@ -0,0 +1,32 @@
# persistence: python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080
# date: 2026-11-06T09:35:18Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM
$ docker compose ps -a (before)
SERVICE STATUS
api Up 18 seconds (healthy)
migrate Exited (0) 19 seconds ago
postgres Up 26 seconds (healthy)
valkey Up 26 seconds (healthy)
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
$ docker compose ps -a (after)
SERVICE STATUS
api Up 1 second (health: starting)
migrate Exited (0) 1 second ago
postgres Up 8 seconds (healthy)
valkey Up 8 seconds (healthy)
$ docker compose logs --since 2026-11-06T09:35:18Z postgres valkey api | shutdown/ready lines
valkey-1 | 7:M 06 Nov 2026 09:35:19.811 * User requested shutdown...
valkey-1 | 7:M 06 Nov 2026 09:35:20.228 * Ready to accept connections tcp
api-1 | 2026-11-06 09:35:19,146 INFO messenger: application stopping
api-1 | 2026-11-06 09:35:28,169 INFO uvicorn.error: Waiting for application startup.
api-1 | 2026-11-06 09:35:28,171 INFO messenger: application started
postgres-1 | 2026-11-06 09:35:19.812 UTC [1] LOG: database system is shut down
postgres-1 | 2026-11-06 09:35:20.286 UTC [29] LOG: database system was shut down at 2026-11-06 09:35:19 UTC
postgres-1 | 2026-11-06 09:35:20.291 UTC [1] LOG: database system is ready to accept connections
$ docker volume ls (volumes kept)
grigoriev-lab2_pgdata
+21
View File
@@ -0,0 +1,21 @@
# python student-tests/sigterm_check.py; then docker compose start api
# date: 2026-11-06T09:36:47Z
сообщение с маркером отправлено: HTTP 201; маркер в логах: False
docker stop занял: 0.48 с (лимит 10 с)
код выхода контейнера: 0 (0 — сам завершился по SIGTERM; 137 — убит SIGKILL)
запросы до SIGTERM: 41, все 200: True
запросы после SIGTERM: 19, результаты: ['200', 'RemoteDisconnected', 'URLError']
ответов 5xx за всё время: 0
логи остановки:
2026-11-06 09:36:06,143 INFO uvicorn.error: Shutting down
2026-11-06 09:36:06,244 INFO uvicorn.error: Waiting for application shutdown.
2026-11-06 09:36:06,244 INFO messenger: application stopping
2026-11-06 09:36:06,245 INFO uvicorn.error: Application shutdown complete.
2026-11-06 09:36:06,245 INFO uvicorn.error: Finished server process [1]
2026-11-06 09:36:48,504 INFO uvicorn.error: Shutting down
2026-11-06 09:36:48,605 INFO uvicorn.error: Waiting for application shutdown.
2026-11-06 09:36:48,605 INFO messenger: application stopping
2026-11-06 09:36:48,606 INFO uvicorn.error: Application shutdown complete.
2026-11-06 09:36:48,606 INFO uvicorn.error: Finished server process [1]
+4
View File
@@ -0,0 +1,4 @@
# python tests/smoke.py --base-url http://127.0.0.1:8080
# date: 2026-11-06T09:35:17Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM
PASS: lab2 public API scenario; infrastructure and grading evidence remain separate.
+86
View File
@@ -0,0 +1,86 @@
# python -m unittest discover -s student-tests -v
# date: 2026-11-06T09:35:29Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, 12 CPU / 1.9 GiB for Docker VM
test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username)
Повторная регистрация того же username -> 409 conflict ... ok
test_empty_text (test_api.EmptyMessageTest.test_empty_text)
Пустой текст -> 400 ... ok
test_missing_text (test_api.EmptyMessageTest.test_missing_text)
Тело без поля text -> 400 ... ok
test_text_length_limit (test_api.EmptyMessageTest.test_text_length_limit)
4000 символов можно (эмодзи = 1 символ), 4001 — 400 ... ok
test_whitespace_text (test_api.EmptyMessageTest.test_whitespace_text)
Текст только из пробельных символов -> 400 ... ok
test_member_has_access (test_api.ForeignChatTest.test_member_has_access)
Участник видит чат (контроль: 404 выше не из-за ошибки в тесте) ... ok
test_outsider_cannot_read_chat (test_api.ForeignChatTest.test_outsider_cannot_read_chat)
Посторонний читает чат -> 404, как будто чата нет ... ok
test_outsider_cannot_write_or_read_history (test_api.ForeignChatTest.test_outsider_cannot_write_or_read_history)
Посторонний пишет/читает историю -> 404 ... ok
test_outsider_does_not_see_chat_in_list (test_api.ForeignChatTest.test_outsider_does_not_see_chat_in_list)
Чужой чат не попадает в список чатов ... ok
test_lone_surrogate_is_rejected (test_api.IdentityTest.test_lone_surrogate_is_rejected)
Одиночный суррогат не кодируется в UTF-8 -> 400, а не 500 ... ok
test_nul_character_is_preserved (test_api.IdentityTest.test_nul_character_is_preserved)
U+0000 — допустимый code point: сообщение, display_name и title сохраняются и читаются без изменений ... ok
test_sender_cannot_be_forged (test_api.IdentityTest.test_sender_cannot_be_forged)
sender_id в теле запрещён: отправитель только из сессии ... ok
test_extra_field (test_api.InvalidJsonTest.test_extra_field)
Лишнее поле в теле -> 400 ... ok
test_json_not_object (test_api.InvalidJsonTest.test_json_not_object)
JSON-массив вместо объекта -> 400 ... ok
test_malformed_json (test_api.InvalidJsonTest.test_malformed_json)
Битый JSON -> 400 invalid_request ... ok
test_wrong_type (test_api.InvalidJsonTest.test_wrong_type)
Число вместо строки -> 400 (без тихого приведения типов) ... ok
test_cursor_from_other_chat (test_api.PaginationTest.test_cursor_from_other_chat)
cursor от другого чата -> 400 ... ok
test_invalid_cursor_and_limit (test_api.PaginationTest.test_invalid_cursor_and_limit)
Мусорный cursor и limit вне 1..100 -> 400 ... ok
test_walk_several_pages (test_api.PaginationTest.test_walk_several_pages)
7 сообщений по 3: три страницы, без потерь, повторов и перестановок ... ok
test_authentication_before_validation (test_auth.BearerTest.test_authentication_before_validation)
Аноним с битым JSON на защищённом endpoint получает 401, а не 400; с сессией — 400 ... ok
test_only_bearer_is_accepted (test_auth.BearerTest.test_only_bearer_is_accepted)
Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer ... ok
test_scheme_is_case_insensitive (test_auth.BearerTest.test_scheme_is_case_insensitive)
Схема аутентификации нечувствительна к регистру (RFC 9110) ... ok
test_x_user_id_does_not_override_session (test_auth.BearerTest.test_x_user_id_does_not_override_session)
X-User-Id игнорируется: владелец определяется только токеном ... ok
test_login_rejects_body (test_auth.LoginTest.test_login_rejects_body)
POST /auth/sessions принимает только заголовок, JSON body -> 400 ... ok
test_login_returns_opaque_session (test_auth.LoginTest.test_login_returns_opaque_session)
Вход: 201, token_type=Bearer, токен случайный и не содержит username/UUID ... ok
test_malformed_basic (test_auth.LoginTest.test_malformed_basic)
Нет заголовка, не base64, нет двоеточия, Bearer вместо Basic -> 401 Basic ... ok
test_password_with_colon_and_unicode (test_auth.LoginTest.test_password_with_colon_and_unicode)
Двоеточие и не-ASCII в пароле допустимы: делим только по первому ':' ... ok
test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same)
Неверный пароль и несуществующий пользователь -> одинаковый 401 с Basic challenge ... ok
test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session)
Logout -> 204 без тела; этот токен -> 401, вторая сессия того же пользователя работает ... ok
test_password_is_not_returned (test_auth.RegistrationTest.test_password_is_not_returned)
Ответ регистрации и /users/me не содержат password/hash ... ok
test_password_length_limits (test_auth.RegistrationTest.test_password_length_limits)
Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом ... ok
test_password_required_and_not_blank (test_auth.RegistrationTest.test_password_required_and_not_blank)
Без password или из одних пробелов -> 400 ... ok
test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients)
100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории ... ok
test_parallel_registration_of_same_username (test_concurrency.ConcurrencyTest.test_parallel_registration_of_same_username)
20 одновременных регистраций одного username -> ровно один 201, остальные 409; вход только с паролем победителя ... ok
test_chat_creation_is_rolled_back (test_db.DatabaseTest.test_chat_creation_is_rolled_back)
Неизвестный участник: INSERT chats выполнен, INSERT chat_members упал по FK, всё откатано ... ok
test_history_query_uses_index (test_db.DatabaseTest.test_history_query_uses_index)
Запрос страницы истории идёт по индексу (chat_id, created_at, id), без Sort ... ok
test_migrations_are_idempotent (test_db.DatabaseTest.test_migrations_are_idempotent)
Повторный запуск миграций ничего не меняет и завершается успешно ... ok
test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_not_stored_in_plaintext)
В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok
----------------------------------------------------------------------
Ran 38 tests in 11.284s
OK
отправлено 201: 100, уникальных id: 100, прочитано: 100 за 4 страниц(ы)
@@ -0,0 +1,29 @@
{
"big_d50_offset": {
"median_ms": 12.147,
"p95_ms": 12.302,
"planning_ms": 0.069,
"shared_hit": 8065,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"big_d90_offset": {
"median_ms": 22.887,
"p95_ms": 23.85,
"planning_ms": 0.073,
"shared_hit": 14568,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"medium_d90_offset": {
"median_ms": 1.702,
"p95_ms": 2.26,
"planning_ms": 0.059,
"shared_hit": 2499,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
}
}
@@ -0,0 +1,29 @@
{
"big_d50_offset": {
"median_ms": 12.699,
"p95_ms": 13.438,
"planning_ms": 0.074,
"shared_hit": 8065,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"big_d90_offset": {
"median_ms": 103.23,
"p95_ms": 113.371,
"planning_ms": 0.081,
"shared_hit": 12716,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_d90_offset": {
"median_ms": 4.908,
"p95_ms": 5.356,
"planning_ms": 0.062,
"shared_hit": 2867,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(messages_chat_history_idx)"
}
}
+578
View File
@@ -0,0 +1,578 @@
{
"environment": {
"date": "2026-11-06T09:24:18Z",
"docker_cpus": 12,
"docker_memory_gib": 1.9,
"docker_server": "27.2.0",
"postgres": "17.11",
"shared_buffers": "128MB"
},
"runs": 15,
"warmup": 3,
"variants": {
"pk_only": {
"build_seconds": 0.0,
"index_bytes": 0,
"queries": {
"big_first": {
"median_ms": 29.855,
"p95_ms": 33.463,
"planning_ms": 0.07,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d50_keyset": {
"median_ms": 27.84,
"p95_ms": 29.521,
"planning_ms": 0.086,
"shared_hit": 12303,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d50_offset": {
"median_ms": 82.726,
"p95_ms": 91.053,
"planning_ms": 0.071,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d90_keyset": {
"median_ms": 24.206,
"p95_ms": 24.969,
"planning_ms": 0.081,
"shared_hit": 12303,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d90_offset": {
"median_ms": 95.196,
"p95_ms": 101.548,
"planning_ms": 0.073,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_first": {
"median_ms": 21.283,
"p95_ms": 22.359,
"planning_ms": 0.063,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_d50_keyset": {
"median_ms": 23.805,
"p95_ms": 24.848,
"planning_ms": 0.084,
"shared_hit": 12303,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_d50_offset": {
"median_ms": 22.787,
"p95_ms": 24.114,
"planning_ms": 0.065,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_d90_keyset": {
"median_ms": 22.095,
"p95_ms": 23.473,
"planning_ms": 0.075,
"shared_hit": 12303,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_d90_offset": {
"median_ms": 23.605,
"p95_ms": 25.903,
"planning_ms": 0.07,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"small_first": {
"median_ms": 20.489,
"p95_ms": 22.56,
"planning_ms": 0.066,
"shared_hit": 12361,
"shared_read": 0,
"rows": 10,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"small_d50_keyset": {
"median_ms": 21.807,
"p95_ms": 23.296,
"planning_ms": 0.074,
"shared_hit": 12273,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Sort > Gather > Seq Scan"
},
"small_d50_offset": {
"median_ms": 20.635,
"p95_ms": 21.433,
"planning_ms": 0.065,
"shared_hit": 12361,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"small_d90_keyset": {
"median_ms": 22.765,
"p95_ms": 24.006,
"planning_ms": 0.076,
"shared_hit": 12273,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Sort > Gather > Seq Scan"
},
"small_d90_offset": {
"median_ms": 20.671,
"p95_ms": 21.792,
"planning_ms": 0.065,
"shared_hit": 12361,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
}
}
},
"chat_id": {
"build_seconds": 0.43,
"index_bytes": 1572864,
"queries": {
"big_first": {
"median_ms": 28.506,
"p95_ms": 29.773,
"planning_ms": 0.074,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d50_keyset": {
"median_ms": 26.492,
"p95_ms": 28.799,
"planning_ms": 0.095,
"shared_hit": 12303,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d50_offset": {
"median_ms": 86.904,
"p95_ms": 89.746,
"planning_ms": 0.079,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d90_keyset": {
"median_ms": 24.488,
"p95_ms": 25.492,
"planning_ms": 0.085,
"shared_hit": 12303,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"big_d90_offset": {
"median_ms": 99.044,
"p95_ms": 102.717,
"planning_ms": 0.08,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_first": {
"median_ms": 2.821,
"p95_ms": 3.308,
"planning_ms": 0.052,
"shared_hit": 2694,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)"
},
"medium_d50_keyset": {
"median_ms": 3.69,
"p95_ms": 3.892,
"planning_ms": 0.074,
"shared_hit": 2694,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)"
},
"medium_d50_offset": {
"median_ms": 5.17,
"p95_ms": 5.732,
"planning_ms": 0.068,
"shared_hit": 2694,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)"
},
"medium_d90_keyset": {
"median_ms": 3.184,
"p95_ms": 3.875,
"planning_ms": 0.069,
"shared_hit": 2694,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)"
},
"medium_d90_offset": {
"median_ms": 5.065,
"p95_ms": 5.217,
"planning_ms": 0.059,
"shared_hit": 2694,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(bench_chat_idx)"
},
"small_first": {
"median_ms": 0.057,
"p95_ms": 0.093,
"planning_ms": 0.048,
"shared_hit": 13,
"shared_read": 0,
"rows": 10,
"plan": "Limit > Sort > Index Scan(bench_chat_idx)"
},
"small_d50_keyset": {
"median_ms": 0.046,
"p95_ms": 0.065,
"planning_ms": 0.046,
"shared_hit": 13,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Sort > Index Scan(bench_chat_idx)"
},
"small_d50_offset": {
"median_ms": 0.044,
"p95_ms": 0.05,
"planning_ms": 0.04,
"shared_hit": 13,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Sort > Index Scan(bench_chat_idx)"
},
"small_d90_keyset": {
"median_ms": 0.058,
"p95_ms": 0.089,
"planning_ms": 0.058,
"shared_hit": 13,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Sort > Index Scan(bench_chat_idx)"
},
"small_d90_offset": {
"median_ms": 0.047,
"p95_ms": 0.056,
"planning_ms": 0.04,
"shared_hit": 13,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Sort > Index Scan(bench_chat_idx)"
}
}
},
"created_at_id": {
"build_seconds": 0.42,
"index_bytes": 8126464,
"queries": {
"big_first": {
"median_ms": 0.066,
"p95_ms": 0.115,
"planning_ms": 0.033,
"shared_hit": 9,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"big_d50_keyset": {
"median_ms": 0.059,
"p95_ms": 0.088,
"planning_ms": 0.058,
"shared_hit": 18,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"big_d50_offset": {
"median_ms": 23.172,
"p95_ms": 24.77,
"planning_ms": 0.056,
"shared_hit": 9806,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"big_d90_keyset": {
"median_ms": 0.053,
"p95_ms": 0.086,
"planning_ms": 0.052,
"shared_hit": 17,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"big_d90_offset": {
"median_ms": 42.03,
"p95_ms": 42.737,
"planning_ms": 0.056,
"shared_hit": 17650,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"medium_first": {
"median_ms": 0.351,
"p95_ms": 0.411,
"planning_ms": 0.025,
"shared_hit": 327,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"medium_d50_keyset": {
"median_ms": 0.431,
"p95_ms": 0.508,
"planning_ms": 0.047,
"shared_hit": 375,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"medium_d50_offset": {
"median_ms": 21.222,
"p95_ms": 23.522,
"planning_ms": 0.074,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_d90_keyset": {
"median_ms": 0.371,
"p95_ms": 0.45,
"planning_ms": 0.046,
"shared_hit": 314,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"medium_d90_offset": {
"median_ms": 21.646,
"p95_ms": 23.229,
"planning_ms": 0.072,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"small_first": {
"median_ms": 20.97,
"p95_ms": 21.726,
"planning_ms": 0.074,
"shared_hit": 12361,
"shared_read": 0,
"rows": 10,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"small_d50_keyset": {
"median_ms": 22.362,
"p95_ms": 23.698,
"planning_ms": 0.086,
"shared_hit": 12273,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Sort > Gather > Seq Scan"
},
"small_d50_offset": {
"median_ms": 20.795,
"p95_ms": 22.545,
"planning_ms": 0.079,
"shared_hit": 12361,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"small_d90_keyset": {
"median_ms": 0.606,
"p95_ms": 1.147,
"planning_ms": 0.052,
"shared_hit": 548,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Index Scan(bench_time_idx)"
},
"small_d90_offset": {
"median_ms": 20.988,
"p95_ms": 22.671,
"planning_ms": 0.075,
"shared_hit": 12361,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
}
}
},
"chat_created_id": {
"build_seconds": 0.45,
"index_bytes": 11796480,
"queries": {
"big_first": {
"median_ms": 0.041,
"p95_ms": 0.062,
"planning_ms": 0.043,
"shared_hit": 9,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"big_d50_keyset": {
"median_ms": 0.044,
"p95_ms": 0.054,
"planning_ms": 0.05,
"shared_hit": 13,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"big_d50_offset": {
"median_ms": 12.13,
"p95_ms": 12.453,
"planning_ms": 0.069,
"shared_hit": 8064,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"big_d90_keyset": {
"median_ms": 0.074,
"p95_ms": 0.148,
"planning_ms": 0.086,
"shared_hit": 11,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"big_d90_offset": {
"median_ms": 122.989,
"p95_ms": 182.894,
"planning_ms": 0.105,
"shared_hit": 12361,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Gather Merge > Sort > Seq Scan"
},
"medium_first": {
"median_ms": 0.073,
"p95_ms": 0.087,
"planning_ms": 0.053,
"shared_hit": 51,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"medium_d50_keyset": {
"median_ms": 0.07,
"p95_ms": 0.104,
"planning_ms": 0.059,
"shared_hit": 48,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"medium_d50_offset": {
"median_ms": 0.999,
"p95_ms": 1.258,
"planning_ms": 0.063,
"shared_hit": 1408,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"medium_d90_keyset": {
"median_ms": 0.067,
"p95_ms": 0.103,
"planning_ms": 0.076,
"shared_hit": 49,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"medium_d90_offset": {
"median_ms": 6.129,
"p95_ms": 7.569,
"planning_ms": 0.081,
"shared_hit": 2714,
"shared_read": 0,
"rows": 51,
"plan": "Limit > Sort > Bitmap Heap Scan > Bitmap Index Scan(messages_chat_history_idx)"
},
"small_first": {
"median_ms": 0.037,
"p95_ms": 0.05,
"planning_ms": 0.048,
"shared_hit": 13,
"shared_read": 0,
"rows": 10,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"small_d50_keyset": {
"median_ms": 0.054,
"p95_ms": 0.065,
"planning_ms": 0.071,
"shared_hit": 8,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"small_d50_offset": {
"median_ms": 0.036,
"p95_ms": 0.054,
"planning_ms": 0.044,
"shared_hit": 13,
"shared_read": 0,
"rows": 5,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"small_d90_keyset": {
"median_ms": 0.047,
"p95_ms": 0.099,
"planning_ms": 0.069,
"shared_hit": 4,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
},
"small_d90_offset": {
"median_ms": 0.038,
"p95_ms": 0.049,
"planning_ms": 0.049,
"shared_hit": 13,
"shared_read": 0,
"rows": 1,
"plan": "Limit > Index Scan(messages_chat_history_idx)"
}
}
}
}
}
+52
View File
@@ -0,0 +1,52 @@
{
"environment": {
"date": "2026-11-06T09:33:39Z",
"docker_cpus": 12,
"docker_memory_gib": 1.9,
"docker_server": "27.2.0",
"postgres": "17.11",
"shared_buffers": "128MB"
},
"dump_bytes": 15031377,
"times_seconds": {
"dump_bench": 1.89,
"dump_messenger": 0.45,
"copy": 1.52,
"restore_bench": 2.11,
"restore_messenger": 0.4,
"analyze": 0.67,
"api_restore_ready": 6.66
},
"rto_seconds": 13.7,
"source": {
"users": "1000",
"chats": "4021",
"chat_members": "8600",
"messages": "200000",
"all_messages_md5": "8b73772737bfac55f58fcb44bb7cf76b",
"big_first_page_md5": "dc073bfb1f81a079c2213518ba3892a3",
"big_d90_page_md5": "aad19d2102ee255431bf6eb01e46ed30",
"small_chat_md5": "0003ec25c51fc6f6d025c469ab5ca302"
},
"restored": {
"users": "1000",
"chats": "4021",
"chat_members": "8600",
"messages": "200000",
"all_messages_md5": "8b73772737bfac55f58fcb44bb7cf76b",
"big_first_page_md5": "dc073bfb1f81a079c2213518ba3892a3",
"big_d90_page_md5": "aad19d2102ee255431bf6eb01e46ed30",
"small_chat_md5": "0003ec25c51fc6f6d025c469ab5ca302"
},
"mismatches": [],
"concurrent_writes": {
"committed_before_dump_start": 3694,
"committed_total": 11219,
"present_in_backup": 4329,
"lost_after_snapshot": 6890
},
"api_restore": {
"old_token_users_me": 200,
"message_matches": true
}
}
+111
View File
@@ -0,0 +1,111 @@
# Трек 2: результаты
Среда: `{"date": "2026-11-06T09:24:18Z", "docker_cpus": 12, "docker_memory_gib": 1.9, "docker_server": "27.2.0", "postgres": "17.11", "shared_buffers": "128MB"}`
## Чтение страницы истории (LIMIT 51), медиана из 15 прогонов, мс
| запрос | pk_only | chat_id | created_at_id | chat_created_id |
|---|---|---|---|---|
| big_first | 29.855 | 28.506 | 0.066 | 0.041 |
| big_d50_keyset | 27.840 | 26.492 | 0.059 | 0.044 |
| big_d50_offset | 82.726 | 86.904 | 23.172 | 12.130 |
| big_d90_keyset | 24.206 | 24.488 | 0.053 | 0.074 |
| big_d90_offset | 95.196 | 99.044 | 42.030 | 122.989 |
| medium_first | 21.283 | 2.821 | 0.351 | 0.073 |
| medium_d50_keyset | 23.805 | 3.690 | 0.431 | 0.070 |
| medium_d50_offset | 22.787 | 5.170 | 21.222 | 0.999 |
| medium_d90_keyset | 22.095 | 3.184 | 0.371 | 0.067 |
| medium_d90_offset | 23.605 | 5.065 | 21.646 | 6.129 |
| small_first | 20.489 | 0.057 | 20.970 | 0.037 |
| small_d50_keyset | 21.807 | 0.046 | 22.362 | 0.054 |
| small_d50_offset | 20.635 | 0.044 | 20.795 | 0.036 |
| small_d90_keyset | 22.765 | 0.058 | 0.606 | 0.047 |
| small_d90_offset | 20.671 | 0.047 | 20.988 | 0.038 |
## Буферы (shared hit + read) на запрос
| запрос | pk_only | chat_id | created_at_id | chat_created_id |
|---|---|---|---|---|
| big_first | 12361 | 12361 | 9 | 9 |
| big_d50_keyset | 12303 | 12303 | 18 | 13 |
| big_d50_offset | 12361 | 12361 | 9806 | 8064 |
| big_d90_keyset | 12303 | 12303 | 17 | 11 |
| big_d90_offset | 12361 | 12361 | 17650 | 12361 |
| medium_first | 12361 | 2694 | 327 | 51 |
| medium_d50_keyset | 12303 | 2694 | 375 | 48 |
| medium_d50_offset | 12361 | 2694 | 12361 | 1408 |
| medium_d90_keyset | 12303 | 2694 | 314 | 49 |
| medium_d90_offset | 12361 | 2694 | 12361 | 2714 |
| small_first | 12361 | 13 | 12361 | 13 |
| small_d50_keyset | 12273 | 13 | 12273 | 8 |
| small_d50_offset | 12361 | 13 | 12361 | 13 |
| small_d90_keyset | 12273 | 13 | 548 | 4 |
| small_d90_offset | 12361 | 13 | 12361 | 13 |
## Планы
- pk_only / big_first: `Limit > Gather Merge > Sort > Seq Scan`
- pk_only / big_d90_keyset: `Limit > Gather Merge > Sort > Seq Scan`
- pk_only / big_d90_offset: `Limit > Gather Merge > Sort > Seq Scan`
- pk_only / small_first: `Limit > Gather Merge > Sort > Seq Scan`
- chat_id / big_first: `Limit > Gather Merge > Sort > Seq Scan`
- chat_id / big_d90_keyset: `Limit > Gather Merge > Sort > Seq Scan`
- chat_id / big_d90_offset: `Limit > Gather Merge > Sort > Seq Scan`
- chat_id / small_first: `Limit > Sort > Index Scan(bench_chat_idx)`
- created_at_id / big_first: `Limit > Index Scan(bench_time_idx)`
- created_at_id / big_d90_keyset: `Limit > Index Scan(bench_time_idx)`
- created_at_id / big_d90_offset: `Limit > Index Scan(bench_time_idx)`
- created_at_id / small_first: `Limit > Gather Merge > Sort > Seq Scan`
- chat_created_id / big_first: `Limit > Index Scan(messages_chat_history_idx)`
- chat_created_id / big_d90_keyset: `Limit > Index Scan(messages_chat_history_idx)`
- chat_created_id / big_d90_offset: `Limit > Gather Merge > Sort > Seq Scan`
- chat_created_id / small_first: `Limit > Index Scan(messages_chat_history_idx)`
## Индексы: размер и время построения
| вариант | размер индексов, MiB | построение, с |
|---|---|---|
| pk_only | 0.0 | 0.00 |
| chat_id | 1.5 | 0.43 |
| created_at_id | 7.8 | 0.42 |
| chat_created_id | 11.2 | 0.45 |
## Запись
Пакет: EXPLAIN ANALYZE INSERT 20000 строк в транзакции с ROLLBACK, после CHECKPOINT (медиана 5) — без шума fsync commit. pgbench: по одной строке на транзакцию с COMMIT, 4 клиента, 10 с x 5 повторов.
| вариант | INSERT (таблица+индексы), мс/1000 | FK-проверка, мс/1000 | всего, мс/1000 | WAL на строку, байт | pgbench TPS медиана [min..max] | latency, мс |
|---|---|---|---|---|---|---|
| pk_only | 9.70 | 20.89 | 30.69 | 2792 | 628.2 [419.8..3444.1] | 6.368 |
| chat_id | 10.18 | 22.02 | 33.45 | 2950 | 3483.3 [2960.9..3663.6] | 1.148 |
| created_at_id | 8.60 | 21.01 | 29.57 | 2877 | 790.1 [489.5..3691.3] | 5.062 |
| chat_created_id | 10.71 | 19.87 | 31.03 | 3035 | 3376.1 [2738.2..3602.6] | 1.185 |
| chat_created_id_plus_time | 11.44 | 20.48 | 32.02 | 3120 | 3566.2 [2642.9..3650.8] | 1.122 |
## Backup -> restore
| этап | секунд |
|---|---|
| dump_bench | 1.89 |
| dump_messenger | 0.45 |
| copy | 1.52 |
| restore_bench | 2.11 |
| restore_messenger | 0.40 |
| analyze | 0.67 |
| api_restore_ready | 6.66 |
| **итого (RTO на этом стенде)** | **13.70** |
Размер bench.dump: 14.3 MiB. Несовпадения контрольных сумм: нет.
Запись во время дампа: {"committed_before_dump_start": 3694, "committed_total": 11219, "present_in_backup": 4329, "lost_after_snapshot": 6890}.
API на восстановленной БД: {"old_token_users_me": 200, "message_matches": true}.
| проверка | источник | восстановлено |
|---|---|---|
| users | `1000` | `1000` |
| chats | `4021` | `4021` |
| chat_members | `8600` | `8600` |
| messages | `200000` | `200000` |
| all_messages_md5 | `8b73772737bfac55f58fcb44bb7cf76b` | `8b73772737bfac55f58fcb44bb7cf76b` |
| big_first_page_md5 | `dc073bfb1f81a079c2213518ba3892a3` | `dc073bfb1f81a079c2213518ba3892a3` |
| big_d90_page_md5 | `aad19d2102ee255431bf6eb01e46ed30` | `aad19d2102ee255431bf6eb01e46ed30` |
| small_chat_md5 | `0003ec25c51fc6f6d025c469ab5ca302` | `0003ec25c51fc6f6d025c469ab5ca302` |
+386
View File
@@ -0,0 +1,386 @@
{
"environment": {
"date": "2026-11-06T09:25:09Z",
"docker_cpus": 12,
"docker_memory_gib": 1.9,
"docker_server": "27.2.0",
"postgres": "17.11",
"shared_buffers": "128MB"
},
"seconds": 10,
"clients": 4,
"repeats": 5,
"bulk_rows": 20000,
"variants": {
"pk_only": {
"bulk_insert_ms_per_1000": 9.7,
"bulk_fk_ms_per_1000": 20.89,
"bulk_total_ms_per_1000": 30.69,
"bulk_wal_bytes_per_row": 2792,
"tps_median": 628.2,
"tps_min": 419.8,
"tps_max": 3444.1,
"latency_ms_median": 6.368,
"bulks": [
{
"insert_ms_per_1000": 10.31,
"fk_ms_per_1000": 23.74,
"total_ms_per_1000": 34.15,
"wal_bytes_per_row": 2801
},
{
"insert_ms_per_1000": 9.07,
"fk_ms_per_1000": 21.88,
"total_ms_per_1000": 31.03,
"wal_bytes_per_row": 2794
},
{
"insert_ms_per_1000": 10.53,
"fk_ms_per_1000": 19.61,
"total_ms_per_1000": 30.23,
"wal_bytes_per_row": 2792
},
{
"insert_ms_per_1000": 9.7,
"fk_ms_per_1000": 20.89,
"total_ms_per_1000": 30.69,
"wal_bytes_per_row": 2792
},
{
"insert_ms_per_1000": 8.52,
"fk_ms_per_1000": 20.4,
"total_ms_per_1000": 29.02,
"wal_bytes_per_row": 2792
}
],
"attempts": [
{
"tps": 626.912498,
"latency_ms": 6.38,
"transactions": 6272,
"wal_bytes_per_insert": 7237
},
{
"tps": 628.18138,
"latency_ms": 6.368,
"transactions": 6286,
"wal_bytes_per_insert": 7237
},
{
"tps": 419.785035,
"latency_ms": 9.529,
"transactions": 4201,
"wal_bytes_per_insert": 7728
},
{
"tps": 2755.410642,
"latency_ms": 1.452,
"transactions": 27546,
"wal_bytes_per_insert": 2175
},
{
"tps": 3444.121974,
"latency_ms": 1.161,
"transactions": 34429,
"wal_bytes_per_insert": 1801
}
]
},
"chat_id": {
"bulk_insert_ms_per_1000": 10.18,
"bulk_fk_ms_per_1000": 22.02,
"bulk_total_ms_per_1000": 33.45,
"bulk_wal_bytes_per_row": 2950,
"tps_median": 3483.3,
"tps_min": 2960.9,
"tps_max": 3663.6,
"latency_ms_median": 1.148,
"bulks": [
{
"insert_ms_per_1000": 10.32,
"fk_ms_per_1000": 23.03,
"total_ms_per_1000": 33.45,
"wal_bytes_per_row": 2945
},
{
"insert_ms_per_1000": 11.41,
"fk_ms_per_1000": 22.02,
"total_ms_per_1000": 33.52,
"wal_bytes_per_row": 2957
},
{
"insert_ms_per_1000": 9.36,
"fk_ms_per_1000": 24.61,
"total_ms_per_1000": 34.06,
"wal_bytes_per_row": 2947
},
{
"insert_ms_per_1000": 9.9,
"fk_ms_per_1000": 21.2,
"total_ms_per_1000": 31.19,
"wal_bytes_per_row": 2950
},
{
"insert_ms_per_1000": 10.18,
"fk_ms_per_1000": 19.36,
"total_ms_per_1000": 29.63,
"wal_bytes_per_row": 2954
}
],
"attempts": [
{
"tps": 3483.270409,
"latency_ms": 1.148,
"transactions": 34822,
"wal_bytes_per_insert": 1914
},
{
"tps": 3562.57173,
"latency_ms": 1.123,
"transactions": 35614,
"wal_bytes_per_insert": 1879
},
{
"tps": 2960.857014,
"latency_ms": 1.351,
"transactions": 29602,
"wal_bytes_per_insert": 2186
},
{
"tps": 3355.068589,
"latency_ms": 1.192,
"transactions": 33540,
"wal_bytes_per_insert": 1976
},
{
"tps": 3663.575244,
"latency_ms": 1.092,
"transactions": 36626,
"wal_bytes_per_insert": 1845
}
]
},
"created_at_id": {
"bulk_insert_ms_per_1000": 8.6,
"bulk_fk_ms_per_1000": 21.01,
"bulk_total_ms_per_1000": 29.57,
"bulk_wal_bytes_per_row": 2877,
"tps_median": 790.1,
"tps_min": 489.5,
"tps_max": 3691.3,
"latency_ms_median": 5.062,
"bulks": [
{
"insert_ms_per_1000": 8.6,
"fk_ms_per_1000": 19.84,
"total_ms_per_1000": 28.53,
"wal_bytes_per_row": 2877
},
{
"insert_ms_per_1000": 9.11,
"fk_ms_per_1000": 22.48,
"total_ms_per_1000": 31.68,
"wal_bytes_per_row": 2877
},
{
"insert_ms_per_1000": 8.19,
"fk_ms_per_1000": 21.01,
"total_ms_per_1000": 29.28,
"wal_bytes_per_row": 2877
},
{
"insert_ms_per_1000": 8.73,
"fk_ms_per_1000": 20.75,
"total_ms_per_1000": 29.57,
"wal_bytes_per_row": 2877
},
{
"insert_ms_per_1000": 8.48,
"fk_ms_per_1000": 21.36,
"total_ms_per_1000": 29.93,
"wal_bytes_per_row": 2877
}
],
"attempts": [
{
"tps": 3589.868099,
"latency_ms": 1.114,
"transactions": 35885,
"wal_bytes_per_insert": 1823
},
{
"tps": 3691.258686,
"latency_ms": 1.084,
"transactions": 36901,
"wal_bytes_per_insert": 1783
},
{
"tps": 790.148226,
"latency_ms": 5.062,
"transactions": 7905,
"wal_bytes_per_insert": 6927
},
{
"tps": 517.000669,
"latency_ms": 7.737,
"transactions": 5204,
"wal_bytes_per_insert": 7432
},
{
"tps": 489.540276,
"latency_ms": 8.171,
"transactions": 4896,
"wal_bytes_per_insert": 7550
}
]
},
"chat_created_id": {
"bulk_insert_ms_per_1000": 10.71,
"bulk_fk_ms_per_1000": 19.87,
"bulk_total_ms_per_1000": 31.03,
"bulk_wal_bytes_per_row": 3035,
"tps_median": 3376.1,
"tps_min": 2738.2,
"tps_max": 3602.6,
"latency_ms_median": 1.185,
"bulks": [
{
"insert_ms_per_1000": 10.68,
"fk_ms_per_1000": 19.73,
"total_ms_per_1000": 30.5,
"wal_bytes_per_row": 3061
},
{
"insert_ms_per_1000": 10.71,
"fk_ms_per_1000": 21.26,
"total_ms_per_1000": 32.07,
"wal_bytes_per_row": 3035
},
{
"insert_ms_per_1000": 11.04,
"fk_ms_per_1000": 22.12,
"total_ms_per_1000": 33.26,
"wal_bytes_per_row": 3035
},
{
"insert_ms_per_1000": 11.06,
"fk_ms_per_1000": 19.87,
"total_ms_per_1000": 31.03,
"wal_bytes_per_row": 3035
},
{
"insert_ms_per_1000": 10.3,
"fk_ms_per_1000": 19.29,
"total_ms_per_1000": 29.67,
"wal_bytes_per_row": 3035
}
],
"attempts": [
{
"tps": 3602.626694,
"latency_ms": 1.11,
"transactions": 36014,
"wal_bytes_per_insert": 1946
},
{
"tps": 3376.107093,
"latency_ms": 1.185,
"transactions": 33751,
"wal_bytes_per_insert": 2032
},
{
"tps": 3128.651853,
"latency_ms": 1.279,
"transactions": 31276,
"wal_bytes_per_insert": 2155
},
{
"tps": 3399.102462,
"latency_ms": 1.177,
"transactions": 33982,
"wal_bytes_per_insert": 2019
},
{
"tps": 2738.175055,
"latency_ms": 1.461,
"transactions": 27367,
"wal_bytes_per_insert": 2400
}
]
},
"chat_created_id_plus_time": {
"bulk_insert_ms_per_1000": 11.44,
"bulk_fk_ms_per_1000": 20.48,
"bulk_total_ms_per_1000": 32.02,
"bulk_wal_bytes_per_row": 3120,
"tps_median": 3566.2,
"tps_min": 2642.9,
"tps_max": 3650.8,
"latency_ms_median": 1.122,
"bulks": [
{
"insert_ms_per_1000": 12.02,
"fk_ms_per_1000": 19.57,
"total_ms_per_1000": 31.68,
"wal_bytes_per_row": 3145
},
{
"insert_ms_per_1000": 11.95,
"fk_ms_per_1000": 22.66,
"total_ms_per_1000": 34.71,
"wal_bytes_per_row": 3120
},
{
"insert_ms_per_1000": 11.32,
"fk_ms_per_1000": 22.18,
"total_ms_per_1000": 33.59,
"wal_bytes_per_row": 3120
},
{
"insert_ms_per_1000": 11.44,
"fk_ms_per_1000": 20.48,
"total_ms_per_1000": 32.02,
"wal_bytes_per_row": 3120
},
{
"insert_ms_per_1000": 11.1,
"fk_ms_per_1000": 19.77,
"total_ms_per_1000": 30.95,
"wal_bytes_per_row": 3120
}
],
"attempts": [
{
"tps": 3546.172367,
"latency_ms": 1.128,
"transactions": 35449,
"wal_bytes_per_insert": 2054
},
{
"tps": 3566.208524,
"latency_ms": 1.122,
"transactions": 35652,
"wal_bytes_per_insert": 2032
},
{
"tps": 2642.919736,
"latency_ms": 1.513,
"transactions": 26420,
"wal_bytes_per_insert": 2556
},
{
"tps": 3623.258363,
"latency_ms": 1.104,
"transactions": 36217,
"wal_bytes_per_insert": 2006
},
{
"tps": 3650.774819,
"latency_ms": 1.096,
"transactions": 36496,
"wal_bytes_per_insert": 1996
}
]
}
}
}
+46
View File
@@ -0,0 +1,46 @@
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_by uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id),
user_id uuid NOT NULL REFERENCES users (id),
position smallint NOT NULL CHECK (position >= 1),
PRIMARY KEY (chat_id, user_id),
UNIQUE (chat_id, position)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members (chat_id, user_id)
);
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
CHECK (expires_at > created_at)
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+14
View File
@@ -0,0 +1,14 @@
ALTER TABLE users
DROP CONSTRAINT users_display_name_check,
ALTER COLUMN display_name TYPE bytea USING convert_to(display_name, 'UTF8'),
ADD CONSTRAINT users_display_name_check CHECK (octet_length(display_name) BETWEEN 1 AND 400);
ALTER TABLE chats
DROP CONSTRAINT chats_title_check,
ALTER COLUMN title TYPE bytea USING convert_to(title, 'UTF8'),
ADD CONSTRAINT chats_title_check CHECK (octet_length(title) BETWEEN 1 AND 400);
ALTER TABLE messages
DROP CONSTRAINT messages_text_check,
ALTER COLUMN text TYPE bytea USING convert_to(text, 'UTF8'),
ADD CONSTRAINT messages_text_check CHECK (octet_length(text) BETWEEN 1 AND 16000);
+6
View File
@@ -0,0 +1,6 @@
CREATE TABLE session_revocations (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
expires_at timestamptz NOT NULL
);
CREATE INDEX session_revocations_expires_idx ON session_revocations (expires_at);
+19
View File
@@ -0,0 +1,19 @@
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==25.1.0
argon2-cffi-bindings==26.1.0
cffi==2.1.1
click==8.5.0
fastapi==0.115.6
h11==0.16.0
idna==3.20
psycopg==3.3.6
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.12
pydantic==2.10.4
pydantic_core==2.27.2
redis==8.1.0
starlette==0.41.3
typing_extensions==4.16.0
uvicorn==0.34.0
+62
View File
@@ -0,0 +1,62 @@
SELECT setseed(0.42);
INSERT INTO users (username, display_name, password_hash, created_at)
SELECT 'bench_' || lpad(g::text, 4, '0'), convert_to('Bench ' || g, 'UTF8'), 'synthetic-no-login', timestamptz '2026-08-01 00:00:00Z'
FROM generate_series(0, 999) AS g;
CREATE TABLE bench_users AS
SELECT id, (substr(username, 7))::int AS n FROM users WHERE username LIKE 'bench\_%';
CREATE UNIQUE INDEX ON bench_users (n);
CREATE TABLE bench_chats AS
SELECT gen_random_uuid() AS id, p.kind, p.messages, p.members, row_number() OVER () AS rn
FROM (VALUES ('big', 1, 100000, 200), ('medium', 20, 3000, 20), ('small', 4000, 10, 2))
AS p(kind, chats, messages, members)
CROSS JOIN LATERAL generate_series(1, p.chats);
INSERT INTO chats (id, title, created_by, created_at)
SELECT c.id, convert_to(c.kind || ' ' || c.rn, 'UTF8'), u.id, timestamptz '2026-08-31 00:00:00Z'
FROM bench_chats c JOIN bench_users u ON u.n = (c.rn * 37) % 1000;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT c.id, u.id, k + 1
FROM bench_chats c
CROSS JOIN LATERAL generate_series(0, c.members - 1) AS k
JOIN bench_users u ON u.n = (c.rn * 37 + k) % 1000;
INSERT INTO messages (chat_id, sender_id, text, created_at)
SELECT m.chat_id, u.id, convert_to(left(repeat('Синтетическое сообщение ', 20), m.len), 'UTF8'), m.ts
FROM (
SELECT c.id AS chat_id, c.rn,
(random() * (c.members - 1))::int AS k,
20 + (random() * 380)::int AS len,
timestamptz '2026-09-01 00:00:00Z' + random() * interval '30 days' AS ts
FROM bench_chats c CROSS JOIN LATERAL generate_series(1, c.messages)
) AS m
JOIN bench_users u ON u.n = (m.rn * 37 + m.k) % 1000
ORDER BY m.ts;
CREATE TABLE bench_targets AS
SELECT row_number() OVER () AS n, chat_id, sender_id
FROM (SELECT chat_id, sender_id FROM messages ORDER BY random() LIMIT 10000) AS s;
CREATE UNIQUE INDEX ON bench_targets (n);
CREATE TABLE bench_cursors AS
SELECT c.kind, c.id AS chat_id, d.depth, (c.messages * d.depth)::int AS skip, m.created_at, m.id
FROM (SELECT DISTINCT ON (kind) id, kind, messages FROM bench_chats ORDER BY kind, rn) AS c
CROSS JOIN (VALUES (0.5), (0.9)) AS d(depth)
CROSS JOIN LATERAL (
SELECT created_at, id FROM messages WHERE chat_id = c.id
ORDER BY created_at, id OFFSET (c.messages * d.depth)::int - 1 LIMIT 1
) AS m;
CREATE OR REPLACE FUNCTION bench_explain(query text) RETURNS jsonb LANGUAGE plpgsql AS $$
DECLARE
result json;
BEGIN
EXECUTE 'EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) ' || query INTO result;
RETURN result::jsonb;
END
$$;
VACUUM ANALYZE;
+399
View File
@@ -0,0 +1,399 @@
"""Трек 2: план запроса истории, стоимость записи, backup -> restore -> сверка.
Стенд должен быть запущен (docker compose up -d). Данные — синтетические, в отдельной БД bench.
python research/track2.py prepare # БД bench: 200 000 сообщений в чатах разного размера
python research/track2.py reads # 4 варианта индекса x запросы -> evidence/track2/reads.json
python research/track2.py writes # pgbench INSERT для каждого варианта -> evidence/track2/writes.json
python research/track2.py explain # EXPLAIN (ANALYZE, BUFFERS) рабочего индекса -> evidence/explain-history.txt
python research/track2.py restore # pg_dump -> новый postgres-restore -> сверка -> evidence/track2/restore.json
python research/track2.py report # evidence/track2/results.md из JSON
python research/track2.py all
"""
import base64
from datetime import datetime, timezone
import json
import os
from pathlib import Path
import re
import statistics
import subprocess
import sys
import time
import urllib.error
import urllib.request
import uuid
ROOT = Path(__file__).resolve().parents[1]
OUT = ROOT / 'evidence' / 'track2'
WARMUP, RUNS = 3, 15
PROJECT_VOLUME = 'grigoriev-lab2_pgdata_restore'
RESTORE_PORT = int(os.environ.get('RESTORE_API_PORT', '8081'))
VARIANTS = {
'pk_only': [],
'chat_id': ['CREATE INDEX bench_chat_idx ON messages (chat_id)'],
'created_at_id': ['CREATE INDEX bench_time_idx ON messages (created_at, id)'],
'chat_created_id': ['CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id)'],
}
WRITE_VARIANTS = dict(VARIANTS, chat_created_id_plus_time=VARIANTS['chat_created_id'] + VARIANTS['created_at_id'])
COLUMNS = 'id, chat_id, sender_id, text, created_at'
def run(args, stdin=None, check=True):
result = subprocess.run(args, cwd=ROOT, input=stdin, capture_output=True, text=True, encoding='utf-8')
if check and result.returncode != 0:
raise SystemExit('%s failed:\n%s' % (' '.join(args[:6]), result.stderr.strip()))
return result.stdout.strip()
def compose(*args, **kwargs):
return run(['docker', 'compose', '--profile', 'restore', *args], **kwargs)
def psql(sql, db='bench', service='postgres'):
return compose('exec', '-T', service, 'psql', '-U', 'messenger', '-d', db, '-X', '-q', '-tA',
'-v', 'ON_ERROR_STOP=1', stdin=sql)
def save(name, data):
OUT.mkdir(parents=True, exist_ok=True)
(OUT / name).write_text(json.dumps(data, ensure_ascii=False, indent=2) + '\n', encoding='utf-8')
print('saved evidence/track2/' + name)
def load(name):
return json.loads((OUT / name).read_text(encoding='utf-8'))
def environment():
info = run(['docker', 'info', '--format', '{{.NCPU}} {{.MemTotal}} {{.ServerVersion}}']).split()
return {'date': datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'),
'docker_cpus': int(info[0]), 'docker_memory_gib': round(int(info[1]) / 2 ** 30, 1),
'docker_server': info[2], 'postgres': psql('SHOW server_version', db='messenger'),
'shared_buffers': psql('SHOW shared_buffers', db='messenger')}
def prepare():
psql('DROP DATABASE IF EXISTS bench WITH (FORCE);', db='messenger')
psql('CREATE DATABASE bench;', db='messenger')
for path in sorted((ROOT / 'migrations').glob('*.sql')):
psql(path.read_text(encoding='utf-8'))
started = time.monotonic()
psql((ROOT / 'research' / 'seed.sql').read_text(encoding='utf-8'))
print('seed: %.1f s' % (time.monotonic() - started))
print(psql("SELECT kind, count(*) AS chats, sum(messages) AS messages FROM bench_chats GROUP BY kind ORDER BY 3 DESC"))
print('messages:', psql('SELECT count(*) FROM messages'),
'table size:', psql("SELECT pg_size_pretty(pg_table_size('messages'))"))
def use_variant(statements):
existing = psql("SELECT string_agg(indexname, ',') FROM pg_indexes WHERE tablename = 'messages' "
"AND indexname <> 'messages_pkey'")
if existing:
psql('DROP INDEX %s;' % existing)
started = time.monotonic()
for statement in statements:
psql(statement + ';')
build = time.monotonic() - started
psql('ANALYZE messages;')
size = int(psql("SELECT coalesce(sum(pg_relation_size(indexname::regclass)), 0) FROM pg_indexes "
"WHERE tablename = 'messages' AND indexname <> 'messages_pkey'"))
return build, size
def plan_shape(node):
name = node['Node Type'] + ('(%s)' % node['Index Name'] if 'Index Name' in node else '')
children = node.get('Plans', [])
return name + (' > ' + ' + '.join(plan_shape(c) for c in children) if children else '')
def queries():
cursors = psql("SELECT kind, chat_id, depth, skip, created_at, id FROM bench_cursors ORDER BY kind, depth")
result = {}
for line in cursors.splitlines():
kind, chat_id, depth, skip, created_at, message_id = line.split('|')
label = '%s_d%d' % (kind, round(float(depth) * 100))
base = "SELECT %s FROM messages WHERE chat_id = '%s' " % (COLUMNS, chat_id)
result.setdefault('%s_first' % kind, base + 'ORDER BY created_at, id LIMIT 51')
result['%s_keyset' % label] = base + ("AND (created_at, id) > ('%s', '%s') ORDER BY created_at, id LIMIT 51"
% (created_at, message_id))
result['%s_offset' % label] = base + 'ORDER BY created_at, id OFFSET %s LIMIT 51' % skip
return result
def measure(query):
calls = ''.join("SELECT bench_explain($q$%s$q$);\n" % query for _ in range(WARMUP + RUNS))
plans = [json.loads(line)[0] for line in psql(calls).splitlines()][WARMUP:]
times = sorted(p['Execution Time'] for p in plans)
top = plans[-1]['Plan']
return {'median_ms': round(statistics.median(times), 3),
'p95_ms': round(times[int(len(times) * 0.95) - 1], 3),
'planning_ms': round(statistics.median(p['Planning Time'] for p in plans), 3),
'shared_hit': top.get('Shared Hit Blocks', 0), 'shared_read': top.get('Shared Read Blocks', 0),
'rows': top['Actual Rows'], 'plan': plan_shape(top)}
def reads():
data = {'environment': environment(), 'runs': RUNS, 'warmup': WARMUP, 'variants': {}}
for name, statements in VARIANTS.items():
build, size = use_variant(statements)
results = {}
for label, query in queries().items():
results[label] = measure(query)
print('%-16s %-22s %9.3f ms %s' % (name, label, results[label]['median_ms'], results[label]['plan']))
data['variants'][name] = {'build_seconds': round(build, 2), 'index_bytes': size, 'queries': results}
use_variant(VARIANTS['chat_created_id'])
save('reads.json', data)
PGBENCH_SCRIPT = '''\\set n random(1, 10000)
INSERT INTO messages (chat_id, sender_id, text) SELECT chat_id, sender_id, '%s' FROM bench_targets WHERE n = :n;
'''
def pgbench(text, seconds, clients=4):
compose('exec', '-T', 'postgres', 'sh', '-c', 'cat > /tmp/insert.sql', stdin=PGBENCH_SCRIPT % text)
output = compose('exec', '-T', 'postgres', 'pgbench', '-U', 'messenger', '-n', '-c', str(clients),
'-j', str(clients), '-T', str(seconds), '-f', '/tmp/insert.sql', 'bench')
return {'tps': float(re.search(r'tps = ([\d.]+)', output).group(1)),
'latency_ms': float(re.search(r'latency average = ([\d.]+) ms', output).group(1)),
'transactions': int(re.search(r'actually processed: (\d+)', output).group(1))}
BULK_SQL = ("INSERT INTO messages (chat_id, sender_id, text) SELECT t.chat_id, t.sender_id, 'bulk write' "
"FROM generate_series(1, %d) AS g JOIN bench_targets t ON t.n = 1 + g %% 10000;")
def wal_since(lsn):
return int(psql("SELECT pg_wal_lsn_diff(pg_current_wal_lsn(), '%s')" % lsn))
def bulk(rows):
psql('CHECKPOINT;')
before = psql('SELECT pg_current_wal_lsn()')
plan = json.loads(psql('BEGIN; SELECT bench_explain($q$%s$q$); ROLLBACK;' % (BULK_SQL % rows).rstrip(';')))[0]
wal = wal_since(before)
psql('VACUUM messages;')
per_1000 = 1000 / rows
fk_ms = sum(t['Time'] for t in plan.get('Triggers', []))
return {'insert_ms_per_1000': round(plan['Plan']['Actual Total Time'] * per_1000, 2),
'fk_ms_per_1000': round(fk_ms * per_1000, 2),
'total_ms_per_1000': round(plan['Execution Time'] * per_1000, 2),
'wal_bytes_per_row': round(wal / rows)}
def writes(seconds=10, repeats=5, bulk_rows=20000):
data = {'environment': environment(), 'seconds': seconds, 'clients': 4, 'repeats': repeats,
'bulk_rows': bulk_rows, 'variants': {}}
for name, statements in WRITE_VARIANTS.items():
use_variant(statements)
bulks = [bulk(bulk_rows) for _ in range(5)]
attempts = []
for _ in range(repeats):
psql('CHECKPOINT;')
before = psql('SELECT pg_current_wal_lsn()')
result = pgbench('pgbench write', seconds)
result['wal_bytes_per_insert'] = round(wal_since(before) / result['transactions'])
psql("DELETE FROM messages WHERE text = 'pgbench write'; VACUUM messages;")
attempts.append(result)
tps = [a['tps'] for a in attempts]
data['variants'][name] = {
'bulk_insert_ms_per_1000': statistics.median(b['insert_ms_per_1000'] for b in bulks),
'bulk_fk_ms_per_1000': statistics.median(b['fk_ms_per_1000'] for b in bulks),
'bulk_total_ms_per_1000': statistics.median(b['total_ms_per_1000'] for b in bulks),
'bulk_wal_bytes_per_row': statistics.median(b['wal_bytes_per_row'] for b in bulks),
'tps_median': round(statistics.median(tps), 1), 'tps_min': round(min(tps), 1), 'tps_max': round(max(tps), 1),
'latency_ms_median': statistics.median(a['latency_ms'] for a in attempts),
'bulks': bulks, 'attempts': attempts}
v = data['variants'][name]
print('%-28s insert=%6.2f fk=%6.2f ms/1000 wal/row=%5d B | tps median=%7.1f [%7.1f..%7.1f]'
% (name, v['bulk_insert_ms_per_1000'], v['bulk_fk_ms_per_1000'], v['bulk_wal_bytes_per_row'],
v['tps_median'], v['tps_min'], v['tps_max']))
use_variant(VARIANTS['chat_created_id'])
save('writes.json', data)
def explain():
use_variant(VARIANTS['chat_created_id'])
selected = queries()
lines = ['# EXPLAIN (ANALYZE, BUFFERS): история сообщений, рабочий индекс messages_chat_history_idx',
'# %s' % json.dumps(environment(), ensure_ascii=False),
'# messages: %s; big chat: 100000, medium: 3000, small: 10' % psql('SELECT count(*) FROM messages')]
for label in ('big_first', 'big_d90_keyset', 'big_d90_offset', 'small_first'):
psql('SELECT bench_explain($q$%s$q$);' % selected[label])
plan = psql('EXPLAIN (ANALYZE, BUFFERS) ' + selected[label] + ';')
lines += ['', '## ' + label, selected[label], plan]
(ROOT / 'evidence' / 'explain-history.txt').write_text('\n'.join(lines) + '\n', encoding='utf-8')
print('saved evidence/explain-history.txt')
CHECKSUMS = {
'users': 'SELECT count(*) FROM users',
'chats': 'SELECT count(*) FROM chats',
'chat_members': 'SELECT count(*) FROM chat_members',
'messages': "SELECT count(*) FROM messages WHERE text <> 'during dump'",
'all_messages_md5': "SELECT md5(string_agg(id::text || chat_id::text || sender_id::text || text || created_at::text, '|' "
"ORDER BY id)) FROM messages WHERE text <> 'during dump'",
'big_first_page_md5': "SELECT md5(string_agg(id::text || text, '|' ORDER BY created_at, id)) FROM ("
"SELECT m.* FROM messages m JOIN bench_cursors c ON c.chat_id = m.chat_id AND c.kind = 'big' "
"AND c.depth = 0.5 ORDER BY m.created_at, m.id LIMIT 100) AS p",
'big_d90_page_md5': "SELECT md5(string_agg(id::text || text, '|' ORDER BY created_at, id)) FROM ("
"SELECT m.* FROM messages m JOIN bench_cursors c ON c.chat_id = m.chat_id AND c.kind = 'big' "
"AND c.depth = 0.9 WHERE (m.created_at, m.id) > (c.created_at, c.id) "
"AND m.text <> 'during dump' ORDER BY m.created_at, m.id LIMIT 100) AS p",
'small_chat_md5': "SELECT md5(string_agg(m.id::text || m.text, '|' ORDER BY m.created_at, m.id)) FROM messages m "
"JOIN bench_cursors c ON c.chat_id = m.chat_id AND c.kind = 'small' AND c.depth = 0.5 "
"WHERE m.text <> 'during dump'",
}
def checksums(service):
return {name: psql(query, service=service) for name, query in CHECKSUMS.items()}
def api(method, path, port, token=None, body=None, headers=None):
all_headers = dict(headers or {})
if token:
all_headers['Authorization'] = 'Bearer ' + token
data = json.dumps(body).encode() if body is not None else None
if data:
all_headers['Content-Type'] = 'application/json'
request = urllib.request.Request('http://127.0.0.1:%d%s' % (port, path), data=data, headers=all_headers, method=method)
try:
response = urllib.request.urlopen(request, timeout=5)
except urllib.error.HTTPError as error:
response = error
with response:
raw = response.read()
return response.status, json.loads(raw) if raw else None
def marker_data():
username = 'restore_' + uuid.uuid4().hex[:12]
password = 'Restore-' + uuid.uuid4().hex
api('POST', '/api/v1/users', 8080, body={'username': username, 'display_name': 'Restore', 'password': password})
credential = base64.b64encode(('%s:%s' % (username, password)).encode()).decode()
token = api('POST', '/api/v1/auth/sessions', 8080, headers={'Authorization': 'Basic ' + credential})[1]['token']
me = api('GET', '/api/v1/users/me', 8080, token)[1]
chat = api('POST', '/api/v1/chats', 8080, token, {'title': 'До backup', 'member_ids': [me['id']]})[1]
message = api('POST', '/api/v1/chats/%s/messages' % chat['id'], 8080, token, {'text': 'Переживёт restore'})[1]
return token, chat, message
def timed(action):
started = time.monotonic()
action()
return round(time.monotonic() - started, 2)
def restore():
(ROOT / 'backups').mkdir(exist_ok=True)
compose('rm', '-sf', 'postgres-restore', 'api-restore')
run(['docker', 'volume', 'rm', PROJECT_VOLUME], check=False)
compose('up', '-d', '--wait', '--no-build', 'postgres-restore')
token, chat, message = marker_data()
psql("DELETE FROM messages WHERE text = 'during dump';")
source = checksums('postgres')
compose('exec', '-T', 'postgres', 'sh', '-c', 'cat > /tmp/insert.sql', stdin=PGBENCH_SCRIPT % 'during dump')
writer = subprocess.Popen(['docker', 'compose', 'exec', '-T', 'postgres', 'pgbench', '-U', 'messenger', '-n',
'-c', '2', '-T', '6', '-f', '/tmp/insert.sql', 'bench'],
cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True)
time.sleep(2)
before_dump = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'"))
times = {'dump_bench': timed(lambda: compose('exec', '-T', 'postgres', 'pg_dump', '-U', 'messenger', '-Fc',
'-f', '/tmp/bench.dump', 'bench'))}
writer.wait()
written_total = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'"))
times['dump_messenger'] = timed(lambda: compose('exec', '-T', 'postgres', 'pg_dump', '-U', 'messenger', '-Fc',
'-f', '/tmp/messenger.dump', 'messenger'))
def copy():
for name in ('bench.dump', 'messenger.dump'):
compose('cp', 'postgres:/tmp/' + name, 'backups/' + name)
compose('cp', 'backups/' + name, 'postgres-restore:/tmp/' + name)
times['copy'] = timed(copy)
dump_bytes = (ROOT / 'backups' / 'bench.dump').stat().st_size
psql('CREATE DATABASE bench;', db='messenger', service='postgres-restore')
times['restore_bench'] = timed(lambda: compose('exec', '-T', 'postgres-restore', 'pg_restore', '-U', 'messenger',
'-j', '4', '-d', 'bench', '/tmp/bench.dump'))
times['restore_messenger'] = timed(lambda: compose('exec', '-T', 'postgres-restore', 'pg_restore', '-U', 'messenger',
'-d', 'messenger', '/tmp/messenger.dump'))
times['analyze'] = timed(lambda: psql('ANALYZE;', service='postgres-restore'))
restored = checksums('postgres-restore')
in_restored = int(psql("SELECT count(*) FROM messages WHERE text = 'during dump'", service='postgres-restore'))
times['api_restore_ready'] = timed(lambda: compose('up', '-d', '--wait', '--no-build', 'api-restore'))
status_me = api('GET', '/api/v1/users/me', RESTORE_PORT, token)[0]
page = api('GET', '/api/v1/chats/%s/messages' % chat['id'], RESTORE_PORT, token)[1]
api_ok = status_me == 200 and page['items'] == [message]
mismatches = [k for k in CHECKSUMS if source[k] != restored[k]]
data = {'environment': environment(), 'dump_bytes': dump_bytes, 'times_seconds': times,
'rto_seconds': round(sum(times.values()), 2), 'source': source, 'restored': restored,
'mismatches': mismatches,
'concurrent_writes': {'committed_before_dump_start': before_dump, 'committed_total': written_total,
'present_in_backup': in_restored, 'lost_after_snapshot': written_total - in_restored},
'api_restore': {'old_token_users_me': status_me, 'message_matches': api_ok}}
compose('stop', 'api-restore')
psql("DELETE FROM messages WHERE text = 'during dump';")
save('restore.json', data)
print(json.dumps({k: data[k] for k in ('times_seconds', 'rto_seconds', 'mismatches', 'concurrent_writes', 'api_restore')},
ensure_ascii=False, indent=2))
if mismatches or not api_ok:
raise SystemExit('restore verification FAILED')
def report():
r, w, s = load('reads.json'), load('writes.json'), load('restore.json')
lines = ['# Трек 2: результаты', '', 'Среда: `%s`' % json.dumps(r['environment'], ensure_ascii=False), '',
'## Чтение страницы истории (LIMIT 51), медиана из %d прогонов, мс' % r['runs'], '']
labels = list(next(iter(r['variants'].values()))['queries'])
lines.append('| запрос | ' + ' | '.join(r['variants']) + ' |')
lines.append('|---' * (len(r['variants']) + 1) + '|')
for label in labels:
lines.append('| %s | ' % label + ' | '.join('%.3f' % v['queries'][label]['median_ms']
for v in r['variants'].values()) + ' |')
lines += ['', '## Буферы (shared hit + read) на запрос', '',
'| запрос | ' + ' | '.join(r['variants']) + ' |', '|---' * (len(r['variants']) + 1) + '|']
for label in labels:
lines.append('| %s | ' % label + ' | '.join(str(v['queries'][label]['shared_hit'] + v['queries'][label]['shared_read'])
for v in r['variants'].values()) + ' |')
lines += ['', '## Планы', '']
for name, v in r['variants'].items():
for label in ('big_first', 'big_d90_keyset', 'big_d90_offset', 'small_first'):
lines.append('- %s / %s: `%s`' % (name, label, v['queries'][label]['plan']))
lines += ['', '## Индексы: размер и время построения', '', '| вариант | размер индексов, MiB | построение, с |', '|---|---|---|']
for name, v in r['variants'].items():
lines.append('| %s | %.1f | %.2f |' % (name, v['index_bytes'] / 2 ** 20, v['build_seconds']))
lines += ['', '## Запись', '',
'Пакет: EXPLAIN ANALYZE INSERT %d строк в транзакции с ROLLBACK, после CHECKPOINT (медиана 5) — '
'без шума fsync commit. pgbench: по одной строке на транзакцию с COMMIT, '
'%d клиента, %d с x %d повторов.' % (w['bulk_rows'], w['clients'], w['seconds'], w['repeats']), '',
'| вариант | INSERT (таблица+индексы), мс/1000 | FK-проверка, мс/1000 | всего, мс/1000 | WAL на строку, байт | pgbench TPS медиана [min..max] | latency, мс |',
'|---|---|---|---|---|---|---|']
for name, v in w['variants'].items():
lines.append('| %s | %.2f | %.2f | %.2f | %d | %.1f [%.1f..%.1f] | %.3f |' % (
name, v['bulk_insert_ms_per_1000'], v['bulk_fk_ms_per_1000'], v['bulk_total_ms_per_1000'],
v['bulk_wal_bytes_per_row'], v['tps_median'], v['tps_min'], v['tps_max'], v['latency_ms_median']))
lines += ['', '## Backup -> restore', '', '| этап | секунд |', '|---|---|']
for name, value in s['times_seconds'].items():
lines.append('| %s | %.2f |' % (name, value))
lines += ['| **итого (RTO на этом стенде)** | **%.2f** |' % s['rto_seconds'], '',
'Размер bench.dump: %.1f MiB. Несовпадения контрольных сумм: %s.' % (s['dump_bytes'] / 2 ** 20, s['mismatches'] or 'нет'),
'Запись во время дампа: %s.' % json.dumps(s['concurrent_writes'], ensure_ascii=False),
'API на восстановленной БД: %s.' % json.dumps(s['api_restore'], ensure_ascii=False), '',
'| проверка | источник | восстановлено |', '|---|---|---|']
for name in s['source']:
lines.append('| %s | `%s` | `%s` |' % (name, s['source'][name], s['restored'][name]))
(OUT / 'results.md').write_text('\n'.join(lines) + '\n', encoding='utf-8')
print('saved evidence/track2/results.md')
COMMANDS = {'prepare': prepare, 'reads': reads, 'writes': writes, 'explain': explain, 'restore': restore, 'report': report}
if __name__ == '__main__':
command = sys.argv[1] if len(sys.argv) > 1 else 'all'
for step in (COMMANDS if command == 'all' else [command]):
print('==', step)
COMMANDS[step]()
+28
View File
@@ -0,0 +1,28 @@
import os
from pathlib import Path
import secrets
ROOT = Path(__file__).resolve().parents[1]
SECRETS = ROOT / 'secrets'
def write(name, value):
path = SECRETS / name
if path.exists():
print('keep existing secrets/%s' % name)
return path.read_text(encoding='utf-8').strip()
path.write_text(value + '\n', encoding='utf-8')
os.chmod(path, 0o644)
print('created secrets/%s' % name)
return value
def main():
SECRETS.mkdir(exist_ok=True)
password = write('postgres_password', secrets.token_hex(24))
write('database_url', 'postgresql://messenger:%s@postgres:5432/messenger' % password)
write('database_url_restore', 'postgresql://messenger:%s@postgres-restore:5432/messenger' % password)
if __name__ == '__main__':
main()
+6
View File
@@ -0,0 +1,6 @@
@echo off
cd /d "%~dp0.."
docker compose stop api || exit /b 1
docker compose restart postgres valkey || exit /b 1
docker compose up -d --no-build --no-recreate --wait postgres valkey || exit /b 1
docker compose start api || exit /b 1
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose stop api
docker compose restart postgres valkey
docker compose up -d --no-build --no-recreate --wait postgres valkey
docker compose start api
+162
View File
@@ -0,0 +1,162 @@
from contextlib import asynccontextmanager
import logging
import time
from typing import Annotated, Optional
import uuid
from fastapi import Depends, FastAPI, Header, Query, Request, Response
from fastapi.exceptions import RequestValidationError
import psycopg
from starlette.concurrency import run_in_threadpool
from starlette.exceptions import HTTPException as StarletteHTTPException
import auth
from cache import cache
from config import settings
from db import connection, pool, request_deadline
from errors import ApiError, error_response
from models import CreateChat, CreateMessage, CreateUser
import store
log = logging.getLogger('messenger')
Limit = Annotated[int, Query(ge=1, le=100)]
Cursor = Annotated[Optional[str], Query(min_length=1)]
PUBLIC = {('POST', '/api/v1/users'), ('POST', '/api/v1/auth/sessions')}
state = {'ready': False}
@asynccontextmanager
async def lifespan(app):
pool.open(wait=False)
log.info('session cache: %s', 'valkey' if cache.client else 'disabled')
state['ready'] = True
log.info('application started')
yield
state['ready'] = False
log.info('application stopping')
pool.close(timeout=2)
app = FastAPI(title='MTUSI Messenger lab2', lifespan=lifespan)
@app.middleware('http')
async def request_context(request: Request, call_next):
request.state.request_id = uuid.uuid4().hex
request_deadline.set(time.monotonic() + settings.db_request_timeout)
started = time.perf_counter()
try:
response = await call_next(request)
except Exception:
log.exception('unhandled error request_id=%s', request.state.request_id)
response = error_response(request, 500, 'Внутренняя ошибка сервера')
response.headers['X-Request-Id'] = request.state.request_id
log.info('%s %s -> %d %.1fms request_id=%s', request.method, request.url.path,
response.status_code, (time.perf_counter() - started) * 1000, request.state.request_id)
return response
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
return error_response(request, exc.status, exc.message, exc.headers)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
messages = {404: 'Ресурс не найден', 405: 'Метод не поддерживается'}
return error_response(request, exc.status_code, messages.get(exc.status_code, 'Ошибка запроса'))
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
if request.url.path.startswith('/api/v1/') and (request.method, request.url.path) not in PUBLIC:
try:
await run_in_threadpool(auth.authenticate, request.headers.get('authorization'))
except ApiError as error:
return error_response(request, error.status, error.message, error.headers)
except (psycopg.OperationalError, psycopg.InterfaceError):
return error_response(request, 503, 'Хранилище временно недоступно')
errors = exc.errors()
where = '.'.join(str(part) for part in errors[0]['loc']) if errors else 'request'
return error_response(request, 400, 'Некорректный запрос: ' + where)
@app.exception_handler(psycopg.OperationalError)
@app.exception_handler(psycopg.InterfaceError)
async def handle_database_unavailable(request: Request, exc: psycopg.Error):
log.warning('database unavailable: %s request_id=%s', type(exc).__name__, request.state.request_id)
return error_response(request, 503, 'Хранилище временно недоступно')
@app.get('/health/live')
async def liveness():
return {'status': 'ok'}
@app.get('/health/ready')
def readiness():
if not state['ready']:
raise ApiError(503, 'Сервис не готов')
with connection(limit=1) as conn:
conn.execute('SELECT 1')
return {'status': 'ok'}
def current_session(authorization: Annotated[Optional[str], Header()] = None):
return auth.authenticate(authorization)
def current_user(session: Annotated[dict, Depends(current_session)]):
return session['user']
@app.post('/api/v1/users', status_code=201)
def register_user(body: CreateUser):
return store.create_user(body.username, body.display_name, auth.hash_password(body.password))
@app.post('/api/v1/auth/sessions', status_code=201)
def create_session(request: Request, authorization: Annotated[Optional[str], Header()] = None):
if request.headers.get('content-length', '0') != '0' or 'transfer-encoding' in request.headers:
raise ApiError(400, 'Вход принимает только заголовок Authorization: Basic, без тела')
return auth.login(authorization)
@app.delete('/api/v1/auth/sessions/current', status_code=204)
def delete_session(session: Annotated[dict, Depends(current_session)]):
auth.logout(session)
return Response(status_code=204)
@app.get('/api/v1/users/me')
def get_me(user: Annotated[dict, Depends(current_user)]):
return user
@app.post('/api/v1/chats', status_code=201)
def create_chat(body: CreateChat, user: Annotated[dict, Depends(current_user)]):
return store.create_chat(user['id'], body.title, body.member_ids)
@app.get('/api/v1/chats')
def list_chats(user: Annotated[dict, Depends(current_user)], limit: Limit = 50, cursor: Cursor = None):
return store.list_chats(user['id'], cursor, limit)
@app.get('/api/v1/chats/{chat_id}')
def get_chat(chat_id: uuid.UUID, user: Annotated[dict, Depends(current_user)]):
return store.get_chat(str(chat_id), user['id'])
@app.post('/api/v1/chats/{chat_id}/messages', status_code=201)
def create_message(chat_id: uuid.UUID, body: CreateMessage, user: Annotated[dict, Depends(current_user)]):
return store.create_message(str(chat_id), user['id'], body.text)
@app.get('/api/v1/chats/{chat_id}/messages')
def list_messages(chat_id: uuid.UUID, user: Annotated[dict, Depends(current_user)],
limit: Limit = 50, cursor: Cursor = None):
return store.list_messages(str(chat_id), user['id'], cursor, limit)
+119
View File
@@ -0,0 +1,119 @@
import base64
import binascii
import hashlib
import re
import secrets
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
import psycopg
from cache import REVOKED, cache
from config import settings
from db import iso
from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized
import store
REVOCATION_MARGIN_SECONDS = 5
USERNAME = re.compile(r'^[a-z0-9_]{3,32}$')
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
DUMMY_HASH = hasher.hash('dummy-password-for-equal-timing')
def hash_password(password):
return hasher.hash(password)
def verify_password(password_hash, password):
try:
return hasher.verify(password_hash, password)
except (VerificationError, InvalidHashError):
return False
def token_hash(token):
return hashlib.sha256(token.encode('ascii')).digest()
def parse_credentials(header, scheme):
name, _, value = (header or '').strip().partition(' ')
value = value.strip()
if name.lower() != scheme or not value or ' ' in value:
return None
return value
def parse_basic(header):
value = parse_credentials(header, 'basic')
if value is None:
return None
try:
decoded = base64.b64decode(value, validate=True).decode('utf-8')
except (binascii.Error, UnicodeDecodeError):
return None
username, separator, password = decoded.partition(':')
if not separator or not USERNAME.match(username) or not 12 <= len(password) <= 128:
return None
return username, password
def login(header):
credentials = parse_basic(header)
row = store.find_credentials(credentials[0]) if credentials else None
if row is None:
verify_password(DUMMY_HASH, credentials[1] if credentials else 'x' * 12)
raise unauthorized(BASIC_CHALLENGE, 'Неверное имя пользователя или пароль')
if not verify_password(row['password_hash'], credentials[1]):
raise unauthorized(BASIC_CHALLENGE, 'Неверное имя пользователя или пароль')
token = secrets.token_urlsafe(32)
digest = token_hash(token)
expires_at = store.create_session(row['id'], digest, settings.session_ttl)
user = store.user_out(row)
cache.put(digest, user, expires_at)
return {'token': token, 'token_type': 'Bearer', 'expires_at': iso(expires_at), 'user': user}
def authenticate(header):
token = parse_credentials(header, 'bearer')
if token is None or not token.isascii():
raise unauthorized(BEARER_CHALLENGE)
digest = token_hash(token)
if cache.client is not None and not cache.synced:
sync_revocations()
user = cache.get(digest)
if user == REVOKED:
raise unauthorized(BEARER_CHALLENGE)
if user is None:
row = store.session_user(digest)
if row is None:
raise unauthorized(BEARER_CHALLENGE)
user = store.user_out(row)
cache.put(digest, user, row['expires_at'])
return {'user': user, 'token_hash': digest}
def sync_revocations():
errors_before = cache.errors
try:
pending = store.pending_revocations()
except psycopg.Error:
return
if not cache.revoke_all(pending):
return
if pending:
try:
store.clear_revocations(pending)
except psycopg.Error:
pass
cache.mark_synced(errors_before)
def logout(session):
store.revoke_session(session['token_hash'], cache.max_ttl + REVOCATION_MARGIN_SECONDS)
if cache.revoke(session['token_hash']):
try:
store.clear_revocations([session['token_hash']])
except psycopg.Error:
pass
+84
View File
@@ -0,0 +1,84 @@
from datetime import datetime, timezone
import json
import logging
import threading
import time
import redis
from config import settings
log = logging.getLogger('messenger.cache')
BYPASS_SECONDS = 5
REVOKED = 'revoked'
FAILED = object()
class SessionCache:
def __init__(self, url, max_ttl):
self.client = redis.Redis.from_url(url, socket_timeout=0.2, socket_connect_timeout=0.2,
decode_responses=True) if url else None
self.max_ttl = max_ttl
self.bypass_until = 0.0
self.lock = threading.Lock()
self.errors = 0
self.synced = False
def _run(self, action, force=False):
if self.client is None:
return None
if not force and time.monotonic() < self.bypass_until:
return FAILED
try:
return action(self.client)
except redis.RedisError as error:
log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS)
self.bypass_until = time.monotonic() + BYPASS_SECONDS
with self.lock:
self.errors += 1
self.synced = False
return FAILED
@staticmethod
def key(token_hash):
return 'session:' + token_hash.hex()
def mark_synced(self, errors_before):
with self.lock:
if self.errors == errors_before:
self.synced = True
def get(self, token_hash):
if not self.synced:
return None
raw = self._run(lambda c: c.get(self.key(token_hash)))
if raw is FAILED or not raw or raw == REVOKED:
return REVOKED if raw == REVOKED else None
entry = json.loads(raw)
if entry['expires_at'] <= time.time():
return None
return entry['user']
def put(self, token_hash, user, expires_at: datetime):
remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds())
ttl = min(self.max_ttl, remaining)
if ttl <= 0:
return
value = json.dumps({'user': user, 'expires_at': expires_at.timestamp()}, ensure_ascii=False)
self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl, nx=True))
def revoke(self, token_hash):
return self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), force=True) is not FAILED
def revoke_all(self, token_hashes):
def write(client):
with client.pipeline(transaction=False) as pipe:
for token_hash in token_hashes:
pipe.set(self.key(token_hash), REVOKED, ex=self.max_ttl)
pipe.execute()
return True
return not token_hashes or self._run(write) is not FAILED
cache = SessionCache(settings.cache_url, settings.session_cache_ttl)
+38
View File
@@ -0,0 +1,38 @@
import os
def setting(name, default=None):
path = os.environ.get(name + '_FILE')
if path:
with open(path, encoding='utf-8') as file:
return file.read().strip()
return os.environ.get(name, default)
def positive_int(name, default):
value = int(os.environ.get(name, default))
if value <= 0:
raise SystemExit('%s must be a positive integer' % name)
return value
class Settings:
def __init__(self):
self.host = os.environ.get('APP_HOST', '0.0.0.0')
self.port = positive_int('APP_PORT', '8080')
self.env = os.environ.get('APP_ENV', 'lab')
self.shutdown_timeout = positive_int('APP_SHUTDOWN_TIMEOUT', '5')
self.database_url = setting('DATABASE_URL')
self.cache_url = setting('CACHE_URL') or None
self.session_ttl = positive_int('SESSION_TTL_SECONDS', '3600')
self.session_cache_ttl = positive_int('SESSION_CACHE_TTL_SECONDS', '60')
self.db_pool_min = positive_int('DB_POOL_MIN', '1')
self.db_pool_max = positive_int('DB_POOL_MAX', '10')
self.db_pool_timeout = float(os.environ.get('DB_POOL_TIMEOUT_SECONDS', '2'))
self.db_statement_timeout_ms = positive_int('DB_STATEMENT_TIMEOUT_MS', '3000')
self.db_request_timeout = float(os.environ.get('DB_REQUEST_TIMEOUT_SECONDS', '4'))
if not self.database_url:
raise SystemExit('DATABASE_URL or DATABASE_URL_FILE is required')
settings = Settings()
+122
View File
@@ -0,0 +1,122 @@
from contextlib import contextmanager
import contextvars
from datetime import timezone
import itertools
import logging
import os
import socket
import threading
import time
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from config import settings
log = logging.getLogger('messenger.db')
request_deadline = contextvars.ContextVar('request_deadline', default=None)
CHECK_SECONDS = 1
def abort(conn):
try:
sock = socket.socket(fileno=os.dup(conn.fileno()))
except (OSError, psycopg.Error):
return
try:
sock.shutdown(socket.SHUT_RDWR)
except OSError:
pass
finally:
sock.close()
class Watchdog:
def __init__(self):
self.cond = threading.Condition()
self.armed = {}
self.ids = itertools.count()
threading.Thread(target=self.loop, name='db-watchdog', daemon=True).start()
@contextmanager
def guard(self, conn, seconds):
key = next(self.ids)
with self.cond:
self.armed[key] = (time.monotonic() + seconds, conn)
self.cond.notify()
try:
yield
finally:
with self.cond:
self.armed.pop(key, None)
def loop(self):
with self.cond:
while True:
now = time.monotonic()
for key, (deadline, conn) in list(self.armed.items()):
if deadline <= now:
del self.armed[key]
log.warning('database did not answer in time, aborting connection')
abort(conn)
wake = min((deadline for deadline, _ in self.armed.values()), default=now + 60)
self.cond.wait(max(wake - now, 0.01))
watchdog = Watchdog()
def check(conn):
with watchdog.guard(conn, CHECK_SECONDS):
ConnectionPool.check_connection(conn)
pool = ConnectionPool(
settings.database_url,
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
timeout=settings.db_pool_timeout,
check=check,
open=False,
name='messenger',
kwargs={
'connect_timeout': 3,
'row_factory': dict_row,
'options': '-c timezone=UTC -c statement_timeout=%d' % settings.db_statement_timeout_ms,
},
)
def remaining(limit=None):
deadline = request_deadline.get()
left = settings.db_request_timeout if deadline is None else deadline - time.monotonic()
if limit is not None:
left = min(left, limit)
if left <= 0:
raise psycopg.OperationalError('request deadline exceeded')
return left
@contextmanager
def connection(limit=None):
conn = pool.getconn(timeout=min(settings.db_pool_timeout, remaining(limit)))
try:
with watchdog.guard(conn, remaining(limit)):
try:
yield conn
except BaseException:
try:
conn.rollback()
except psycopg.Error:
pass
raise
conn.commit()
finally:
pool.putconn(conn)
def iso(value):
return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
+37
View File
@@ -0,0 +1,37 @@
from fastapi import Request
from fastapi.responses import JSONResponse
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',
}
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
class ApiError(Exception):
def __init__(self, status, message, headers=None):
super().__init__(message)
self.status = status
self.message = message
self.headers = headers
def unauthorized(challenge, message='Нужна действительная сессия'):
return ApiError(401, message, {'WWW-Authenticate': challenge})
def error_response(request: Request, status, message, headers=None):
request_id = getattr(request.state, 'request_id', '-')
body = {'error': {'code': CODES.get(status, 'invalid_request'), 'message': message, 'request_id': request_id}}
if status == 401 and not headers:
headers = {'WWW-Authenticate': BEARER_CHALLENGE}
return JSONResponse(body, status_code=status, headers=headers)
+22
View File
@@ -0,0 +1,22 @@
import logging
import sys
import uvicorn
from config import settings
def main():
logging.basicConfig(stream=sys.stdout, level=logging.INFO,
format='%(asctime)s %(levelname)s %(name)s: %(message)s')
logging.getLogger('messenger').info('config host=%s port=%d env=%s session_ttl=%ds session_cache_ttl=%ds',
settings.host, settings.port, settings.env,
settings.session_ttl, settings.session_cache_ttl)
from app import app
uvicorn.run(app, host=settings.host, port=settings.port, access_log=False, log_config=None,
timeout_graceful_shutdown=settings.shutdown_timeout)
if __name__ == '__main__':
main()
+47
View File
@@ -0,0 +1,47 @@
import logging
from pathlib import Path
import sys
import time
import psycopg
from config import settings
MIGRATIONS = Path(__file__).resolve().parent.parent / 'migrations'
LOCK_ID = 20260002
log = logging.getLogger('migrate')
def connect(attempts=30):
for attempt in range(1, attempts + 1):
try:
return psycopg.connect(settings.database_url, autocommit=True, connect_timeout=3)
except psycopg.OperationalError:
if attempt == attempts:
raise
log.info('database is not ready, retry %d/%d', attempt, attempts)
time.sleep(1)
def main():
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(asctime)s %(name)s: %(message)s')
with connect() as conn:
conn.execute('SELECT pg_advisory_lock(%s)', (LOCK_ID,))
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations ('
'version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())')
applied = {row[0] for row in conn.execute('SELECT version FROM schema_migrations')}
for path in sorted(MIGRATIONS.glob('*.sql')):
if path.stem in applied:
log.info('skip %s: already applied', path.stem)
continue
with conn.transaction():
conn.execute(path.read_text(encoding='utf-8'))
conn.execute('INSERT INTO schema_migrations (version) VALUES (%s)', (path.stem,))
log.info('applied %s', path.stem)
conn.execute('SELECT pg_advisory_unlock(%s)', (LOCK_ID,))
log.info('schema is up to date')
if __name__ == '__main__':
main()
+45
View File
@@ -0,0 +1,45 @@
from pydantic import BaseModel, ConfigDict, Field, field_validator
class StrictModel(BaseModel):
model_config = ConfigDict(extra='forbid', strict=True)
def not_blank(value):
if not value.strip():
raise ValueError('must not be blank')
try:
value.encode('utf-8')
except UnicodeEncodeError:
raise ValueError('must be valid Unicode') from None
return value
class CreateUser(StrictModel):
username: str = Field(pattern=r'^[a-z0-9_]{3,32}$')
display_name: str = Field(min_length=1, max_length=100)
password: str = Field(min_length=12, max_length=128)
@field_validator('display_name', 'password')
@classmethod
def not_blank_fields(cls, value):
return not_blank(value)
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[str] = Field(min_length=1, max_length=100)
@field_validator('title')
@classmethod
def title_not_blank(cls, value):
return not_blank(value)
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
@field_validator('text')
@classmethod
def text_not_blank(cls, value):
return not_blank(value)
+31
View File
@@ -0,0 +1,31 @@
import base64
from datetime import datetime
import json
import uuid
from errors import ApiError
def encode_cursor(scope, item):
raw = json.dumps({'s': scope, 't': item['created_at'], 'i': item['id']}, separators=(',', ':'))
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip('=')
def decode_cursor(scope, cursor):
try:
padded = cursor + '=' * (-len(cursor) % 4)
data = json.loads(base64.urlsafe_b64decode(padded.encode('ascii')))
if data['s'] != scope or not isinstance(data['t'], str) or not isinstance(data['i'], str):
raise ValueError
created_at = datetime.fromisoformat(data['t'])
if created_at.tzinfo is None:
raise ValueError
return created_at, uuid.UUID(data['i'])
except (ValueError, TypeError, KeyError, AttributeError):
raise ApiError(400, 'Некорректный cursor') from None
def page(items, scope, limit):
chunk = items[:limit]
has_more = len(items) > limit
return {'items': chunk, 'next_cursor': encode_cursor(scope, chunk[-1]) if has_more else None}
+166
View File
@@ -0,0 +1,166 @@
import uuid
from psycopg import errors
from db import connection, iso
from errors import ApiError
from pagination import decode_cursor, page
USER_COLUMNS = 'u.id, u.username, u.display_name, u.created_at'
MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, created_at'
CHAT_SELECT = ('SELECT c.id, c.title, c.created_at, '
'ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.position) AS member_ids '
'FROM chats c ')
def utf8(value):
return value.encode('utf-8')
def unicode(value):
return bytes(value).decode('utf-8')
def user_out(row):
return {'id': str(row['id']), 'username': row['username'],
'display_name': unicode(row['display_name']), 'created_at': iso(row['created_at'])}
def chat_out(row):
return {'id': str(row['id']), 'title': unicode(row['title']),
'member_ids': [str(m) for m in row['member_ids']], 'created_at': iso(row['created_at'])}
def message_out(row):
return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']),
'text': unicode(row['text']), 'created_at': iso(row['created_at'])}
def create_user(username, display_name, password_hash):
try:
with connection() as conn:
row = conn.execute(
'INSERT INTO users AS u (username, display_name, password_hash) VALUES (%s, %s, %s) '
'RETURNING ' + USER_COLUMNS,
(username, utf8(display_name), password_hash)).fetchone()
except errors.UniqueViolation:
raise ApiError(409, 'Имя пользователя уже занято') from None
return user_out(row)
def find_credentials(username):
with connection() as conn:
return conn.execute('SELECT ' + USER_COLUMNS + ', u.password_hash FROM users u WHERE u.username = %s',
(username,)).fetchone()
def create_session(user_id, token_hash, ttl_seconds):
with connection() as conn:
conn.execute('DELETE FROM sessions WHERE user_id = %s AND expires_at <= now()', (user_id,))
return conn.execute(
'INSERT INTO sessions (token_hash, user_id, expires_at) '
'VALUES (%s, %s, now() + make_interval(secs => %s)) RETURNING expires_at',
(token_hash, user_id, ttl_seconds)).fetchone()['expires_at']
def session_user(token_hash):
with connection() as conn:
return conn.execute(
'SELECT ' + USER_COLUMNS + ', s.expires_at FROM sessions s JOIN users u ON u.id = s.user_id '
'WHERE s.token_hash = %s AND s.expires_at > now()',
(token_hash,)).fetchone()
def revoke_session(token_hash, keep_seconds):
with connection() as conn:
conn.execute('DELETE FROM sessions WHERE token_hash = %s', (token_hash,))
conn.execute('INSERT INTO session_revocations (token_hash, expires_at) '
'VALUES (%s, now() + make_interval(secs => %s)) '
'ON CONFLICT (token_hash) DO UPDATE SET expires_at = EXCLUDED.expires_at',
(token_hash, keep_seconds))
def pending_revocations():
with connection() as conn:
conn.execute('DELETE FROM session_revocations WHERE expires_at <= now()')
return [bytes(r['token_hash']) for r in conn.execute('SELECT token_hash FROM session_revocations').fetchall()]
def clear_revocations(token_hashes):
with connection() as conn:
conn.execute('DELETE FROM session_revocations WHERE token_hash = ANY(%s)', (list(token_hashes),))
def create_chat(creator_id, title, member_ids):
try:
members = [str(uuid.UUID(m)) for m in member_ids]
except ValueError:
raise ApiError(400, 'Неизвестный участник чата') from None
if len(set(members)) != len(members):
raise ApiError(400, 'Участники не должны повторяться')
if creator_id not in members:
raise ApiError(400, 'Создатель должен быть участником чата')
try:
with connection() as conn, conn.transaction():
chat = conn.execute('INSERT INTO chats (title, created_by) VALUES (%s, %s) RETURNING id, title, created_at',
(utf8(title), creator_id)).fetchone()
conn.execute('INSERT INTO chat_members (chat_id, user_id, position) '
'SELECT %s, member, position FROM unnest(%s::uuid[]) WITH ORDINALITY AS t(member, position)',
(chat['id'], members))
except errors.ForeignKeyViolation:
raise ApiError(400, 'Неизвестный участник чата') from None
return chat_out({**chat, 'member_ids': members})
def get_chat(chat_id, user_id):
with connection() as conn:
row = conn.execute(CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s '
'WHERE c.id = %s', (user_id, chat_id)).fetchone()
if row is None:
raise ApiError(404, 'Чат не найден')
return chat_out(row)
def list_chats(user_id, cursor, limit):
scope = 'user:' + user_id
sql = CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s '
params = [user_id]
if cursor:
sql += 'AND (c.created_at, c.id) > (%s, %s) '
params += decode_cursor(scope, cursor)
sql += 'ORDER BY c.created_at, c.id LIMIT %s'
with connection() as conn:
rows = conn.execute(sql, params + [limit + 1]).fetchall()
return page([chat_out(r) for r in rows], scope, limit)
def is_member(conn, chat_id, user_id):
return conn.execute('SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s',
(chat_id, user_id)).fetchone() is not None
def create_message(chat_id, sender_id, text):
with connection() as conn:
row = conn.execute(
'INSERT INTO messages (chat_id, sender_id, text) SELECT %s, %s, %s '
'WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s) '
'RETURNING ' + MESSAGE_COLUMNS,
(chat_id, sender_id, utf8(text), chat_id, sender_id)).fetchone()
if row is None:
raise ApiError(404, 'Чат не найден')
return message_out(row)
def list_messages(chat_id, user_id, cursor, limit):
scope = 'chat:' + chat_id
sql = 'SELECT ' + MESSAGE_COLUMNS + ' FROM messages WHERE chat_id = %s '
params = [chat_id]
if cursor:
sql += 'AND (created_at, id) > (%s, %s) '
params += decode_cursor(scope, cursor)
sql += 'ORDER BY created_at, id LIMIT %s'
with connection() as conn:
if not is_member(conn, chat_id, user_id):
raise ApiError(404, 'Чат не найден')
rows = conn.execute(sql, params + [limit + 1]).fetchall()
return page([message_out(r) for r in rows], scope, limit)
+56
View File
@@ -0,0 +1,56 @@
"""Usage (стенд уже запущен через docker compose up -d):
python student-tests/expiry_check.py --ttl 2
Скрипт пересоздаёт только api с SESSION_TTL_SECONDS=<ttl>, проверяет истечение сессии,
затем возвращает api с обычным TTL из .env. Volumes и данные не трогаются.
"""
import argparse
import hashlib
import os
import time
from helpers import call, compose, new_user, wait_ready
def restart_api(ttl=None):
env = dict(os.environ)
if ttl is None:
env.pop('SESSION_TTL_SECONDS', None)
else:
env['SESSION_TTL_SECONDS'] = str(ttl)
compose('up', '-d', '--no-deps', '--no-build', 'api', env=env)
wait_ready()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--ttl', type=int, default=2)
args = parser.parse_args()
print('пересоздаю api с SESSION_TTL_SECONDS=%d' % args.ttl)
restart_api(args.ttl)
try:
alice = new_user('expiry')
status = call('GET', '/api/v1/users/me', token=alice['token'])[0]
print('сразу после входа: /users/me -> %d' % status)
assert status == 200
key = 'session:' + hashlib.sha256(alice['token'].encode()).hexdigest()
cache_ttl = int(compose('exec', '-T', 'valkey', 'valkey-cli', 'TTL', key))
print('TTL ключа этой сессии в Valkey: %d с (-2 = ключа нет)' % cache_ttl)
assert cache_ttl <= args.ttl, 'кэш живёт дольше сессии'
time.sleep(args.ttl + 1.5)
status, headers, _ = call('GET', '/api/v1/users/me', token=alice['token'])
print('через %.1f с: /users/me -> %d, WWW-Authenticate: %s' % (args.ttl + 1.5, status, headers['WWW-Authenticate']))
assert status == 401 and headers['WWW-Authenticate'] == 'Bearer realm="messenger"'
status = call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])[0]
print('logout истёкшим токеном -> %d' % status)
assert status == 401
print('PASS: сессия истекла по SESSION_TTL_SECONDS=%d, кэш не продлил её' % args.ttl)
finally:
print('возвращаю api с TTL из .env')
restart_api()
if __name__ == '__main__':
main()
+127
View File
@@ -0,0 +1,127 @@
"""Usage (стенд уже запущен через docker compose up -d):
python student-tests/failure_check.py
Останавливает и замораживает Valkey и PostgreSQL (docker compose stop/pause, без удаления volumes),
проверяет поведение API и восстановление.
"""
import time
import uuid
from helpers import basic, call, compose, new_chat, new_user, wait_ready
failures = []
def timed(method, path, token=None, body=None, headers=None):
started = time.monotonic()
try:
status = call(method, path, body=body, token=token, headers=headers, timeout=10)[0]
except OSError as error:
status = type(error).__name__
return status, time.monotonic() - started
def expect(title, result, allowed, max_seconds):
status, seconds = result
ok = status in allowed and seconds <= max_seconds
print(' %-48s -> %-4s за %.2f с %s' % (title, status, seconds, 'OK' if ok else 'FAIL'))
if not ok:
failures.append(title)
def main():
alice = new_user('failure')
chat = new_chat(alice)
history = '/api/v1/chats/%s/messages' % chat['id']
assert call('POST', history, {'text': 'до отказа'}, alice['token'])[0] == 201
fake = uuid.uuid4().hex * 2
print('1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL')
compose('stop', 'valkey')
try:
expect('первый запрос: обнаружение отказа кэша', timed('GET', '/api/v1/users/me', alice['token']), [200], 1.5)
expect('GET /users/me действующим токеном', timed('GET', '/api/v1/users/me', alice['token']), [200], 1)
expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'без кэша'}), [201], 1)
expect('неизвестный токен', timed('GET', '/api/v1/users/me', fake), [401], 1)
expect('без Authorization', timed('GET', '/api/v1/users/me'), [401], 1)
expect('/health/ready (Valkey некритичен)', timed('GET', '/health/ready'), [200], 1)
started = time.monotonic()
other = new_user('nocache')
expect('регистрация и вход без кэша', (200, time.monotonic() - started), [200], 1)
expect('logout без кэша', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1.5)
expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1)
finally:
compose('up', '-d', '--wait', 'valkey')
print('1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша')
revoked = new_user('paused')
call('GET', '/api/v1/users/me', token=revoked['token'])
compose('pause', 'valkey')
try:
expect('logout при паузе Valkey', timed('DELETE', '/api/v1/auth/sessions/current', revoked['token']), [204], 1.5)
finally:
compose('unpause', 'valkey')
time.sleep(6)
expect('через 6 с после unpause: /users/me', timed('GET', '/api/v1/users/me', revoked['token']), [401], 1)
expect('через 6 с после unpause: сообщение', timed('POST', history, revoked['token'], {'text': 'после logout'}), [401], 1)
print('1в. Valkey на паузе: logout, рестарт API, unpause — отзыв переживает рестарт процесса')
restarted = new_user('restart')
call('GET', '/api/v1/users/me', token=restarted['token'])
compose('pause', 'valkey')
try:
expect('logout при паузе Valkey', timed('DELETE', '/api/v1/auth/sessions/current', restarted['token']), [204], 1.5)
compose('restart', 'api')
wait_ready()
finally:
compose('unpause', 'valkey')
time.sleep(6)
expect('после рестарта API и unpause: /users/me', timed('GET', '/api/v1/users/me', restarted['token']), [401], 1)
expect('после рестарта API и unpause: сообщение', timed('POST', history, restarted['token'], {'text': 'после рестарта'}), [401], 1)
print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит')
compose('stop', 'postgres')
stopped_at = time.monotonic()
try:
expect('GET история', timed('GET', history, alice['token']), [503], 3)
expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'при отказе БД'}), [503], 3)
expect('неизвестный токен (не 200!)', timed('GET', '/api/v1/users/me', fake), [503], 3)
expect('без Authorization', timed('GET', '/api/v1/users/me'), [401], 1)
expect('вход по Basic верным паролем', timed('POST', '/api/v1/auth/sessions',
headers=basic(alice['username'], alice['password'])), [503], 3)
expect('/health/live', timed('GET', '/health/live'), [200], 1)
expect('/health/ready', timed('GET', '/health/ready'), [503], 3)
finally:
compose('up', '-d', '--wait', 'postgres')
ready_at = wait_ready()
print('3. PostgreSQL запущен: готовность через %.1f с после остановки' % (ready_at - stopped_at))
status = call('GET', '/api/v1/users/me', token=alice['token'])[0]
texts = [m['text'] for m in call('GET', history + '?limit=100', token=alice['token'])[2]['items']]
print(' прежний токен -> %d; история: %s' % (status, texts))
if status != 200 or texts != ['до отказа', 'без кэша']:
failures.append('восстановление')
print('4. PostgreSQL заморожен (pause): запросы получают 503 в пределах общего срока, а не зависают')
compose('pause', 'postgres')
try:
expect('GET история', timed('GET', history, alice['token']), [503], 4.5)
expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'при заморозке'}), [503], 4.5)
expect('неизвестный токен (не 200!)', timed('GET', '/api/v1/users/me', fake), [503], 4.5)
expect('вход по Basic', timed('POST', '/api/v1/auth/sessions', headers=basic(alice['username'], alice['password'])), [503], 4.5)
expect('/health/ready', timed('GET', '/health/ready'), [503], 2)
expect('/health/live', timed('GET', '/health/live'), [200], 1)
finally:
compose('unpause', 'postgres')
unpaused = time.monotonic()
wait_ready()
texts = [m['text'] for m in call('GET', history + '?limit=100', token=alice['token'])[2]['items']]
print(' готовность через %.1f с после unpause; история: %s' % (time.monotonic() - unpaused, texts))
if texts != ['до отказа', 'без кэша']:
failures.append('после заморозки')
print('FAIL: ' + ', '.join(failures) if failures else 'PASS: отказы Valkey и PostgreSQL обработаны')
raise SystemExit(1 if failures else 0)
if __name__ == '__main__':
main()
+101
View File
@@ -0,0 +1,101 @@
import base64
import json
import os
from pathlib import Path
import subprocess
import time
import urllib.error
import urllib.parse
import urllib.request
import uuid
BASE_URL = os.environ.get('BASE_URL', 'http://127.0.0.1:8080').rstrip('/')
ROOT = Path(__file__).resolve().parents[1]
def call(method, path, body=None, token=None, raw=None, headers=None, timeout=10):
all_headers = {}
if token:
all_headers['Authorization'] = 'Bearer ' + token
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode('utf-8')
if raw is not None:
all_headers['Content-Type'] = 'application/json'
all_headers.update(headers or {})
request = urllib.request.Request(BASE_URL + path, data=raw, headers=all_headers, method=method)
try:
response = urllib.request.urlopen(request, timeout=timeout)
except urllib.error.HTTPError as error:
response = error
with response:
data = response.read()
return response.status, response.headers, json.loads(data) if data else None
def basic(username, password):
return {'Authorization': 'Basic ' + base64.b64encode((username + ':' + password).encode('utf-8')).decode()}
def register(label='user', password=None):
username = (label + '_' + uuid.uuid4().hex[:12])[:32]
password = password or 'Pw-' + uuid.uuid4().hex
status, _, user = call('POST', '/api/v1/users', {'username': username, 'display_name': label, 'password': password})
assert status == 201, status
return user, password
def login(username, password):
status, _, session = call('POST', '/api/v1/auth/sessions', headers=basic(username, password))
assert status == 201, status
return session
def new_user(label='user'):
user, password = register(label)
session = login(user['username'], password)
return dict(user, password=password, token=session['token'])
def new_chat(owner, *others, title='Тестовый чат'):
members = [owner['id']] + [u['id'] for u in others]
status, _, chat = call('POST', '/api/v1/chats', {'title': title, 'member_ids': members}, owner['token'])
assert status == 201, status
return chat
def read_all_messages(chat_id, token, limit):
items, cursor, pages = [], None, 0
while True:
query = '?limit=%d' % limit + ('&cursor=' + urllib.parse.quote(cursor, safe='') if cursor else '')
status, _, page = call('GET', '/api/v1/chats/%s/messages%s' % (chat_id, query), token=token)
assert status == 200, status
items += page['items']
pages += 1
cursor = page['next_cursor']
if cursor is None:
return items, pages
def compose(*args, env=None, check=True):
result = subprocess.run(['docker', 'compose', *args], cwd=ROOT, capture_output=True, text=True,
encoding='utf-8', env=env)
if check and result.returncode != 0:
raise RuntimeError('docker compose %s failed: %s' % (' '.join(args), result.stderr.strip()))
return result.stdout.strip()
def sql(query, db='messenger', service='postgres'):
return compose('exec', '-T', service, 'psql', '-U', 'messenger', '-d', db, '-X', '-tA', '-v', 'ON_ERROR_STOP=1',
'-c', query)
def wait_ready(seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call('GET', '/health/ready', timeout=2)[0] == 200:
return time.monotonic()
except OSError:
pass
time.sleep(0.3)
raise AssertionError('API is not ready after %ds' % seconds)
+75
View File
@@ -0,0 +1,75 @@
"""Usage (стенд запущен через docker compose up -d):
python student-tests/sigterm_check.py
docker compose start api
"""
import argparse
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
from helpers import BASE_URL, call, new_chat, new_user
def docker(*args):
return subprocess.run(['docker', *args], capture_output=True, text=True, encoding='utf-8').stdout.strip()
def probe_forever(results, stop_event):
while not stop_event.is_set():
started = time.monotonic()
try:
with urllib.request.urlopen(BASE_URL + '/health/live', timeout=1) as response:
outcome = str(response.status)
except urllib.error.HTTPError as error:
outcome = str(error.code)
except Exception as error:
outcome = type(error).__name__
results.append((started, outcome))
time.sleep(0.02)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--container', default='grigoriev-lab2-api-1')
parser.add_argument('--stop-timeout', type=int, default=10, help='секунд до SIGKILL у docker stop')
args = parser.parse_args()
marker = 'PRIVATE-' + uuid.uuid4().hex
alice = new_user('alice')
chat = new_chat(alice)
status = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': marker}, alice['token'])[0]
logs_before = docker('logs', args.container)
print('сообщение с маркером отправлено: HTTP %d; маркер в логах: %s' % (status, marker in logs_before))
results, stop_event = [], threading.Event()
prober = threading.Thread(target=probe_forever, args=(results, stop_event))
prober.start()
time.sleep(1)
sigterm_at = time.monotonic()
docker('stop', '-t', str(args.stop_timeout), args.container)
stopped_at = time.monotonic()
time.sleep(1)
stop_event.set()
prober.join()
before = [r for t, r in results if t < sigterm_at]
after = [r for t, r in results if t >= sigterm_at]
exit_code = docker('inspect', '--format', '{{.State.ExitCode}}', args.container)
print('docker stop занял: %.2f с (лимит %d с)' % (stopped_at - sigterm_at, args.stop_timeout))
print('код выхода контейнера: %s (0 — сам завершился по SIGTERM; 137 — убит SIGKILL)' % exit_code)
print('запросы до SIGTERM: %d, все 200: %s' % (len(before), set(before) == {'200'}))
print('запросы после SIGTERM: %d, результаты: %s' % (len(after), sorted(set(after))))
print('ответов 5xx за всё время: %d' % sum(r.startswith('5') for _, r in results))
print('\nлоги остановки:')
for line in docker('logs', args.container).splitlines():
if any(word in line for word in ('Shutting down', 'stopping', 'shutdown', 'Finished server')):
print(' ' + line)
if __name__ == '__main__':
main()
+157
View File
@@ -0,0 +1,157 @@
import unittest
import uuid
from helpers import call, login, new_chat, new_user, read_all_messages
class ErrorFormatMixin:
def assertError(self, result, status, code):
actual, headers, body = result
self.assertEqual(actual, status)
self.assertEqual(body['error']['code'], code)
self.assertEqual(body['error']['request_id'], headers['X-Request-Id'])
self.assertNotIn('Traceback', body['error']['message'])
class InvalidJsonTest(ErrorFormatMixin, unittest.TestCase):
def test_malformed_json(self):
"""Битый JSON -> 400 invalid_request"""
self.assertError(call('POST', '/api/v1/users', raw=b'{"username": "abc",'), 400, 'invalid_request')
def test_json_not_object(self):
"""JSON-массив вместо объекта -> 400"""
self.assertError(call('POST', '/api/v1/users', raw=b'[1, 2, 3]'), 400, 'invalid_request')
def test_wrong_type(self):
"""Число вместо строки -> 400 (без тихого приведения типов)"""
self.assertError(call('POST', '/api/v1/users', {'username': 12345, 'display_name': 'x', 'password': 'Long-enough-pass-1'}), 400, 'invalid_request')
def test_extra_field(self):
"""Лишнее поле в теле -> 400"""
body = {'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': 'x', 'password': 'Long-enough-pass-1', 'is_admin': True}
self.assertError(call('POST', '/api/v1/users', body), 400, 'invalid_request')
class DuplicateUsernameTest(ErrorFormatMixin, unittest.TestCase):
def test_duplicate_username(self):
"""Повторная регистрация того же username -> 409 conflict"""
user = new_user('dup')
again = call('POST', '/api/v1/users', {'username': user['username'], 'display_name': 'Другой',
'password': 'Other-password-123'})
self.assertError(again, 409, 'conflict')
class ForeignChatTest(ErrorFormatMixin, unittest.TestCase):
def setUp(self):
self.alice, self.bob, self.eve = new_user('alice'), new_user('bob'), new_user('eve')
self.chat = new_chat(self.alice, self.bob)
self.path = '/api/v1/chats/' + self.chat['id']
def test_outsider_cannot_read_chat(self):
"""Посторонний читает чат -> 404, как будто чата нет"""
self.assertError(call('GET', self.path, token=self.eve['token']), 404, 'not_found')
missing = call('GET', '/api/v1/chats/' + str(uuid.uuid4()), token=self.eve['token'])
self.assertEqual(missing[2]['error']['message'], call('GET', self.path, token=self.eve['token'])[2]['error']['message'])
def test_outsider_cannot_write_or_read_history(self):
"""Посторонний пишет/читает историю -> 404"""
self.assertError(call('POST', self.path + '/messages', {'text': 'чужое'}, self.eve['token']), 404, 'not_found')
self.assertError(call('GET', self.path + '/messages', token=self.eve['token']), 404, 'not_found')
def test_outsider_does_not_see_chat_in_list(self):
"""Чужой чат не попадает в список чатов"""
status, _, page = call('GET', '/api/v1/chats?limit=100', token=self.eve['token'])
self.assertEqual(status, 200)
self.assertNotIn(self.chat['id'], [c['id'] for c in page['items']])
def test_member_has_access(self):
"""Участник видит чат (контроль: 404 выше не из-за ошибки в тесте)"""
self.assertEqual(call('GET', self.path, token=self.bob['token'])[0], 200)
class EmptyMessageTest(ErrorFormatMixin, unittest.TestCase):
def setUp(self):
self.alice = new_user('alice')
self.path = '/api/v1/chats/%s/messages' % new_chat(self.alice)['id']
def test_empty_text(self):
"""Пустой текст -> 400"""
self.assertError(call('POST', self.path, {'text': ''}, self.alice['token']), 400, 'invalid_request')
def test_whitespace_text(self):
"""Текст только из пробельных символов -> 400"""
self.assertError(call('POST', self.path, {'text': ' \t\n '}, self.alice['token']), 400, 'invalid_request')
def test_missing_text(self):
"""Тело без поля text -> 400"""
self.assertError(call('POST', self.path, {}, self.alice['token']), 400, 'invalid_request')
def test_text_length_limit(self):
"""4000 символов можно (эмодзи = 1 символ), 4001 — 400"""
self.assertEqual(call('POST', self.path, {'text': '😀' * 4000}, self.alice['token'])[0], 201)
self.assertError(call('POST', self.path, {'text': 'x' * 4001}, self.alice['token']), 400, 'invalid_request')
class PaginationTest(ErrorFormatMixin, unittest.TestCase):
def setUp(self):
self.alice = new_user('alice')
self.chat = new_chat(self.alice)
self.sent = [call('POST', '/api/v1/chats/%s/messages' % self.chat['id'],
{'text': 'сообщение %d' % i}, self.alice['token'])[2] for i in range(7)]
def test_walk_several_pages(self):
"""7 сообщений по 3: три страницы, без потерь, повторов и перестановок"""
items, pages = read_all_messages(self.chat['id'], self.alice['token'], limit=3)
self.assertEqual(pages, 3)
self.assertEqual([m['id'] for m in items], [m['id'] for m in self.sent])
keys = [(m['created_at'], m['id']) for m in items]
self.assertEqual(keys, sorted(keys))
def test_cursor_from_other_chat(self):
"""cursor от другого чата -> 400"""
_, _, page = call('GET', '/api/v1/chats/%s/messages?limit=1' % self.chat['id'], token=self.alice['token'])
other = new_chat(self.alice, title='Другой')
self.assertError(call('GET', '/api/v1/chats/%s/messages?cursor=%s' % (other['id'], page['next_cursor']),
token=self.alice['token']), 400, 'invalid_request')
def test_invalid_cursor_and_limit(self):
"""Мусорный cursor и limit вне 1..100 -> 400"""
path = '/api/v1/chats/%s/messages' % self.chat['id']
for query in ('?cursor=not-a-cursor', '?limit=0', '?limit=101', '?limit=abc'):
with self.subTest(query=query):
self.assertError(call('GET', path + query, token=self.alice['token']), 400, 'invalid_request')
class IdentityTest(ErrorFormatMixin, unittest.TestCase):
def test_sender_cannot_be_forged(self):
"""sender_id в теле запрещён: отправитель только из сессии"""
alice, bob = new_user('alice'), new_user('bob')
chat = new_chat(alice, bob)
forged = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': 'hi', 'sender_id': bob['id']}, alice['token'])
self.assertError(forged, 400, 'invalid_request')
def test_nul_character_is_preserved(self):
"""U+0000 — допустимый code point: сообщение, display_name и title сохраняются и читаются без изменений"""
username, password = 'nul_' + uuid.uuid4().hex[:12], 'Nul-password-123'
status, _, user = call('POST', '/api/v1/users', {'username': username, 'display_name': 'a\u0000lice', 'password': password})
self.assertEqual((status, user['display_name']), (201, 'a\u0000lice'))
alice = dict(user, token=login(username, password)['token'])
self.assertEqual(call('GET', '/api/v1/users/me', token=alice['token'])[2]['display_name'], 'a\u0000lice')
status, _, chat = call('POST', '/api/v1/chats', {'title': 't\u0000', 'member_ids': [alice['id']]}, alice['token'])
self.assertEqual((status, chat['title']), (201, 't\u0000'))
path = '/api/v1/chats/%s/messages' % chat['id']
status, _, message = call('POST', path, {'text': 'a\u0000b'}, alice['token'])
self.assertEqual((status, message['text']), (201, 'a\u0000b'))
self.assertEqual(call('GET', path, token=alice['token'])[2]['items'][0]['text'], 'a\u0000b')
self.assertEqual(call('GET', '/api/v1/chats/' + chat['id'], token=alice['token'])[2]['title'], 't\u0000')
def test_lone_surrogate_is_rejected(self):
"""Одиночный суррогат не кодируется в UTF-8 -> 400, а не 500"""
alice = new_user('alice')
chat = new_chat(alice)
self.assertError(call('POST', '/api/v1/chats/%s/messages' % chat['id'], raw=b'{"text": "a\\ud800b"}',
token=alice['token']), 400, 'invalid_request')
if __name__ == '__main__':
unittest.main()
+132
View File
@@ -0,0 +1,132 @@
from datetime import datetime, timezone
import unittest
import uuid
from helpers import basic, call, login, new_user, register
class RegistrationTest(unittest.TestCase):
def body(self, password):
return {'username': 'reg_' + uuid.uuid4().hex[:12], 'display_name': 'Регистрация', 'password': password}
def test_password_is_not_returned(self):
"""Ответ регистрации и /users/me не содержат password/hash"""
status, _, user = call('POST', '/api/v1/users', self.body('Secret-password-1'))
self.assertEqual(status, 201)
self.assertEqual(set(user), {'id', 'username', 'display_name', 'created_at'})
def test_password_length_limits(self):
"""Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом"""
self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 11))[0], 400)
self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 129))[0], 400)
self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 128))[0], 201)
self.assertEqual(call('POST', '/api/v1/users', self.body('🔑' * 12))[0], 201)
def test_password_required_and_not_blank(self):
"""Без password или из одних пробелов -> 400"""
body = self.body('x')
del body['password']
self.assertEqual(call('POST', '/api/v1/users', body)[0], 400)
self.assertEqual(call('POST', '/api/v1/users', self.body(' ' * 20))[0], 400)
class LoginTest(unittest.TestCase):
def setUp(self):
self.user, self.password = register('login')
def assertBasicChallenge(self, result):
status, headers, body = result
self.assertEqual(status, 401)
self.assertEqual(headers['WWW-Authenticate'], 'Basic realm="messenger", charset="UTF-8"')
self.assertEqual(body['error']['code'], 'unauthorized')
return body['error']['message']
def test_login_returns_opaque_session(self):
"""Вход: 201, token_type=Bearer, токен случайный и не содержит username/UUID"""
first = login(self.user['username'], self.password)
second = login(self.user['username'], self.password)
self.assertEqual(first['token_type'], 'Bearer')
self.assertEqual(first['user'], self.user)
self.assertGreaterEqual(len(first['token']), 43)
self.assertNotEqual(first['token'], second['token'])
self.assertNotIn(self.user['username'], first['token'])
self.assertNotIn(self.user['id'], first['token'])
expires = datetime.fromisoformat(first['expires_at'].replace('Z', '+00:00'))
self.assertGreater(expires, datetime.now(timezone.utc))
def test_wrong_password_and_unknown_user_look_the_same(self):
"""Неверный пароль и несуществующий пользователь -> одинаковый 401 с Basic challenge"""
wrong = self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions',
headers=basic(self.user['username'], 'Wrong-password-1')))
unknown = self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions',
headers=basic('nobody_' + uuid.uuid4().hex[:8], 'Wrong-password-1')))
self.assertEqual(wrong, unknown)
def test_malformed_basic(self):
"""Нет заголовка, не base64, нет двоеточия, Bearer вместо Basic -> 401 Basic"""
for header in (None, 'Basic', 'Basic !!!not-base64!!!', 'Basic ' + 'bm9jb2xvbg==', 'Bearer abc'):
with self.subTest(header=header):
headers = {'Authorization': header} if header else {}
self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions', headers=headers))
def test_password_with_colon_and_unicode(self):
"""Двоеточие и не-ASCII в пароле допустимы: делим только по первому ':'"""
user, password = register('colon', password='пароль:с:двоеточием🔑')
self.assertEqual(login(user['username'], password)['user']['id'], user['id'])
def test_login_rejects_body(self):
"""POST /auth/sessions принимает только заголовок, JSON body -> 400"""
status = call('POST', '/api/v1/auth/sessions', {'username': self.user['username']},
headers=basic(self.user['username'], self.password))[0]
self.assertEqual(status, 400)
class BearerTest(unittest.TestCase):
def setUp(self):
self.alice = new_user('alice')
self.eve = new_user('eve')
def assertBearerChallenge(self, headers):
status, response_headers, _ = call('GET', '/api/v1/users/me', headers=headers)
self.assertEqual(status, 401)
self.assertEqual(response_headers['WWW-Authenticate'], 'Bearer realm="messenger"')
def test_only_bearer_is_accepted(self):
"""Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer"""
self.assertBearerChallenge({})
self.assertBearerChallenge(basic(self.alice['username'], self.alice['password']))
self.assertBearerChallenge({'X-User-Id': self.alice['id']})
self.assertBearerChallenge({'Authorization': 'Bearer ' + uuid.uuid4().hex})
self.assertBearerChallenge({'Authorization': 'Bearer'})
def test_authentication_before_validation(self):
"""Аноним с битым JSON на защищённом endpoint получает 401, а не 400; с сессией — 400"""
self.assertEqual(call('POST', '/api/v1/chats', raw=b'{bad')[0], 401)
self.assertEqual(call('POST', '/api/v1/chats', raw=b'{bad', token=self.alice['token'])[0], 400)
self.assertEqual(call('POST', '/api/v1/users', raw=b'{bad')[0], 400)
def test_scheme_is_case_insensitive(self):
"""Схема аутентификации нечувствительна к регистру (RFC 9110)"""
status, _, me = call('GET', '/api/v1/users/me', headers={'Authorization': 'bearer ' + self.alice['token']})
self.assertEqual((status, me['id']), (200, self.alice['id']))
def test_x_user_id_does_not_override_session(self):
"""X-User-Id игнорируется: владелец определяется только токеном"""
status, _, me = call('GET', '/api/v1/users/me', token=self.alice['token'], headers={'X-User-Id': self.eve['id']})
self.assertEqual((status, me['id']), (200, self.alice['id']))
class LogoutTest(unittest.TestCase):
def test_logout_revokes_only_current_session(self):
"""Logout -> 204 без тела; этот токен -> 401, вторая сессия того же пользователя работает"""
alice = new_user('alice')
other = login(alice['username'], alice['password'])['token']
status, _, body = call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])
self.assertEqual((status, body), (204, None))
self.assertEqual(call('GET', '/api/v1/users/me', token=alice['token'])[0], 401)
self.assertEqual(call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])[0], 401)
self.assertEqual(call('GET', '/api/v1/users/me', token=other)[0], 200)
if __name__ == '__main__':
unittest.main()
+68
View File
@@ -0,0 +1,68 @@
from concurrent.futures import ThreadPoolExecutor
import threading
import unittest
import uuid
from helpers import basic, call, new_chat, new_user, read_all_messages
CLIENTS = 10
REGISTRATIONS = 20
PER_CLIENT = 10
class ConcurrencyTest(unittest.TestCase):
def test_100_messages_from_10_clients(self):
"""100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории"""
users = [new_user('client%d' % i) for i in range(CLIENTS)]
chat = new_chat(users[0], *users[1:], title='Нагрузка')
path = '/api/v1/chats/%s/messages' % chat['id']
barrier = threading.Barrier(CLIENTS)
def client(index):
barrier.wait()
results = []
for n in range(PER_CLIENT):
status, _, message = call('POST', path, {'text': 'client %d msg %d' % (index, n)}, users[index]['token'])
results.append((status, message))
return results
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
responses = [r for batch in pool.map(client, range(CLIENTS)) for r in batch]
self.assertEqual([s for s, _ in responses], [201] * CLIENTS * PER_CLIENT)
sent_ids = {m['id'] for _, m in responses}
items, pages = read_all_messages(chat['id'], users[0]['token'], limit=30)
read_ids = [m['id'] for m in items]
keys = [(m['created_at'], m['id']) for m in items]
self.assertEqual(len(sent_ids), 100, 'сервер выдал повторяющиеся id')
self.assertEqual(len(read_ids), 100, 'в истории не ровно 100 сообщений')
self.assertEqual(set(read_ids), sent_ids, 'история не совпадает с подтверждёнными сообщениями')
self.assertEqual(len({m['text'] for m in items}), 100, 'потерялся или задвоился текст')
self.assertEqual(keys, sorted(keys), 'история не упорядочена по (created_at, id)')
print('\n отправлено 201: %d, уникальных id: %d, прочитано: %d за %d страниц(ы)'
% (len(responses), len(sent_ids), len(read_ids), pages))
def test_parallel_registration_of_same_username(self):
"""20 одновременных регистраций одного username -> ровно один 201, остальные 409; вход только с паролем победителя"""
username = 'race_' + uuid.uuid4().hex[:12]
barrier = threading.Barrier(REGISTRATIONS)
def register(index):
password = 'Race-password-%02d' % index
barrier.wait()
status = call('POST', '/api/v1/users', {'username': username, 'display_name': 'Гонка', 'password': password})[0]
return status, password
with ThreadPoolExecutor(max_workers=REGISTRATIONS) as pool:
results = list(pool.map(register, range(REGISTRATIONS)))
statuses = sorted(status for status, _ in results)
self.assertEqual(statuses, [201] + [409] * (REGISTRATIONS - 1))
winner = [password for status, password in results if status == 201][0]
loser = [password for status, password in results if status == 409][0]
self.assertEqual(call('POST', '/api/v1/auth/sessions', headers=basic(username, winner))[0], 201)
self.assertEqual(call('POST', '/api/v1/auth/sessions', headers=basic(username, loser))[0], 401)
if __name__ == '__main__':
unittest.main()
+58
View File
@@ -0,0 +1,58 @@
import hashlib
import time
import unittest
import uuid
from helpers import call, compose, new_chat, new_user, sql
class DatabaseTest(unittest.TestCase):
def test_chat_creation_is_rolled_back(self):
"""Неизвестный участник: INSERT chats выполнен, INSERT chat_members упал по FK, всё откатано"""
alice = new_user('alice')
chats_before = int(sql('SELECT count(*) FROM chats'))
members_before = int(sql('SELECT count(*) FROM chat_members'))
ghost = str(uuid.uuid4())
since = sql("SELECT to_char(now() - interval '1 second', 'YYYY-MM-DD\"T\"HH24:MI:SS\"Z\"')")
status, _, body = call('POST', '/api/v1/chats', {'title': 'Откат', 'member_ids': [alice['id'], ghost]},
alice['token'])
self.assertEqual(status, 400, body)
time.sleep(0.5)
log = compose('logs', '--no-log-prefix', '--since', since, 'postgres')
self.assertIn('violates foreign key constraint', log)
self.assertIn(ghost, log)
self.assertEqual(int(sql('SELECT count(*) FROM chats')), chats_before)
self.assertEqual(int(sql('SELECT count(*) FROM chat_members')), members_before)
def test_secrets_are_not_stored_in_plaintext(self):
"""В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен"""
alice = new_user('alice')
password_hash = sql("SELECT password_hash FROM users WHERE id = '%s'" % alice['id'])
self.assertTrue(password_hash.startswith('$argon2id$'), password_hash[:10])
self.assertNotIn(alice['password'], password_hash)
digest = hashlib.sha256(alice['token'].encode()).hexdigest()
self.assertEqual(sql("SELECT count(*) FROM sessions WHERE token_hash = '\\x%s'" % digest), '1')
dump = sql("SELECT string_agg(encode(token_hash, 'escape'), '') FROM sessions WHERE user_id = '%s'" % alice['id'])
self.assertNotIn(alice['token'], dump)
def test_migrations_are_idempotent(self):
"""Повторный запуск миграций ничего не меняет и завершается успешно"""
before = sql('SELECT version, applied_at FROM schema_migrations ORDER BY version')
users = sql('SELECT count(*) FROM users')
output = compose('run', '--rm', '--no-deps', 'migrate')
self.assertIn('skip 0001_init: already applied', output)
self.assertEqual(sql('SELECT version, applied_at FROM schema_migrations ORDER BY version'), before)
self.assertEqual(sql('SELECT count(*) FROM users'), users)
def test_history_query_uses_index(self):
"""Запрос страницы истории идёт по индексу (chat_id, created_at, id), без Sort"""
alice = new_user('alice')
chat = new_chat(alice)
plan = sql("SET enable_seqscan = off; SET enable_bitmapscan = off; EXPLAIN SELECT id FROM messages WHERE chat_id = '%s' "
"ORDER BY created_at, id LIMIT 51" % chat['id'])
self.assertIn('messages_chat_history_idx', plan)
self.assertNotIn('Sort', plan)
if __name__ == '__main__':
unittest.main()