diff --git a/.dockerignore b/.dockerignore index bc16e556..93f3500f 100644 --- a/.dockerignore +++ b/.dockerignore @@ -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 diff --git a/.env.example b/.env.example index 714c8076..d58527bd 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..2338c371 --- /dev/null +++ b/.github/workflows/app.yml @@ -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 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..5ac5014f --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 9ecb223e..a8372e57 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +.PHONY: help check validate test load test-persistence 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) diff --git a/REPORT.md b/REPORT.md index e42f2b05..cad6df79 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 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:`, значение `{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`. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..1c3af232 --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/README.md b/evidence/README.md index 8df70015..a2f6b802 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -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 | diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..11692792 --- /dev/null +++ b/evidence/expiry.txt @@ -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 diff --git a/evidence/explain-history.txt b/evidence/explain-history.txt new file mode 100644 index 00000000..368d3c93 --- /dev/null +++ b/evidence/explain-history.txt @@ -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 diff --git a/evidence/failure.txt b/evidence/failure.txt new file mode 100644 index 00000000..83b143fc --- /dev/null +++ b/evidence/failure.txt @@ -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 обработаны diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..fa405cb8 --- /dev/null +++ b/evidence/load.json @@ -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." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..a48fd3e8 --- /dev/null +++ b/evidence/persistence.txt @@ -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 diff --git a/evidence/sigterm.txt b/evidence/sigterm.txt new file mode 100644 index 00000000..301ab5ee --- /dev/null +++ b/evidence/sigterm.txt @@ -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] diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..fb6644cd --- /dev/null +++ b/evidence/smoke.txt @@ -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. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..9ebf224f --- /dev/null +++ b/evidence/student-tests.txt @@ -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 страниц(ы) diff --git a/evidence/track2/planner_random_page_cost_1_1.json b/evidence/track2/planner_random_page_cost_1_1.json new file mode 100644 index 00000000..a73c5602 --- /dev/null +++ b/evidence/track2/planner_random_page_cost_1_1.json @@ -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)" + } +} diff --git a/evidence/track2/planner_random_page_cost_4.json b/evidence/track2/planner_random_page_cost_4.json new file mode 100644 index 00000000..1ba65f4b --- /dev/null +++ b/evidence/track2/planner_random_page_cost_4.json @@ -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)" + } +} diff --git a/evidence/track2/reads.json b/evidence/track2/reads.json new file mode 100644 index 00000000..40b0668b --- /dev/null +++ b/evidence/track2/reads.json @@ -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)" + } + } + } + } +} diff --git a/evidence/track2/restore.json b/evidence/track2/restore.json new file mode 100644 index 00000000..8d59aca2 --- /dev/null +++ b/evidence/track2/restore.json @@ -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 + } +} diff --git a/evidence/track2/results.md b/evidence/track2/results.md new file mode 100644 index 00000000..3ebc36c1 --- /dev/null +++ b/evidence/track2/results.md @@ -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` | diff --git a/evidence/track2/writes.json b/evidence/track2/writes.json new file mode 100644 index 00000000..c4dbbadb --- /dev/null +++ b/evidence/track2/writes.json @@ -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 + } + ] + } + } +} diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..44c4ed38 --- /dev/null +++ b/migrations/0001_init.sql @@ -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); diff --git a/migrations/0002_unicode_text.sql b/migrations/0002_unicode_text.sql new file mode 100644 index 00000000..bf25a000 --- /dev/null +++ b/migrations/0002_unicode_text.sql @@ -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); diff --git a/migrations/0003_session_revocations.sql b/migrations/0003_session_revocations.sql new file mode 100644 index 00000000..c2bcb84c --- /dev/null +++ b/migrations/0003_session_revocations.sql @@ -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); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..0313e9df --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/research/seed.sql b/research/seed.sql new file mode 100644 index 00000000..dd42b229 --- /dev/null +++ b/research/seed.sql @@ -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; diff --git a/research/track2.py b/research/track2.py new file mode 100644 index 00000000..52a76f5f --- /dev/null +++ b/research/track2.py @@ -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]() diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 00000000..6c0ce8ee --- /dev/null +++ b/scripts/init_secrets.py @@ -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() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..713107fb --- /dev/null +++ b/scripts/restart.cmd @@ -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 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..e269cef9 --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/src/app.py b/src/app.py new file mode 100644 index 00000000..5cad9ca4 --- /dev/null +++ b/src/app.py @@ -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) diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..9aafd2f6 --- /dev/null +++ b/src/auth.py @@ -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 diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..c44eb033 --- /dev/null +++ b/src/cache.py @@ -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) diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..470040ee --- /dev/null +++ b/src/config.py @@ -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() diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..6eb1af01 --- /dev/null +++ b/src/db.py @@ -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') diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..5cbdbba5 --- /dev/null +++ b/src/errors.py @@ -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) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..f3f09365 --- /dev/null +++ b/src/main.py @@ -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() diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..7ac81bac --- /dev/null +++ b/src/migrate.py @@ -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() diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..a1dab270 --- /dev/null +++ b/src/models.py @@ -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) diff --git a/src/pagination.py b/src/pagination.py new file mode 100644 index 00000000..81b08760 --- /dev/null +++ b/src/pagination.py @@ -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} diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..cbf33720 --- /dev/null +++ b/src/store.py @@ -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) diff --git a/student-tests/expiry_check.py b/student-tests/expiry_check.py new file mode 100644 index 00000000..7bde51ec --- /dev/null +++ b/student-tests/expiry_check.py @@ -0,0 +1,56 @@ +"""Usage (стенд уже запущен через docker compose up -d): + python student-tests/expiry_check.py --ttl 2 + +Скрипт пересоздаёт только api с SESSION_TTL_SECONDS=, проверяет истечение сессии, +затем возвращает 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() diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py new file mode 100644 index 00000000..a6ffa7ce --- /dev/null +++ b/student-tests/failure_check.py @@ -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() diff --git a/student-tests/helpers.py b/student-tests/helpers.py new file mode 100644 index 00000000..7654e210 --- /dev/null +++ b/student-tests/helpers.py @@ -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) diff --git a/student-tests/sigterm_check.py b/student-tests/sigterm_check.py new file mode 100644 index 00000000..86f2ee5c --- /dev/null +++ b/student-tests/sigterm_check.py @@ -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() diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..be589b60 --- /dev/null +++ b/student-tests/test_api.py @@ -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() diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..3a56ee20 --- /dev/null +++ b/student-tests/test_auth.py @@ -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() diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..4d258446 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -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() diff --git a/student-tests/test_db.py b/student-tests/test_db.py new file mode 100644 index 00000000..5997fd83 --- /dev/null +++ b/student-tests/test_db.py @@ -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()