ЛР 2 — БПИ2302 — Григорьев — на 5 #136
@@ -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
@@ -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
|
||||
|
||||
@@ -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
@@ -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,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)
|
||||
|
||||
|
||||
@@ -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
@@ -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
|
||||
@@ -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 |
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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 обработаны
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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
|
||||
@@ -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]
|
||||
@@ -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.
|
||||
@@ -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)"
|
||||
}
|
||||
}
|
||||
@@ -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)"
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
}
|
||||
@@ -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` |
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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;
|
||||
@@ -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]()
|
||||
@@ -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()
|
||||
@@ -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
|
||||
Executable
+7
@@ -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
@@ -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
@@ -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
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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')
|
||||
@@ -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
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user