From 6bec450e20e38372cb964e59bcd5fabd8948d01e Mon Sep 17 00:00:00 2001 From: alenchha Date: Mon, 19 Oct 2026 19:11:28 +0300 Subject: [PATCH 1/4] =?UTF-8?q?=D0=9B=D0=A0=202:=20PostgreSQL,=20=D1=81?= =?UTF-8?q?=D0=B5=D1=81=D1=81=D0=B8=D0=B8=20=D0=B2=20Valkey,=20=D1=82?= =?UTF-8?q?=D1=80=D0=B5=D0=BA=202?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 18 ++ .github/workflows/app.yml | 39 +++ Dockerfile | 31 +++ Makefile | 54 +++- REPORT.md | 178 ++++++++++++- app/__init__.py | 0 app/config.py | 43 +++ app/cursor.py | 43 +++ app/db.py | 99 +++++++ app/errors.py | 37 +++ app/main.py | 391 ++++++++++++++++++++++++++++ app/passwords.py | 16 ++ app/repo.py | 132 ++++++++++ app/sessions.py | 139 ++++++++++ compose.yaml | 101 +++++++ evidence/dependency.txt | 29 +++ evidence/expiry.txt | 5 + evidence/explain-10k.txt | 88 +++++++ evidence/git-hygiene.txt | 32 +++ evidence/level4-tests.txt | 24 ++ evidence/load-cache.json | 17 ++ evidence/load-nocache.json | 17 ++ evidence/load.txt | 34 +++ evidence/migrations.txt | 35 +++ evidence/outages.txt | 5 + evidence/persistence.txt | 18 ++ evidence/smoke.txt | 2 + evidence/stand.txt | 8 + evidence/track2/run.txt | 227 ++++++++++++++++ migrations/0001_init.sql | 46 ++++ requirements.txt | 22 ++ scripts/bootstrap.sh | 15 ++ scripts/migrate.py | 60 +++++ scripts/restart.sh | 5 + student-tests/common.py | 111 ++++++++ student-tests/dependency.sh | 39 +++ student-tests/evidence.sh | 126 +++++++++ student-tests/expiry.sh | 35 +++ student-tests/explain.sh | 15 ++ student-tests/explain.sql | 51 ++++ student-tests/seed.sql | 37 +++ student-tests/test_auth_sessions.py | 114 ++++++++ student-tests/test_expiry.py | 44 ++++ student-tests/test_outages.py | 93 +++++++ student-tests/test_storage_rules.py | 242 +++++++++++++++++ student-tests/test_without_cache.py | 32 +++ student-tests/test_without_db.py | 41 +++ student-tests/track2.sh | 113 ++++++++ student-tests/track2_indexes.sql | 104 ++++++++ student-tests/track2_verify.sql | 17 ++ 50 files changed, 3210 insertions(+), 14 deletions(-) create mode 100644 .github/workflows/app.yml create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/config.py create mode 100644 app/cursor.py create mode 100644 app/db.py create mode 100644 app/errors.py create mode 100644 app/main.py create mode 100644 app/passwords.py create mode 100644 app/repo.py create mode 100644 app/sessions.py create mode 100644 compose.yaml create mode 100644 evidence/dependency.txt create mode 100644 evidence/expiry.txt create mode 100644 evidence/explain-10k.txt create mode 100644 evidence/git-hygiene.txt create mode 100644 evidence/level4-tests.txt create mode 100644 evidence/load-cache.json create mode 100644 evidence/load-nocache.json create mode 100644 evidence/load.txt create mode 100644 evidence/migrations.txt create mode 100644 evidence/outages.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/stand.txt create mode 100644 evidence/track2/run.txt create mode 100644 migrations/0001_init.sql create mode 100644 requirements.txt create mode 100755 scripts/bootstrap.sh create mode 100644 scripts/migrate.py create mode 100755 scripts/restart.sh create mode 100644 student-tests/common.py create mode 100755 student-tests/dependency.sh create mode 100755 student-tests/evidence.sh create mode 100755 student-tests/expiry.sh create mode 100755 student-tests/explain.sh create mode 100644 student-tests/explain.sql create mode 100644 student-tests/seed.sql create mode 100644 student-tests/test_auth_sessions.py create mode 100644 student-tests/test_expiry.py create mode 100644 student-tests/test_outages.py create mode 100644 student-tests/test_storage_rules.py create mode 100644 student-tests/test_without_cache.py create mode 100644 student-tests/test_without_db.py create mode 100755 student-tests/track2.sh create mode 100644 student-tests/track2_indexes.sql create mode 100644 student-tests/track2_verify.sql diff --git a/.env.example b/.env.example index 714c8076..001b3362 100644 --- a/.env.example +++ b/.env.example @@ -9,3 +9,21 @@ 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 +# --- Реализация lab2: сервер и деградация (перенесено из lab1) --- +GRACEFUL_TIMEOUT=8 +MAX_INFLIGHT_REQUESTS=64 +MAX_BODY_BYTES=65536 +MAX_RSS_MB=0 +# --- Реализация lab2: PostgreSQL --- +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_POOL_TIMEOUT=3 +DB_CONNECT_TIMEOUT=3 +DB_STATEMENT_TIMEOUT_MS=5000 +DB_OP_TIMEOUT=6 +REQUEST_TIMEOUT=8 +DB_READY_TIMEOUT=1.5 +# --- Реализация lab2: кэш сессий в Valkey --- +SESSION_CACHE_TTL_SECONDS=30 +SESSION_SWEEP_SECONDS=60 +CACHE_TIMEOUT=0.2 diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..5f235986 --- /dev/null +++ b/.github/workflows/app.yml @@ -0,0 +1,39 @@ +name: Application +on: [push, pull_request] +permissions: + contents: read +jobs: + app: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - name: Bootstrap local env and secrets + run: make bootstrap + - name: Start stack + run: docker compose --env-file .env up -d --build + - name: Wait for readiness + run: | + for i in $(seq 1 60); do + if curl -fsS http://localhost:8080/health/ready; then exit 0; fi + sleep 2 + done + docker compose --env-file .env ps + docker compose --env-file .env logs --tail=200 + exit 1 + - name: Migrations are idempotent + run: docker compose --env-file .env run --rm migrate + - name: Public smoke + run: make test PYTHON=python + - name: Own checks + run: make test-custom PYTHON=python + - name: Persistence with restart hook + run: make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python + - name: Logs on failure + if: failure() + run: docker compose --env-file .env logs --tail=200 + - name: Tear down + if: always() + run: docker compose --env-file .env down -v diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..9ec3243c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,31 @@ +FROM python:3.12.8-slim-bookworm@sha256:2199a62885a12290dc9c5be3ca0681d367576ab7bf037da120e564723292a2f0 + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 \ + PIP_DEFAULT_TIMEOUT=120 \ + PIP_RETRIES=10 + +RUN groupadd --system --gid 10001 app \ + && useradd --system --uid 10001 --gid app --home-dir /app --shell /usr/sbin/nologin app + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-deps -r requirements.txt + +COPY app/ app/ +COPY migrations/ migrations/ +COPY scripts/migrate.py scripts/migrate.py + +USER 10001:10001 + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \ + CMD ["python", "-c", "import urllib.request,sys; sys.exit(0 if urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).status == 200 else 1)"] + +STOPSIGNAL SIGTERM + +CMD ["sh", "-c", "exec uvicorn app.main:app --host \"${APP_HOST:-0.0.0.0}\" --port \"${APP_PORT:-8080}\" --timeout-graceful-shutdown \"${GRACEFUL_TIMEOUT:-8}\""] diff --git a/Makefile b/Makefile index 9ecb223e..2608b111 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,16 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence +COMPOSE ?= docker compose --env-file .env + +.PHONY: help check validate test load test-persistence bootstrap build up down logs ps migrate psql test-custom expiry dependency outages explain track2 evidence help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "bootstrap: local .env and secrets; build/up/down: compose stack; migrate: apply SQL migrations" + @echo "test-custom: own level-4 checks; expiry: short-TTL instance; dependency: cache and database outages" + @echo "outages: revocation vs cache restart, hung database; evidence: full run into evidence/" + @echo "explain: history query plan on 10k rows; track2: grade-5 experiment; test-persistence: restart hook" check: $(PYTHON) scripts/check_contract.py @@ -24,3 +30,49 @@ load: test-persistence: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +bootstrap: + sh scripts/bootstrap.sh + +build: + $(COMPOSE) build + +up: + $(COMPOSE) up -d --build + +down: + $(COMPOSE) down + +logs: + $(COMPOSE) logs --tail=100 api + +ps: + $(COMPOSE) ps + +migrate: + $(COMPOSE) run --rm migrate + +psql: + $(COMPOSE) exec postgres psql -U messenger -d messenger + +test-custom: + $(PYTHON) student-tests/test_auth_sessions.py --base-url "$(BASE_URL)" + $(PYTHON) student-tests/test_storage_rules.py --base-url "$(BASE_URL)" + +expiry: + sh student-tests/expiry.sh + +dependency: + sh student-tests/dependency.sh + +outages: + $(PYTHON) student-tests/test_outages.py --base-url "$(BASE_URL)" + +explain: + sh student-tests/explain.sh + +track2: + TOTAL=$(or $(TOTAL),120000) sh student-tests/track2.sh + +evidence: + sh student-tests/evidence.sh diff --git a/REPORT.md b/REPORT.md index e42f2b05..1687ca91 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,189 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Курлова Алёна Алексеевна, БВТ2301 +- Целевая оценка; выбранный трек 5: 5, трек 2 «План запроса и восстановление» - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, psycopg 3.3.6 (+psycopg-pool), valkey-py 6.2.0, argon2-cffi 25.1.0 — документация перечисленных библиотек; документация PostgreSQL 17 (transactions, EXPLAIN, pg_dump/pg_restore, типы данных), Valkey persistence, RFC 7617, RFC 9106. Реализация, свои тесты и стенд эксперимента написаны с помощью ИИ-ассистента (Claude Code); все прогоны и доказательства выполнены автором. Отдельно просмотрены публичные ревью преподавателя к PR других студентов этой же лабораторной и проверено, закрыты ли названные там случаи в этой работе: сохранение NUL в тексте, отзыв сессии против возврата кэша, зависшая БД, тело запроса на входе, Unicode-пробелы. Четыре из них требовали правок, остальные уже работали; на каждый добавлен свой тест. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker (проверено 29.7.2) с плагином Compose (v5.5.1), `make`, Python 3.9+ на хосте (только для публичных и своих тестов) и свободный порт 8080. Образы закреплены по digest, Python-зависимости — по версиям в `requirements.txt`. + +```sh +make bootstrap # создаёт локальный .env и secrets/ (пароль генерируется на месте) +make up # build + postgres + valkey + миграции + api +curl -i http://localhost:8080/health/ready +make test # публичный smoke +make test-custom # свои проверки уровня 4 +``` + +`make bootstrap` создаёт `.env` из `.env.example` и три файла в `secrets/`: `postgres_password` (случайный), `database_url`, `cache_url`. Каталоги `secrets/`, `backups/` и `.env` закрыты `.gitignore`; в репозиторий попадают только пути к секретам, не значения. + +Миграции применяет отдельный одноразовый сервис `migrate` (`python scripts/migrate.py`), от которого `api` зависит через `service_completed_successfully`. Повторный запуск (`make migrate`) печатает `skip 0001_init` и ничего не меняет: применённые версии и их sha256 лежат в таблице `schema_migrations`, при изменении уже применённого файла запуск падает с ошибкой. Выполняется под advisory lock, поэтому одновременный запуск двух runner-ов безопасен. + +Все проверки и эксперименты одной командой — она пересоздаёт стенд с нуля и складывает вывод каждого шага в `evidence/`: + +```sh +make evidence +``` + +Те же сценарии по отдельности: + +```sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh # рестарт API и всех хранилищ +make expiry # истечение сессии при TTL=2 с +make outages # отзыв сессии против рестарта кэша, зависшая БД +make dependency # отказ Valkey, затем отказ PostgreSQL +make explain # план истории на таблице не меньше 10 000 сообщений +TOTAL=120000 make track2 # трек 5: индексы + backup/restore +python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-cache.json +# тот же прогон при остановленном Valkey даёт вторую точку сравнения: +docker compose --env-file .env stop valkey +python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-nocache.json +docker compose --env-file .env start valkey +``` + +Безопасная остановка: `make down` (том `pgdata` сохраняется, данные остаются). Намеренное удаление учебных данных: `docker compose --env-file .env down -v` — удаляет том базы вместе со всеми данными; дополнительно `rm -rf backups/` удаляет локальные дампы. `student-tests/track2.sh` сам удаляет свой временный контейнер и том восстановления (`KEEP=1` оставляет их для осмотра). `TOTAL` задаёт целевой размер истории: засев добивает таблицу до этого числа и при повторном запуске не добавляет ничего, поэтому прогоны воспроизводимы. + +Переменные `.env.example` соответствуют реальной конфигурации: `APP_HOST/APP_PORT/GRACEFUL_TIMEOUT` читает команда uvicorn в `Dockerfile`, остальные — `app/config.py`. `DATABASE_URL_FILE` и `CACHE_URL_FILE` в контейнере указывают на docker secrets (`/run/secrets/...`), которые compose монтирует из `secrets/`. + +| Переменная | Что задаёт | Значение по умолчанию | +| --- | --- | --- | +| `SESSION_TTL_SECONDS` | срок жизни сессии | 3600 | +| `SESSION_CACHE_TTL_SECONDS` | срок жизни записи в кэше сессий | 30 | +| `SESSION_SWEEP_SECONDS` | период удаления истёкших сессий из БД | 60 | +| `SESSION_STORE` | источник истины для сессий | postgres | +| `DB_POOL_MIN`, `DB_POOL_MAX` | границы пула соединений | 1, 10 | +| `DB_POOL_TIMEOUT`, `DB_CONNECT_TIMEOUT` | ожидание свободного соединения и подключения, с | 3, 3 | +| `DB_STATEMENT_TIMEOUT_MS` | `statement_timeout` и `lock_timeout` на сервере | 5000 | +| `DB_OP_TIMEOUT` | клиентский лимит на один SQL-запрос, с | 6 | +| `DB_READY_TIMEOUT` | лимит проверки готовности БД, с | 1.5 | +| `REQUEST_TIMEOUT` | потолок на обработку всего HTTP-запроса, с | 8 | +| `CACHE_TIMEOUT` | таймаут на операцию с Valkey, с | 0.2 | +| `MAX_INFLIGHT_REQUESTS` | одновременных запросов, сверх — 429 | 64 | +| `MAX_BODY_BYTES` | размер тела, сверх — 413 | 65536 | +| `MAX_RSS_MB` | лимит памяти процесса, сверх — 503 на запись (0 — выключен) | 0 | ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент → uvicorn/FastAPI (app/) ──► PostgreSQL 17.7 (источник истины: users, chats, chat_members, messages, sessions) + └─► Valkey 8.1 (кэш сессий с TTL, намеренно без persistence) + migrate (одноразовый) ──► PostgreSQL (versioned SQL из migrations/) +``` + +**Источник истины.** Все обязательные данные и сессии лежат в PostgreSQL на томе `pgdata`. Valkey — кэш: он ускоряет проверку токена, но не хранит ничего, чего нет в базе. Поэтому потеря Valkey не теряет данные, а только замедляет работу; `SESSION_STORE=postgres` фиксирует это решение в конфигурации. + +**Кэш сессий намеренно без persistence.** У Valkey выключены и RDB (`--save ""`), и AOF (`--appendonly no`). Это не упущение, а требование безопасности: если кэш переживает рестарт, он может воскресить запись об уже отозванной сессии и вернуть доступ по мёртвому токену. С volatile-кэшом после любого рестарта таблица сессий в PostgreSQL остаётся единственным источником правды, и каждый токен проверяется заново. Persistence кэша обязателен только если он единственное хранилище сессий — у нас это не так. + +**Отзыв сессии устойчив к кэшу.** `DELETE /auth/sessions/current` сначала удаляет ключ из Valkey и только потом строку из PostgreSQL. Поэтому 204 означает, что токен мёртв в обоих местах; обратного порядка (сначала БД, потом кэш) мы избегаем именно потому, что при сбое второго шага кэш продолжал бы отдавать отозванную сессию. Если кэш недоступен, logout возвращает 503 и сессию не удаляет: выход не подтверждается, пока нельзя гарантировать, что кэш больше не отдаст токен. Клиент повторяет запрос; проверено тестом `logout_is_not_confirmed_while_cache_is_down`. + +**Схема и ограничения** (`migrations/0001_init.sql`). `users.username` — `UNIQUE` плюс `CHECK (username ~ '^[a-z0-9_]{3,32}$')`, так что уникальность username гарантирует база, а не только проверка в коде. `chat_members` — таблица связи с `PRIMARY KEY (chat_id, user_id)` и внешними ключами на `chats` и `users`. `messages` ссылается на `chats` и `users`. `sessions` хранит `token_hash bytea PRIMARY KEY`, `user_id`, `created_at`, `expires_at`. + +**Почему текст хранится в `bytea`.** `display_name`, `title` и `messages.text` — `bytea` с UTF-8 байтами, а не `text`. Причина: контракт разрешает в тексте любые Unicode code points, включая U+0000, а тип `text` в PostgreSQL физически не может содержать нулевой байт — попытка записи даёт `invalid byte sequence for encoding "UTF8": 0x00`, то есть 500 на валидном по контракту запросе. Хранение байтами даёт точный round-trip любой строки; длину в code points проверяет приложение (1..100 для имён и заголовков, 1..4000 для текста), а база дополнительно ограничивает `octet_length`. Цена решения — SQL-запросы к этим столбцам нельзя сравнивать как текст: в своих скриптах используются `convert_to`, `position` и `encode`, а не `LIKE` по `convert_from` (последний падает как раз на строках с NUL). + +**Транзакционные границы.** Соединения работают в autocommit, то есть один запрос — одна транзакция. Явная транзакция открывается там, где составная операция должна быть атомарной: создание чата вставляет строку в `chats` и строки в `chat_members` одним `BEGIN ... COMMIT`. Участники добавляются `INSERT ... SELECT u.id FROM users WHERE u.id = ANY(%s)`, и если вставилось меньше строк, чем запрошено, значит кто-то из `member_ids` не существует — поднимается исключение, транзакция откатывается, клиент получает 400, а в базе не остаётся чата без участников. Отправка сообщения — один оператор `INSERT ... SELECT ... WHERE EXISTS (SELECT 1 FROM chat_members ...)`: проверка членства и запись атомарны, отдельного запроса на проверку доступа нет, посторонний получает 404 (0 строк). + +**Индекс истории.** `messages_history_idx (chat_id, created_at, id)` повторяет порядок сортировки контракта, поэтому страница читается диапазонным сканом индекса без сортировки. Keyset-пагинация сравнивает кортеж: `(created_at, id) > (:ts, :id)`. Цена страницы не зависит от её номера — измерения в разделе эксперимента. + +**Пагинация и курсор.** Курсор перенесён из lab1: base64 от `{scope, created_at, id}`, где scope — `messages:` или `chats:`. Курсор проверяется строго (формат времени с микросекундами, UUID, совпадение с заново закодированным значением), поэтому изменённый вручную курсор и курсор другого чата дают 400. Пустая строка в `cursor` или `limit` — это именно неверное значение, а не отсутствие параметра: такой запрос получает 400. Повторов и пропусков при обходе неизменной истории нет; snapshot между HTTP-запросами не гарантируется. Время ставит сервер (`clock_timestamp()`, микросекунды), порядок внутри одной микросекунды разводится по `id`. + +**Аутентификация.** `POST /api/v1/users` принимает `password` (12–128 code points) и хеширует его Argon2id (`argon2-cffi`, `time_cost=2, memory_cost=19456 KiB, parallelism=1`). Хеширование и проверка выполняются в threadpool, чтобы KDF не блокировал event loop. `POST /api/v1/auth/sessions` принимает только Basic и не принимает тело: любой непустой body даёт 400. Вход выдаёт opaque-токен `secrets.token_urlsafe(32)` — 256 бит энтропии; в базу пишется только `sha256(token)`, самого токена сервер не хранит. Остальные endpoint принимают только Bearer; Basic на них — 401 с `WWW-Authenticate: Bearer`, `X-User-Id` игнорируется полностью. Неверный пароль и несуществующий пользователь дают один и тот же 401: при отсутствии пользователя проверка выполняется против фиктивного хеша, чтобы ответ не отличался ни телом, ни временем. Повреждённый UTF-8 в теле или в Basic-строке не «исправляется» заменой символов, а отклоняется (400 и 401 соответственно). + +**Валидация входа.** Тело читается потоком с лимитом `MAX_BODY_BYTES` (413), `Content-Type` обязателен (415 на любой другой), лишние и недостающие поля — 400. Некорректный JSON, в том числе битые числа (`1e999`, `NaN`), обрезанное тело и глубокая вложенность, вызывающая `RecursionError`, дают 400, а не 500. Обязательные строки не могут состоять только из пробельных символов, причём к пробельным приравнены и невидимые `U+200B..U+200D`, `U+2060`, `U+FEFF`. + +**Кэш сессий.** Ключ `session:` — коллизий между пользователями быть не может, значение — публичные поля владельца токена, TTL = `min(SESSION_CACHE_TTL_SECONDS, остаток до expires_at)`. Промах читает `sessions JOIN users` с условием `expires_at > now()` и снова наполняет кэш. Истёкшие строки убирает фоновая задача раз в `SESSION_SWEEP_SECONDS`; TTL абсолютный, рестарт его не продлевает. + +**Пул и таймауты.** `AsyncConnectionPool` с `min_size=1`, `max_size=10`, ожиданием свободного соединения 3 с, `connect_timeout=3`; на каждом соединении выставлены `statement_timeout=5000`, `lock_timeout=5000`, `idle_in_transaction_session_timeout=10000`. Серверных таймаутов недостаточно: если процесс БД заморожен, он не успеет их применить, поэтому каждый SQL-запрос дополнительно обёрнут клиентским лимитом `DB_OP_TIMEOUT`, а весь HTTP-запрос — потолком `REQUEST_TIMEOUT` в middleware. Соединение, на котором сработал клиентский таймаут, закрывается, чтобы пул заменил его, а не выдал следующему запросу. Все запросы параметризованы psycopg (`%s`), конкатенации пользовательских данных в SQL нет. + +**Деградация.** `OperationalError`, `InterfaceError`, таймаут пула и клиентские таймауты превращаются в 503 `unavailable` с `Retry-After` — недоступность зависимости не маскируется под 500. `/health/live` отвечает 200, пока жив процесс; `/health/ready` выполняет `SELECT 1` с отдельным лимитом и отдаёт 503, если база недоступна. Valkey в readiness не входит сознательно: без кэша сервис работоспособен. Ошибки кэша считаются в счётчике и логируются не чаще одного раза на 50 отказов. + +**Что перенесено из lab1:** структура приложения и обработка ошибок, единый формат `{"error":{code,message,request_id}}`, `X-Request-Id` в каждом ответе, строгая валидация полей и курсора, потоковое чтение тела с лимитом (413), лимит одновременных запросов (429), graceful shutdown по SIGTERM с режимом drain, запуск от uid 10001. + +**Объявленные переходы относительно lab1:** `X-User-Id` больше не аутентифицирует — вместо него Bearer-сессия; состояние ушло из памяти процесса в PostgreSQL, поэтому требование «ровно один процесс API» снято; счётчики `MAX_USERS/MAX_CHATS/MAX_MESSAGES` из lab1 убраны — они требовали бы `COUNT(*)` на каждый запрос, их роль теперь выполняют том базы и квоты СУБД; `MAX_RSS_MB` сохранён, но по умолчанию выключен (`0`), так как данные больше не живут в памяти. + +**Решения по инфраструктуре.** Образы закреплены по digest: `postgres:17.7-alpine@sha256:bb377b72…`, `valkey/valkey:8.1-alpine@sha256:081c2f5c…`. У Valkey политика `allkeys-lru` и нет томов — это допустимо именно потому, что это кэш, а не хранилище истины. Пароль PostgreSQL и строки подключения передаются docker secrets, в `environment` лежат только пути к файлам. Порт API опубликован на `127.0.0.1:8080`, внутрь контейнера сервер слушает `0.0.0.0` (иначе проброшенный порт не дошёл бы до процесса). CI (`.github/workflows/app.yml`) поднимает стек, проверяет повторный запуск миграций и гоняет smoke, свои тесты и persistence. ## Доказательства критериев +Окружение: Apple M4, 10 ядер, 16 ГБ RAM, Docker Desktop (лимит 10 CPU / 7.7 ГБ), macOS Darwin 25.6.0 arm64, Docker 29.7.2, Compose v5.5.1, PostgreSQL 17.7 (aarch64, musl), Valkey 8.1.10, образ API — python 3.12.8-slim, хост-Python 3.9.6, 2026-10-19. Полный состав стенда и версии — в `evidence/stand.txt`. Все числа ниже получены одним прогоном `make evidence`, начатым с удаления тома базы, поэтому относятся к одному и тому же состоянию стенда. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` | `PASS: lab2 public API scenario` | `evidence/smoke.txt` | +| Данные и действующие сессии переживают рестарт API и хранилищ | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` (hook: `docker compose restart postgres valkey api`) | `PASS: persistence preserved confirmed data and existing session`; тот же токен читает ту же историю | `evidence/persistence.txt` (состояние контейнеров до и после, логи postgres о перезапуске) | +| PostgreSQL содержит users/chats/members/messages, есть PK/FK, уникальность username, миграции с нуля | `make up` на пустом томе, затем `make migrate` | `apply 0001_init`, повторный запуск — `skip 0001_init`; в `schema_migrations` одна версия с checksum `4fd0a8c6…` | `evidence/migrations.txt` (включая `\d+ messages`) | +| Составная операция создания чата атомарна | `test_storage_rules.py::unknown_member_rolls_chat_back` | 400 на неизвестного участника, чат в списке отсутствует | `evidence/level4-tests.txt` | +| Basic только на `POST /auth/sessions`, остальное — Bearer; `X-User-Id` не даёт доступа | `test_auth_sessions.py` | 9/9 PASS, в том числе Basic на `/users/me` → 401 Bearer, вход с телом → 400, повреждённый UTF-8 → 400/401 | `evidence/level4-tests.txt` | +| Срок жизни сессии и отзыв | `make expiry` (TTL=2 с) | 3/3 PASS: истёкший токен → 401, запись истёкшим → 401, `expires_at` соответствует TTL | `evidence/expiry.txt` | +| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 4/4 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` | +| Пароли хешируются password KDF | `app/passwords.py`, формат хеша в БД | `$argon2id$v=19$m=19456,t=2,p=1$…`, в API пароль не возвращается | `evidence/level4-tests.txt` | +| Любая строка Unicode сохраняется без искажений | `test_storage_rules.py::nul_and_unicode_text_round_trips`, `::text_length_limit_counts_code_points` | `a\u0000b`, одиночный `\u0000`, emoji с ZWJ, комбинирующие и RTL, 4000 code points — 201 и точный round-trip; 4001 — 400 | `evidence/level4-tests.txt` | +| Secrets/volumes не попадают в Git | `git status --porcelain`, `git check-ignore -v` | `.env`, `secrets/`, `backups/` игнорируются; в рабочем дереве только код, тесты и `evidence/` | `evidence/git-hygiene.txt` | +| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1097.7 RPS / p95 6.06 мс против 691.7 RPS / p95 8.15 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` | +| Параметризованные запросы, ограниченный пул и таймауты | `test_storage_rules.py::sql_injection_is_not_executed`, `::content_type_is_required`, `::broken_json_does_not_break_the_api`, `app/db.py` | SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, `statement_timeout=5000`, клиентский лимит 6 с, потолок запроса 8 с | `evidence/level4-tests.txt` | +| Гонка регистрации одинакового username | `test_storage_rules.py::duplicate_username_race_creates_one_user` (12 потоков) | один 201, одиннадцать 409 | `evidence/level4-tests.txt` | +| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (53 764 сообщения в таблице) | keyset, первая страница: 24 буфера, 0.026 мс; keyset на глубине 90 %: 53 буфера, 0.063 мс; OFFSET той же глубины: 29 813 буферов, 4.17 мс (29 699 строк пройдено ради 50) | `evidence/explain-10k.txt` | +| Проверка expiry, logout, неверного пароля и недоступности Redis/БД | `make dependency`, `make outages` | без Valkey 3/3 PASS (кэш обойдён, ошибок нет); без PostgreSQL 4/4 PASS: `/health/ready` 503, запись 503, неизвестный токен не становится доверенным; зависшая БД (`pause`) отвечает 503 быстрее 10 с | `evidence/dependency.txt`, `evidence/outages.txt` | +| Трек 5 (трек 2): ≥100 000 сообщений, ≥2 индекса, цена записи, backup → restore → сверка | `TOTAL=120000 make track2` | 120 000 сообщений в 68 чатах; варианты A/B/C сравнены; md5 истории источника и копии совпали; маркер после бэкапа в копии отсутствует | `evidence/track2/run.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Проверка инфраструктурного hook: `scripts/restart.sh` выполняет `docker compose --env-file .env restart postgres valkey api`, то есть перезапускаются и API, и PostgreSQL, и Valkey; тома не удаляются. Подтверждение — состояние контейнеров до и после в `evidence/persistence.txt` (у всех трёх сервисов новое время старта) плюс строки `database system was shut down` → `database system is ready to accept connections` в логах postgres из того же файла. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +### Трек 2, часть 1: план запроса и цена индекса + +**Гипотеза.** Для keyset-пагинации по контракту (`ORDER BY created_at, id` внутри одного чата) составной индекс `(chat_id, created_at, id)` даёт цену страницы, не зависящую от её глубины, а индекс только по `chat_id` вынуждает читать и сортировать всю историю чата на каждую страницу. Покрывающий индекс с `INCLUDE (sender_id, text)` должен убрать обращения к heap, но увеличить размер индекса и цену записи. + +**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 66 236 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 32 944 строки в самом большом, 20 775 во втором, затем 25, 5 и 3 — то есть разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый. + +| Вариант индекса | План страницы на глубине 90 % | Буферы | Время одной страницы | 100 страниц | Размер индекса | Вставка 10 000 строк | +| --- | --- | --- | --- | --- | --- | --- | +| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 53 | 0.048 мс | 1.12 мс | 10 МБ | 0.084 с | +| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 29 650` | 441 | 1.73 мс | 2186 мс | 848 кБ | 0.078 с | +| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.031 мс | 0.74 мс | 14 МБ | 0.085 с | + +**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 29 650 строк ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 1950 раз (2186 мс против 1.12 мс), причём отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 53) и на серии страниц быстрее A примерно на треть, платя 14 МБ индекса против 10 МБ. Ожидаемого удорожания записи у C на этих данных не видно: 0.085 с против 0.084 с на 10 000 строк — разница в пределах шума, потому что засеянные тексты короткие и однотипные. B пишет быстрее всех (0.078 с) просто потому, что его индекс меньше. + +**Вывод.** В схему взят вариант A: постоянная цена страницы при умеренном размере индекса. C даёт измеримый выигрыш по буферам и по серии страниц и остаётся кандидатом, если история читается существенно чаще, чем пишется; прежде чем переключаться, его цену записи нужно перемерять на длинных текстах, где дублирование текста в индексе должно проявиться. Переключение — одна миграция. + +### Трек 2, часть 2: бэкап и восстановление в новое хранилище + +**Гипотеза.** `pg_dump -Fc` даёт согласованный снимок на момент начала дампа; восстановление в чистое хранилище воспроизводит данные точно, а всё подтверждённое после снимка теряется — это и есть граница потери данных при такой схеме бэкапа. + +**Методика.** `student-tests/track2.sh`: снимок `pg_dump -Fc` → запись маркерного сообщения уже после дампа → поднятие отдельного контейнера PostgreSQL 17.7 на новом томе `mtusi-lab2-restore-data` с новой базой `messenger_restored` → `pg_restore --exit-on-error` → сверка. Сверяются количество строк в каждой таблице, количество строк и md5 конкатенации `(id, created_at, encode(text,'hex'))` в порядке `(created_at, id)` для самого большого чата, первые три сообщения этого чата и наличие маркера. Сверка идёт по `encode`, а не по `convert_from`, потому что в истории есть сообщения с реальным NUL — на них перевод bytea в text падает. Время бэкапа и восстановления снимается внешним таймером с точностью до миллисекунды и включает накладные расходы `docker exec`. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.6 МБ | бэкап 0.761 с | +| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 74/74, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 43/43; md5 истории большого чата (32 944 строки) `6c6725a76404fbb0b8b5b509707e30b5` в обеих базах; первые три сообщения совпали | восстановление 0.370 с; потерь на момент снимка нет | +| Запись после снимка (маркерное сообщение) | в копии отсутствует | в источнике 1 маркер, в восстановленной копии 0 | потеряно всё, подтверждённое после начала дампа | +| Рестарт API и обоих хранилищ с сохранением томов | данные и действующая сессия живы | `PASS` публичного persistence-теста: тот же токен читает ту же историю, дублей нет | простой до readiness < 10 с, потерь нет | +| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 691.7 RPS против 1097.7 RPS, p95 8.15 мс против 6.06 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×1.6 | +| Остановка PostgreSQL | ограниченная ошибка, доверия нет | `/health/ready` 503, регистрация 503, неизвестный токен → 503/401, анонимный → 401, `/health/live` 200 | запись недоступна полностью до возврата БД | +| Заморозка PostgreSQL (`docker compose pause`) | быстрый 503, а не зависший запрос | 503 быстрее 10 с при потолке запроса 8 с; после `unpause` доступ восстановился | потерь нет | +| Рестарт Valkey после подтверждённого logout | отозванный токен остаётся мёртвым | 401 после рестарта кэша | потерь нет | + +**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 32 944 успешных POST, 0 ошибок, 1097.706 RPS, p50 3.248 / p95 6.063 / p99 10.603 мс. С остановленным Valkey: 20 775 успешных POST, 0 ошибок, 691.741 RPS, p50 5.447 / p95 8.152 / p99 11.778 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда. + +**Ограничения измерений.** Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до `VACUUM` — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 1.7 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть. + +**Какие отказы не выдерживаются.** PostgreSQL — единственная точка истины без реплики: при потере тома `pgdata` данные восстанавливаются только из дампа, то есть теряется всё после последнего `pg_dump`. WAL-архивирование и PITR не настроены, непрерывного бэкапа нет. API — один экземпляр, балансировщика нет (это тема lab3), поэтому его перезапуск — простой сервиса, а не бесшовное переключение. Rate limiting по пользователю и HTTPS в объём lab2 не входят. + +**Учебные упрощения.** Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в `bytea` усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (`load_*` пользователи, `load chat *`) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов. + +**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 1950 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.085 с против 0.084 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось). + +**Следующие шаги.** Настроить WAL-архивирование и проверить PITR с восстановлением на момент времени; добавить реплику PostgreSQL и измерить переключение; подобрать `DB_POOL_MAX` и профиль Argon2id под целевой p95; перенести эксперименты на отдельную базу; в lab3 добавить балансировщик и идемпотентность записи. + +## Ответы на вопросы защиты + +- **Что подтверждает COMMIT и от какой настройки durability это зависит.** COMMIT подтверждает, что изменения записаны в WAL и сброшены на диск, поэтому после аварии они будут восстановлены. Зависит от `synchronous_commit` (у нас `on`) и `fsync` (включён): при `synchronous_commit=off` ответ клиенту приходит раньше фактического fsync, и последние транзакции можно потерять при потере питания. +- **Где хранятся сессии и что будет после flush/restart Valkey.** Источник истины — таблица `sessions` в PostgreSQL; в Valkey только кэш с TTL и без persistence. После `FLUSHALL` или рестарта Valkey сессии продолжают работать: первый запрос промахивается, читает строку из базы и снова наполняет кэш. Важнее обратное: именно потому, что кэш не переживает рестарт, отозванная сессия не может вернуться вместе с кэшом — это проверено тестом. +- **Чем аутентификация отличается от доступа к конкретному чату.** Аутентификация отвечает на вопрос «кто это»: действителен ли Bearer-токен и не истёк ли он; её провал — 401. Доступ отвечает на вопрос «можно ли этому пользователю именно этот чат»: есть ли строка в `chat_members`; её провал — 404, а не 403, чтобы не раскрывать существование чужого чата. +- **Почему hash пароля и быстрый checksum решают разные задачи.** Пароль человек выбирает из небольшого множества, поэтому его хеш должен быть намеренно медленным и требовательным к памяти (Argon2id), чтобы перебор был дорогим. Токен сессии — 256 случайных бит, перебирать его бессмысленно, поэтому для него достаточно быстрого SHA-256: он нужен лишь для того, чтобы в базе не лежал сам токен и утечка таблицы не давала доступа. +- **Почему текст лежит в `bytea`, а не в `text`.** Потому что контракт разрешает любые Unicode code points, а `text` в PostgreSQL не может содержать U+0000: такой запрос либо падает с 500, либо строку приходится молча портить. Байты сохраняют её точно, а длину в code points проверяет приложение. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..83685a6f --- /dev/null +++ b/app/config.py @@ -0,0 +1,43 @@ +import os +import socket + + +def _int(name, default): + value = os.environ.get(name) + return int(value) if value not in (None, "") else default + + +def _float(name, default): + value = os.environ.get(name) + return float(value) if value not in (None, "") else default + + +def _secret(name, default=""): + path = os.environ.get(name + "_FILE") + if path: + with open(path, encoding="utf-8") as handle: + return handle.read().strip() + return os.environ.get(name, default) + + +DATABASE_URL = _secret("DATABASE_URL") +CACHE_URL = _secret("CACHE_URL") +SESSION_STORE = os.environ.get("SESSION_STORE", "postgres") +SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600) +SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 30) +SESSION_SWEEP_SECONDS = _int("SESSION_SWEEP_SECONDS", 60) +DB_POOL_MIN = _int("DB_POOL_MIN", 1) +DB_POOL_MAX = _int("DB_POOL_MAX", 10) +DB_POOL_TIMEOUT = _float("DB_POOL_TIMEOUT", 3.0) +DB_CONNECT_TIMEOUT = _int("DB_CONNECT_TIMEOUT", 3) +DB_STATEMENT_TIMEOUT_MS = _int("DB_STATEMENT_TIMEOUT_MS", 5000) +DB_OP_TIMEOUT = _float("DB_OP_TIMEOUT", 6.0) +REQUEST_TIMEOUT = _float("REQUEST_TIMEOUT", 8.0) +DB_READY_TIMEOUT = _float("DB_READY_TIMEOUT", 1.5) +CACHE_TIMEOUT = _float("CACHE_TIMEOUT", 0.2) +MAX_INFLIGHT_REQUESTS = _int("MAX_INFLIGHT_REQUESTS", 64) +MAX_BODY_BYTES = _int("MAX_BODY_BYTES", 65536) +MAX_RSS_MB = _int("MAX_RSS_MB", 0) +PASSWORD_MIN = 12 +PASSWORD_MAX = 128 +INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname() diff --git a/app/cursor.py b/app/cursor.py new file mode 100644 index 00000000..113aabc8 --- /dev/null +++ b/app/cursor.py @@ -0,0 +1,43 @@ +import base64 +import json +import re +import uuid +from datetime import datetime, timezone + +TS_RE = re.compile(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}Z") +TS_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ" + + +class BadCursor(Exception): + pass + + +def fmt(ts: datetime) -> str: + return ts.astimezone(timezone.utc).strftime(TS_FORMAT) + + +def encode_cursor(scope: str, created_at: str, item_id: str) -> str: + raw = json.dumps({"s": scope, "t": created_at, "i": item_id}, separators=(",", ":")).encode() + return base64.urlsafe_b64encode(raw).decode().rstrip("=") + + +def decode_cursor(scope: str, cursor: str): + try: + raw = base64.urlsafe_b64decode(cursor + "=" * (-len(cursor) % 4)) + data = json.loads(raw) + except Exception: + raise BadCursor() from None + if not isinstance(data, dict) or set(data) != {"s", "t", "i"} or data["s"] != scope: + raise BadCursor() + ts, item_id = data["t"], data["i"] + if not isinstance(ts, str) or not TS_RE.fullmatch(ts) or not isinstance(item_id, str): + raise BadCursor() + try: + parsed = datetime.strptime(ts, TS_FORMAT).replace(tzinfo=timezone.utc) + if str(uuid.UUID(item_id)) != item_id: + raise BadCursor() + except ValueError: + raise BadCursor() from None + if encode_cursor(scope, ts, item_id) != cursor: + raise BadCursor() + return parsed, item_id diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..0bd63089 --- /dev/null +++ b/app/db.py @@ -0,0 +1,99 @@ +import asyncio +from contextlib import asynccontextmanager + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import AsyncConnectionPool, PoolTimeout + +from app import config +from app.errors import unavailable + +BROKEN = (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout) + + +async def discard(conn) -> None: + try: + await conn.close() + except Exception: + pass + + +class Guarded: + def __init__(self, conn, timeout: float): + self.conn = conn + self.timeout = timeout + + async def execute(self, *args, **kwargs): + try: + return await asyncio.wait_for(self.conn.execute(*args, **kwargs), self.timeout) + except asyncio.TimeoutError: + await discard(self.conn) + raise unavailable("Хранилище не ответило за отведённое время") from None + + def transaction(self): + return self.conn.transaction() + + +class Database: + def __init__(self) -> None: + options = "-c statement_timeout=%d -c lock_timeout=%d -c idle_in_transaction_session_timeout=%d" % ( + config.DB_STATEMENT_TIMEOUT_MS, + config.DB_STATEMENT_TIMEOUT_MS, + config.DB_STATEMENT_TIMEOUT_MS * 2, + ) + self.pool = AsyncConnectionPool( + conninfo=config.DATABASE_URL, + min_size=config.DB_POOL_MIN, + max_size=config.DB_POOL_MAX, + timeout=config.DB_POOL_TIMEOUT, + max_lifetime=600.0, + open=False, + kwargs={ + "autocommit": True, + "row_factory": dict_row, + "connect_timeout": config.DB_CONNECT_TIMEOUT, + "options": options, + }, + ) + + async def open(self) -> None: + await self.pool.open(wait=False) + + async def close(self) -> None: + await self.pool.close() + + @asynccontextmanager + async def connection(self): + try: + async with self.pool.connection(timeout=config.DB_POOL_TIMEOUT) as conn: + yield Guarded(conn, config.DB_OP_TIMEOUT) + except BROKEN: + raise unavailable("Хранилище недоступно") from None + + @asynccontextmanager + async def transaction(self): + async with self.connection() as conn: + async with conn.transaction(): + yield conn + + async def in_transaction(self, action): + async def run(): + async with self.transaction() as conn: + return await action(conn) + + try: + return await asyncio.wait_for(run(), config.DB_OP_TIMEOUT) + except asyncio.TimeoutError: + raise unavailable("Хранилище не ответило за отведённое время") from None + + async def ready(self) -> bool: + try: + async with self.pool.connection(timeout=config.DB_READY_TIMEOUT) as conn: + try: + await asyncio.wait_for(conn.execute("SELECT 1"), config.DB_READY_TIMEOUT) + except asyncio.TimeoutError: + await discard(conn) + return False + return True + except Exception: + return False diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..8110d273 --- /dev/null +++ b/app/errors.py @@ -0,0 +1,37 @@ +from typing import Optional + +from fastapi.responses import JSONResponse + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str, headers: Optional[dict] = None): + self.status, self.code, self.message, self.headers = status, code, message, headers or {} + + +def bad(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def unauthorized(scheme: str = "Bearer") -> ApiError: + challenge = BASIC_CHALLENGE if scheme == "Basic" else BEARER_CHALLENGE + message = "Нужны имя пользователя и пароль" if scheme == "Basic" else "Нужна действующая сессия" + return ApiError(401, "unauthorized", message, {"WWW-Authenticate": challenge}) + + +def not_found() -> ApiError: + return ApiError(404, "not_found", "Объект не найден") + + +def unavailable(message: str) -> ApiError: + return ApiError(503, "unavailable", message, {"Retry-After": "1"}) + + +def error_body(rid: str, instance: str, status: int, code: str, message: str, headers: Optional[dict] = None) -> JSONResponse: + return JSONResponse( + status_code=status, + content={"error": {"code": code, "message": message, "request_id": rid}}, + headers={"X-Request-Id": rid, "X-Instance-Id": instance, **(headers or {})}, + ) diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..7baa6355 --- /dev/null +++ b/app/main.py @@ -0,0 +1,391 @@ +import asyncio +import base64 +import binascii +import json +import logging +import os +import re +import resource +import signal +import sys +import uuid +from contextlib import asynccontextmanager +from typing import List, Optional, Tuple + +from fastapi import FastAPI, Request +from fastapi.responses import JSONResponse, Response +from starlette.concurrency import run_in_threadpool + +from app import config, passwords, repo +from app.cursor import BadCursor, decode_cursor, encode_cursor +from app.db import Database +from app.errors import ApiError, bad, error_body, not_found, unauthorized, unavailable +from app.sessions import SessionStore + +logging.basicConfig(stream=sys.stdout, level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") +log = logging.getLogger("messenger") + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +ZERO_WIDTH = str.maketrans({char: None for char in "\u200b\u200c\u200d\u2060\ufeff"}) +EXEMPT_PATHS = ("/health/live", "/health/ready") +PAGE_SIZE = os.sysconf("SC_PAGE_SIZE") if hasattr(os, "sysconf") else 4096 + +db = Database() +sessions = SessionStore(db) +state = {"draining": False, "inflight": 0, "rejected": {}} + + +def rss_mb() -> float: + try: + with open("/proc/self/statm") as handle: + return int(handle.read().split()[1]) * PAGE_SIZE / 1048576 + except OSError: + peak = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss + return peak / 1048576 if sys.platform == "darwin" else peak / 1024 + + +def count_rejection(code: str) -> None: + state["rejected"][code] = state["rejected"].get(code, 0) + 1 + + +async def sweeper() -> None: + while True: + await asyncio.sleep(config.SESSION_SWEEP_SECONDS) + try: + removed = await sessions.sweep() + if removed: + log.info("sessions_expired removed=%d", removed) + except Exception: + log.warning("session sweep skipped: storage unavailable") + + +@asynccontextmanager +async def lifespan(_app: FastAPI): + previous = {} + + def on_signal(signum, frame): + if not state["draining"]: + state["draining"] = True + log.info("signal %s: draining, new requests get 503", signal.Signals(signum).name) + handler = previous.get(signum) + if callable(handler): + handler(signum, frame) + + for sig in (signal.SIGTERM, signal.SIGINT): + previous[sig] = signal.getsignal(sig) + signal.signal(sig, on_signal) + await db.open() + await sessions.open() + task = asyncio.create_task(sweeper()) + log.info( + "started: instance=%s session_store=%s session_ttl=%d cache_ttl=%d pool=%d..%d max_inflight=%d max_body=%d", + config.INSTANCE_ID, config.SESSION_STORE, config.SESSION_TTL_SECONDS, config.SESSION_CACHE_TTL_SECONDS, + config.DB_POOL_MIN, config.DB_POOL_MAX, config.MAX_INFLIGHT_REQUESTS, config.MAX_BODY_BYTES, + ) + yield + task.cancel() + await sessions.close() + await db.close() + log.info("stopped: cache=%s rejected=%s", sessions.stats, state["rejected"]) + + +app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None) + + +@app.middleware("http") +async def guard(request: Request, call_next): + rid = uuid.uuid4().hex + request.state.rid = rid + exempt = request.url.path in EXEMPT_PATHS + if state["draining"] and request.url.path != "/health/live": + count_rejection("draining") + return error_body(rid, config.INSTANCE_ID, 503, "unavailable", "Сервер завершает работу", {"Retry-After": "1", "Connection": "close"}) + if not exempt and state["inflight"] >= config.MAX_INFLIGHT_REQUESTS: + count_rejection("inflight") + return error_body(rid, config.INSTANCE_ID, 429, "rate_limited", "Слишком много одновременных запросов", {"Retry-After": "1"}) + state["inflight"] += 1 + try: + response = await asyncio.wait_for(call_next(request), config.REQUEST_TIMEOUT) + except asyncio.TimeoutError: + count_rejection("request_timeout") + log.warning("request timeout request_id=%s method=%s path=%s", rid, request.method, request.url.path) + response = error_body( + rid, config.INSTANCE_ID, 503, "unavailable", + "Запрос не удалось обработать за отведённое время", {"Retry-After": "1"}, + ) + except Exception: + log.exception("unhandled error request_id=%s", rid) + response = error_body(rid, config.INSTANCE_ID, 500, "internal_error", "Внутренняя ошибка сервера") + finally: + state["inflight"] -= 1 + response.headers["X-Request-Id"] = rid + response.headers["X-Instance-Id"] = config.INSTANCE_ID + return response + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError): + if exc.status in (413, 429, 503): + count_rejection(exc.code) + return error_body(request.state.rid, config.INSTANCE_ID, exc.status, exc.code, exc.message, exc.headers) + + +def parse_uuid(value: object) -> Optional[str]: + if not isinstance(value, str): + return None + try: + return str(uuid.UUID(value)) + except ValueError: + return None + + +def non_blank(value: object, max_len: int) -> bool: + if not isinstance(value, str) or not 1 <= len(value) <= max_len: + return False + return value.translate(ZERO_WIDTH).strip() != "" + + +async def read_json(request: Request, fields: Tuple[str, ...]) -> dict: + if request.headers.get("content-type", "").split(";")[0].strip().lower() != "application/json": + raise ApiError(415, "unsupported_media_type", "Ожидается application/json") + too_large = ApiError(413, "payload_too_large", "Тело запроса слишком большое", {"Connection": "close"}) + declared = request.headers.get("content-length") + if declared and declared.isdigit() and int(declared) > config.MAX_BODY_BYTES: + raise too_large + raw = bytearray() + async for chunk in request.stream(): + raw += chunk + if len(raw) > config.MAX_BODY_BYTES: + raise too_large + try: + body = json.loads(bytes(raw).decode("utf-8")) + except (UnicodeDecodeError, ValueError, RecursionError): + raise bad("Некорректный JSON") from None + if not isinstance(body, dict): + raise bad("Ожидается JSON-объект") + if set(body) - set(fields): + raise bad("Лишние поля в запросе") + if set(fields) - set(body): + raise bad("Отсутствуют обязательные поля") + return body + + +def ensure_capacity() -> None: + if config.MAX_RSS_MB and rss_mb() > config.MAX_RSS_MB: + raise unavailable("Достигнут лимит памяти процесса, запись недоступна") + + +def bearer_token(request: Request) -> str: + scheme, _, value = request.headers.get("authorization", "").partition(" ") + token = value.strip() + if scheme.lower() != "bearer" or not token: + raise unauthorized() + return token + + +async def actor(request: Request) -> dict: + user = await sessions.resolve(bearer_token(request)) + if user is None: + raise unauthorized() + return user + + +def basic_credentials(request: Request) -> Tuple[str, str]: + scheme, _, value = request.headers.get("authorization", "").partition(" ") + if scheme.lower() != "basic" or not value.strip(): + raise unauthorized("Basic") + try: + decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8") + except (binascii.Error, ValueError, UnicodeDecodeError): + raise unauthorized("Basic") from None + username, separator, password = decoded.partition(":") + if not separator: + raise unauthorized("Basic") + return username, password + + +async def member_chat(user: dict, chat_id: str) -> dict: + cid = parse_uuid(chat_id) + if cid is None: + raise bad("chat_id должен быть UUID") + async with db.connection() as conn: + chat = await repo.chat_for_member(conn, cid, user["id"]) + if chat is None: + raise not_found() + return chat + + +def page_params(request: Request) -> Tuple[int, Optional[str]]: + query = request.query_params + limit = 50 + if "limit" in query: + if not re.fullmatch(r"[0-9]{1,3}", query["limit"]) or not 1 <= int(query["limit"]) <= 100: + raise bad("limit должен быть целым 1..100") + limit = int(query["limit"]) + cursor = query.get("cursor") + if cursor is not None and cursor == "": + raise bad("Некорректный cursor") + return limit, cursor + + +def keyset(scope: str, cursor: Optional[str]): + if cursor is None: + return None + try: + return decode_cursor(scope, cursor) + except BadCursor: + raise bad("Некорректный cursor") from None + + +def page(scope: str, items: List[dict], has_more: bool) -> JSONResponse: + next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more and items else None + return JSONResponse({"items": items, "next_cursor": next_cursor}) + + +@app.get("/health/live") +async def live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def ready(): + if not await db.ready(): + raise unavailable("База данных недоступна") + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +async def create_user(request: Request): + body = await read_json(request, ("username", "display_name", "password")) + if not isinstance(body["username"], str) or not USERNAME_RE.fullmatch(body["username"]): + raise bad("username должен соответствовать [a-z0-9_]{3,32}") + if not non_blank(body["display_name"], 100): + raise bad("display_name: 1..100 символов, не только пробелы") + password = body["password"] + if not isinstance(password, str) or not config.PASSWORD_MIN <= len(password) <= config.PASSWORD_MAX: + raise bad("password: %d..%d символов" % (config.PASSWORD_MIN, config.PASSWORD_MAX)) + ensure_capacity() + password_hash = await run_in_threadpool(passwords.hash_password, password) + async with db.connection() as conn: + user = await repo.create_user(conn, body["username"], body["display_name"], password_hash) + if user is None: + raise ApiError(409, "conflict", "username уже занят") + log.info("user_created id=%s", user["id"]) + return JSONResponse(user, status_code=201) + + +@app.post("/api/v1/auth/sessions", status_code=201) +async def login(request: Request): + if await request.body(): + raise bad("POST /auth/sessions не принимает тело запроса") + username, password = basic_credentials(request) + row = None + if USERNAME_RE.fullmatch(username) and config.PASSWORD_MIN <= len(password) <= config.PASSWORD_MAX: + async with db.connection() as conn: + row = await repo.credentials(conn, username) + stored = row["password_hash"] if row else passwords.DUMMY_HASH + matches = await run_in_threadpool(passwords.verify_password, stored, password) + if row is None or not matches: + log.info("login_failed username_known=%s", row is not None) + raise unauthorized("Basic") + user = repo.public_user(row) + token, expires_at = await sessions.create(user) + log.info("session_created user=%s", user["id"]) + return JSONResponse({"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": user}, status_code=201) + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def logout(request: Request): + token = bearer_token(request) + user = await sessions.resolve(token) + if user is None: + raise unauthorized() + await sessions.revoke(token) + log.info("session_revoked user=%s", user["id"]) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +async def me(request: Request): + return await actor(request) + + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(request: Request): + user = await actor(request) + body = await read_json(request, ("title", "member_ids")) + if not non_blank(body["title"], 100): + raise bad("title: 1..100 символов, не только пробелы") + raw_ids = body["member_ids"] + if not isinstance(raw_ids, list) or not 1 <= len(raw_ids) <= 100: + raise bad("member_ids: массив из 1..100 UUID") + ids: List[str] = [] + for value in raw_ids: + parsed = parse_uuid(value) + if parsed is None: + raise bad("member_ids содержит некорректный UUID") + ids.append(parsed) + if len(set(ids)) != len(ids): + raise bad("member_ids содержит дубликаты") + if user["id"] not in ids: + raise bad("Создатель должен входить в member_ids") + ensure_capacity() + + async def insert(conn): + return await repo.create_chat(conn, body["title"], ids) + + try: + chat = await db.in_transaction(insert) + except repo.UnknownMember: + raise bad("member_ids содержит неизвестного пользователя") from None + log.info("chat_created id=%s members=%d", chat["id"], len(ids)) + return JSONResponse(chat, status_code=201) + + +@app.get("/api/v1/chats") +async def list_chats(request: Request): + user = await actor(request) + limit, cursor = page_params(request) + scope = "chats:" + user["id"] + after = keyset(scope, cursor) + async with db.connection() as conn: + items, has_more = await repo.list_chats(conn, user["id"], limit, after) + return page(scope, items, has_more) + + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, request: Request): + return await member_chat(await actor(request), chat_id) + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message(chat_id: str, request: Request): + user = await actor(request) + cid = parse_uuid(chat_id) + if cid is None: + raise bad("chat_id должен быть UUID") + body = await read_json(request, ("text",)) + if not non_blank(body["text"], 4000): + raise bad("text: 1..4000 символов, не только пробелы") + ensure_capacity() + async with db.connection() as conn: + message = await repo.create_message(conn, cid, user["id"], body["text"]) + if message is None: + raise not_found() + return JSONResponse(message, status_code=201) + + +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages(chat_id: str, request: Request): + chat = await member_chat(await actor(request), chat_id) + limit, cursor = page_params(request) + scope = "messages:" + chat["id"] + after = keyset(scope, cursor) + async with db.connection() as conn: + items, has_more = await repo.list_messages(conn, chat["id"], limit, after) + return page(scope, items, has_more) + + +@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "PATCH", "DELETE"]) +async def fallback(request: Request): + raise not_found() diff --git a/app/passwords.py b/app/passwords.py new file mode 100644 index 00000000..b509e4a7 --- /dev/null +++ b/app/passwords.py @@ -0,0 +1,16 @@ +from argon2 import PasswordHasher +from argon2.exceptions import Argon2Error, VerifyMismatchError + +HASHER = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +DUMMY_HASH = HASHER.hash("there-is-no-such-user-password") + + +def hash_password(password: str) -> str: + return HASHER.hash(password) + + +def verify_password(stored: str, password: str) -> bool: + try: + return HASHER.verify(stored, password) + except (VerifyMismatchError, Argon2Error, ValueError): + return False diff --git a/app/repo.py b/app/repo.py new file mode 100644 index 00000000..0ade55aa --- /dev/null +++ b/app/repo.py @@ -0,0 +1,132 @@ +from typing import List, Optional, Tuple + +import psycopg + +from app.cursor import fmt + +MESSAGE_COLUMNS = "id, chat_id, sender_id, text, created_at" +CHAT_QUERY = ( + "SELECT c.id, c.title, c.created_at," + " ARRAY(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.user_id) AS member_ids" +) + + +class UnknownMember(Exception): + pass + + +def decoded(value) -> str: + return bytes(value).decode("utf-8") + + +def public_user(row) -> dict: + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": decoded(row["display_name"]), + "created_at": fmt(row["created_at"]), + } + + +def _chat(row) -> dict: + return { + "id": str(row["id"]), + "title": decoded(row["title"]), + "member_ids": [str(value) for value in row["member_ids"]], + "created_at": fmt(row["created_at"]), + } + + +def _message(row) -> dict: + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": decoded(row["text"]), + "created_at": fmt(row["created_at"]), + } + + +async def create_user(conn, username: str, display_name: str, password_hash: str) -> Optional[dict]: + try: + cur = await conn.execute( + "INSERT INTO users (id, username, display_name, password_hash, created_at)" + " VALUES (gen_random_uuid(), %s, %s, %s, clock_timestamp())" + " RETURNING id, username, display_name, created_at", + (username, display_name.encode("utf-8"), password_hash), + ) + except psycopg.errors.UniqueViolation: + return None + return public_user(await cur.fetchone()) + + +async def credentials(conn, username: str): + cur = await conn.execute( + "SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s", + (username,), + ) + return await cur.fetchone() + + +async def create_chat(conn, title: str, member_ids: List[str]) -> dict: + cur = await conn.execute( + "INSERT INTO chats (id, title, created_at)" + " VALUES (gen_random_uuid(), %s, clock_timestamp())" + " RETURNING id, title, created_at", + (title.encode("utf-8"),), + ) + chat = await cur.fetchone() + cur = await conn.execute( + "INSERT INTO chat_members (chat_id, user_id) SELECT %s, u.id FROM users u WHERE u.id = ANY(%s::uuid[])", + (chat["id"], member_ids), + ) + if cur.rowcount != len(member_ids): + raise UnknownMember() + chat["member_ids"] = list(member_ids) + return _chat(chat) + + +async def chat_for_member(conn, chat_id: str, user_id: str) -> Optional[dict]: + cur = await conn.execute( + CHAT_QUERY + " FROM chats c JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s WHERE c.id = %s", + (user_id, chat_id), + ) + row = await cur.fetchone() + return _chat(row) if row else None + + +async def list_chats(conn, user_id: str, limit: int, after) -> Tuple[List[dict], bool]: + ts, last_id = after if after else (None, None) + cur = await conn.execute( + CHAT_QUERY + + " FROM chats c JOIN chat_members m ON m.chat_id = c.id" + " WHERE m.user_id = %s AND (%s::timestamptz IS NULL OR (c.created_at, c.id) > (%s::timestamptz, %s::uuid))" + " ORDER BY c.created_at, c.id LIMIT %s", + (user_id, ts, ts, last_id, limit + 1), + ) + rows = await cur.fetchall() + return [_chat(row) for row in rows[:limit]], len(rows) > limit + + +async def create_message(conn, chat_id: str, sender_id: str, text: str) -> Optional[dict]: + cur = await conn.execute( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at)" + " SELECT gen_random_uuid(), %s, %s, %s, clock_timestamp()" + " WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s)" + " RETURNING " + MESSAGE_COLUMNS, + (chat_id, sender_id, text.encode("utf-8"), chat_id, sender_id), + ) + row = await cur.fetchone() + return _message(row) if row else None + + +async def list_messages(conn, chat_id: str, limit: int, after) -> Tuple[List[dict], bool]: + ts, last_id = after if after else (None, None) + cur = await conn.execute( + "SELECT " + MESSAGE_COLUMNS + " FROM messages" + " WHERE chat_id = %s AND (%s::timestamptz IS NULL OR (created_at, id) > (%s::timestamptz, %s::uuid))" + " ORDER BY created_at, id LIMIT %s", + (chat_id, ts, ts, last_id, limit + 1), + ) + rows = await cur.fetchall() + return [_message(row) for row in rows[:limit]], len(rows) > limit diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..4fae2bcd --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,139 @@ +import hashlib +import json +import logging +import secrets +from datetime import datetime, timedelta, timezone +from typing import Optional + +import valkey.asyncio as valkey + +from app import config +from app.cursor import fmt +from app.errors import unavailable + +log = logging.getLogger("messenger.sessions") + + +class SessionStore: + def __init__(self, db) -> None: + self.db = db + self.client = None + self.stats = {"hits": 0, "misses": 0, "errors": 0} + + async def open(self) -> None: + if not config.CACHE_URL: + log.info("session cache disabled: CACHE_URL is empty") + return + self.client = valkey.Valkey.from_url( + config.CACHE_URL, + socket_timeout=config.CACHE_TIMEOUT, + socket_connect_timeout=config.CACHE_TIMEOUT, + decode_responses=True, + ) + + async def close(self) -> None: + if self.client is not None: + await self.client.aclose() + self.client = None + + @staticmethod + def digest(token: str) -> bytes: + return hashlib.sha256(token.encode("utf-8")).digest() + + @staticmethod + def key(digest: bytes) -> str: + return "session:" + digest.hex() + + async def create(self, user: dict) -> tuple: + token = secrets.token_urlsafe(32) + digest = self.digest(token) + expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS) + async with self.db.connection() as conn: + await conn.execute( + "INSERT INTO sessions (token_hash, user_id, created_at, expires_at)" + " VALUES (%s, %s, clock_timestamp(), %s)", + (digest, user["id"], expires_at), + ) + await self._cache_put(digest, user, expires_at) + return token, fmt(expires_at) + + async def resolve(self, token: str) -> Optional[dict]: + digest = self.digest(token) + cached = await self._cache_get(digest) + if cached is not None: + self.stats["hits"] += 1 + return cached + self.stats["misses"] += 1 + async with self.db.connection() as conn: + cur = await conn.execute( + "SELECT u.id, u.username, u.display_name, u.created_at, 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()", + (digest,), + ) + row = await cur.fetchone() + if row is None: + return None + user = { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": fmt(row["created_at"]), + } + await self._cache_put(digest, user, row["expires_at"]) + return user + + async def revoke(self, token: str) -> None: + digest = self.digest(token) + await self._cache_drop(digest) + async with self.db.connection() as conn: + await conn.execute("DELETE FROM sessions WHERE token_hash = %s", (digest,)) + + async def sweep(self) -> int: + async with self.db.connection() as conn: + cur = await conn.execute("DELETE FROM sessions WHERE expires_at <= now()") + return cur.rowcount + + def _cache_ttl(self, expires_at: datetime) -> int: + remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds()) + return min(config.SESSION_CACHE_TTL_SECONDS, remaining) + + async def _cache_get(self, digest: bytes) -> Optional[dict]: + if self.client is None: + return None + try: + raw = await self.client.get(self.key(digest)) + except Exception: + self._cache_failed("get") + return None + if not raw: + return None + try: + return json.loads(raw) + except ValueError: + return None + + async def _cache_put(self, digest: bytes, user: dict, expires_at: datetime) -> None: + if self.client is None: + return + ttl = self._cache_ttl(expires_at) + if ttl <= 0: + return + try: + await self.client.set(self.key(digest), json.dumps(user), ex=ttl) + except Exception: + self._cache_failed("set") + + async def _cache_drop(self, digest: bytes) -> None: + if self.client is None: + return + try: + await self.client.delete(self.key(digest)) + except Exception: + self._cache_failed("delete") + raise unavailable("Кэш сессий недоступен, выход из сессии не подтверждён") from None + + def _cache_failed(self, operation: str) -> None: + self.stats["errors"] += 1 + if self.stats["errors"] % 50 == 1: + log.warning("session cache %s failed, falling back to postgres (errors=%d)", operation, self.stats["errors"]) diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..0574b5a2 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,101 @@ +name: mtusi-lab2 + +services: + postgres: + image: postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + POSTGRES_INITDB_ARGS: --data-checksums + command: + - postgres + - -c + - synchronous_commit=on + - -c + - shared_buffers=128MB + - -c + - work_mem=8MB + - -c + - max_connections=50 + - -c + - track_io_timing=on + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + start_period: 10s + restart: unless-stopped + + valkey: + image: valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 + command: + - valkey-server + - --save + - "" + - --appendonly + - "no" + - --maxmemory + - 128mb + - --maxmemory-policy + - allkeys-lru + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + start_period: 5s + restart: unless-stopped + + migrate: + build: + context: . + image: mtusi-messenger:lab2 + command: ["python", "scripts/migrate.py"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api: + build: + context: . + image: mtusi-messenger:lab2 + env_file: + - .env + environment: + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: + - database_url + - cache_url + ports: + - "127.0.0.1:8080:8080" + depends_on: + postgres: + condition: service_healthy + valkey: + condition: service_healthy + migrate: + condition: service_completed_successfully + restart: unless-stopped + +volumes: + pgdata: + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/evidence/dependency.txt b/evidence/dependency.txt new file mode 100644 index 00000000..d1c33172 --- /dev/null +++ b/evidence/dependency.txt @@ -0,0 +1,29 @@ +=== 1. Останавливаю кэш сессий (valkey) === + Container mtusi-lab2-valkey-1 Stopping + Container mtusi-lab2-valkey-1 Stopped +api Up 31 seconds (healthy) +postgres Up 37 seconds (unhealthy) +PASS login_and_read_work_without_cache +PASS unknown_token_is_still_rejected +PASS readiness_ignores_the_cache +3/3 checks passed + Container mtusi-lab2-valkey-1 Starting + Container mtusi-lab2-valkey-1 Started + +=== 2. Останавливаю PostgreSQL === + Container mtusi-lab2-postgres-1 Stopping + Container mtusi-lab2-postgres-1 Stopped +api Up 31 seconds (healthy) +valkey Up Less than a second (health: starting) +PASS readiness_reports_the_outage +PASS writes_fail_with_503 +PASS unknown_token_never_becomes_trusted +PASS login_fails_closed +4/4 checks passed + Container mtusi-lab2-postgres-1 Starting + Container mtusi-lab2-postgres-1 Started + +=== 3. Состояние восстановлено === +api Up 38 seconds (healthy) +postgres Up Less than a second (health: starting) +valkey Up 7 seconds (healthy) diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..0966d107 --- /dev/null +++ b/evidence/expiry.txt @@ -0,0 +1,5 @@ +Поднимаю отдельный API с SESSION_TTL_SECONDS=2 на порту 8081 (сеть mtusi-lab2_default) +PASS session_expires_after_ttl +PASS expired_session_cannot_write_or_logout +PASS expires_at_matches_configured_ttl +3/3 checks passed diff --git a/evidence/explain-10k.txt b/evidence/explain-10k.txt new file mode 100644 index 00000000..484df0a1 --- /dev/null +++ b/evidence/explain-10k.txt @@ -0,0 +1,88 @@ +sh student-tests/explain.sh +=== Стенд === +api mtusi-messenger:lab2 Up About a minute (healthy) +postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up About a minute (healthy) +valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up Less than a second (health: starting) + +=== Засев 10000 сообщений с неравномерными чатами === + seed_duration | seeded_rows | target_total | messages_total +-----------------+-------------+--------------+---------------- + 00:00:00.001309 | 0 | 10000 | 53764 +(1 row) + + +=== План запроса истории === + postgres_version +----------------------------------------------------------------------------------------------- + PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit +(1 row) + + messages_total | chats_with_messages | table_size | indexes_size +----------------+---------------------+------------+-------------- + 53764 | 14 | 5368 kB | 6320 kB +(1 row) + +--- распределение истории по чатам: 5 самых больших и 5 самых маленьких --- + chat_id | rows +--------------------------------------+------- + e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32 | 32944 + c995246c-35ed-422d-b097-c71f8829a0e0 | 20775 + d73dc509-7b93-4fc3-b6de-b7079bcc294f | 25 + 7485e75e-455e-4a7b-b164-3dbc84099fc0 | 5 + 63d536a7-78d4-4502-92fa-9bbac4e7c5c4 | 3 +(5 rows) + + chat_id | rows +--------------------------------------+------ + 143b0ced-4c1a-4742-a4ad-02c4b606ba0f | 1 + b4faa937-91fc-4f41-b25e-f3f692878c1f | 1 + 84d473db-544b-4a24-995b-43a4852c68ab | 1 + 574fc146-1610-484a-85a9-cb084afa7d28 | 1 + 836ed5bf-8ccb-419e-96d5-2c4fe7342292 | 1 +(5 rows) + +--- A. keyset, первая страница самого большого чата --- + QUERY PLAN +---------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..6.89 rows=50 width=67) (actual time=0.006..0.016 rows=50 loops=1) + Buffers: shared hit=24 + -> Index Scan using messages_history_idx on messages (cost=0.41..4269.16 rows=32968 width=67) (actual time=0.006..0.014 rows=50 loops=1) + Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) + Buffers: shared hit=24 + Planning: + Buffers: shared hit=6 + Planning Time: 0.046 ms + Execution Time: 0.026 ms +(9 rows) + +--- B. keyset, страница на глубине 90% истории (так работает cursor API) --- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.41..11.51 rows=50 width=67) (actual time=0.017..0.025 rows=50 loops=1) + Buffers: shared hit=53 + -> Index Scan using messages_history_idx on messages (cost=0.41..3272.65 rows=14746 width=67) (actual time=0.017..0.023 rows=50 loops=1) + Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))) + Buffers: shared hit=53 + Planning Time: 0.027 ms + Execution Time: 0.063 ms +(7 rows) + +--- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) --- + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=3839.41..3845.89 rows=50 width=67) (actual time=4.152..4.159 rows=50 loops=1) + Buffers: shared hit=29813 + -> Index Scan using messages_history_idx on messages (cost=0.41..4269.16 rows=32968 width=67) (actual time=0.008..3.474 rows=29699 loops=1) + Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) + Buffers: shared hit=29813 + Planning Time: 0.018 ms + Execution Time: 4.172 ms +(7 rows) + +--- индексы таблицы messages --- + index | size | scans +----------------------+---------+------- + messages_history_idx | 4072 kB | 12 + messages_pkey | 2248 kB | 0 +(2 rows) + diff --git a/evidence/git-hygiene.txt b/evidence/git-hygiene.txt new file mode 100644 index 00000000..efee0f42 --- /dev/null +++ b/evidence/git-hygiene.txt @@ -0,0 +1,32 @@ + M .env.example + M Makefile + M REPORT.md +?? .github/workflows/app.yml +?? Dockerfile +?? app/ +?? compose.yaml +?? evidence/dependency.txt +?? evidence/expiry.txt +?? evidence/explain-10k.txt +?? evidence/git-hygiene.txt +?? evidence/level4-tests.txt +?? evidence/load-cache.json +?? evidence/load-nocache.json +?? evidence/load.txt +?? evidence/migrations.txt +?? evidence/outages.txt +?? evidence/persistence.txt +?? evidence/smoke.txt +?? evidence/stand.txt +?? evidence/track2/ +?? migrations/ +?? requirements.txt +?? scripts/bootstrap.sh +?? scripts/migrate.py +?? scripts/restart.sh +?? student-tests/ +--- правила игнорирования --- +.gitignore:2:.env .env +.gitignore:5:secrets/ secrets/database_url +.gitignore:5:secrets/ secrets/postgres_password +.gitignore:15:backups/ backups diff --git a/evidence/level4-tests.txt b/evidence/level4-tests.txt new file mode 100644 index 00000000..55078387 --- /dev/null +++ b/evidence/level4-tests.txt @@ -0,0 +1,24 @@ +PASS wrong_password_gives_same_401 +PASS basic_is_rejected_on_business_endpoints +PASS x_user_id_does_not_authenticate +PASS logout_revokes_only_its_own_token +PASS token_is_opaque_and_unique +PASS short_password_is_rejected +PASS password_is_never_returned +PASS login_rejects_a_request_body +PASS broken_utf8_credentials_are_rejected +9/9 checks passed + +PASS duplicate_username_race_creates_one_user +PASS unknown_member_rolls_chat_back +PASS keyset_pagination_is_complete +PASS cursor_is_bound_to_its_chat +PASS limit_bounds_are_enforced +PASS sql_injection_is_not_executed +PASS malformed_requests_are_rejected +PASS nul_and_unicode_text_round_trips +PASS text_length_limit_counts_code_points +PASS unicode_blanks_are_rejected +PASS broken_json_does_not_break_the_api +PASS content_type_is_required +12/12 checks passed diff --git a/evidence/load-cache.json b/evidence/load-cache.json new file mode 100644 index 00000000..e8babd6c --- /dev/null +++ b/evidence/load-cache.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.012, + "concurrency": 4, + "successful_requests": 32944, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 1097.706, + "successful_latency_ms": { + "p50": 3.248, + "p95": 6.063, + "p99": 10.603 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-nocache.json b/evidence/load-nocache.json new file mode 100644 index 00000000..376f4e77 --- /dev/null +++ b/evidence/load-nocache.json @@ -0,0 +1,17 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.033, + "concurrency": 4, + "successful_requests": 20775, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 691.741, + "successful_latency_ms": { + "p50": 5.447, + "p95": 8.152, + "p99": 11.778 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load.txt b/evidence/load.txt new file mode 100644 index 00000000..a0ad4007 --- /dev/null +++ b/evidence/load.txt @@ -0,0 +1,34 @@ +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.012, + "concurrency": 4, + "successful_requests": 32944, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 1097.706, + "successful_latency_ms": { + "p50": 3.248, + "p95": 6.063, + "p99": 10.603 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} +{ + "lab": 2, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.033, + "concurrency": 4, + "successful_requests": 20775, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 691.741, + "successful_latency_ms": { + "p50": 5.447, + "p95": 8.152, + "p99": 11.778 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 00000000..f1a3e852 --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1,35 @@ +--- первый запуск (из логов сервиса migrate) --- +migrate-1 | apply 0001_init +migrate-1 | migrations complete: 1 file(s) +--- повторный запуск --- + Container mtusi-lab2-postgres-1 Running + Container mtusi-lab2-postgres-1 Waiting + Container mtusi-lab2-postgres-1 Healthy + Container mtusi-lab2-migrate-run-d04acc691283 Creating + Container mtusi-lab2-migrate-run-d04acc691283 Created +skip 0001_init +migrations complete: 1 file(s) +--- схема --- + Table "public.messages" + Column | Type | Collation | Nullable | Default | Storage | Compression | Stats target | Description +------------+--------------------------+-----------+----------+---------+----------+-------------+--------------+------------- + id | uuid | | not null | | plain | | | + chat_id | uuid | | not null | | plain | | | + sender_id | uuid | | not null | | plain | | | + text | bytea | | not null | | extended | | | + created_at | timestamp with time zone | | not null | | plain | | | +Indexes: + "messages_pkey" PRIMARY KEY, btree (id) + "messages_history_idx" btree (chat_id, created_at, id) +Check constraints: + "messages_text_size" CHECK (octet_length(text) >= 1 AND octet_length(text) <= 16000) +Foreign-key constraints: + "messages_chat_id_fkey" FOREIGN KEY (chat_id) REFERENCES chats(id) ON DELETE CASCADE + "messages_sender_id_fkey" FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE RESTRICT +Access method: heap + + version | checksum | applied_at +-----------+------------------------------------------------------------------+------------------------------- + 0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-19 15:50:30.673311+00 +(1 row) + diff --git a/evidence/outages.txt b/evidence/outages.txt new file mode 100644 index 00000000..1058d561 --- /dev/null +++ b/evidence/outages.txt @@ -0,0 +1,5 @@ +PASS revoked_session_stays_revoked_after_cache_restart +PASS logout_is_not_confirmed_while_cache_is_down +PASS cached_sessions_do_not_cross_users +PASS hung_database_fails_fast +4/4 checks passed diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..99d3c113 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,18 @@ +--- состояние контейнеров до рестарта --- +api Up 38 seconds (healthy) +postgres Up Less than a second (health: starting) +valkey Up 7 seconds (healthy) +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. +--- состояние контейнеров после рестарта --- +api Up Less than a second (health: starting) +postgres Up Less than a second (health: starting) +valkey Up Less than a second (health: starting) +--- логи postgres о перезапуске --- +postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit +postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432 +postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: listening on IPv6 address "::", port 5432 +postgres-1 | 2026-10-19 15:51:09.946 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432" +postgres-1 | 2026-10-19 15:51:09.949 UTC [29] LOG: database system was shut down at 2026-10-19 15:51:09 UTC +postgres-1 | 2026-10-19 15:51:09.951 UTC [1] LOG: database system is ready to accept connections diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..404a2c60 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/stand.txt b/evidence/stand.txt new file mode 100644 index 00000000..09af0175 --- /dev/null +++ b/evidence/stand.txt @@ -0,0 +1,8 @@ +Darwin arm64 +Docker version 29.7.2, build a7dcaa6 +Docker Compose version v5.5.1 +api mtusi-messenger:lab2 Up 1 second (health: starting) +postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up 7 seconds (healthy) +valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up 7 seconds (healthy) +PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit +Valkey server v=8.1.10 sha=00000000:1 malloc=jemalloc-5.3.0 bits=64 build=2cb63ac0e4567989 diff --git a/evidence/track2/run.txt b/evidence/track2/run.txt new file mode 100644 index 00000000..4f2ca729 --- /dev/null +++ b/evidence/track2/run.txt @@ -0,0 +1,227 @@ +=== Стенд и версии === +api mtusi-messenger:lab2 Up About a minute (healthy) +postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 Up About a minute (healthy) +valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up Less than a second (health: starting) +Darwin arm64 +Docker version 29.7.2, build a7dcaa6 + +=== 1. Засев истории: цель 120000 сообщений, чаты неравномерные === + seed_duration | seeded_rows | target_total | messages_total +----------------+-------------+--------------+---------------- + 00:00:00.63315 | 66236 | 120000 | 120000 +(1 row) + + +=== 2. Сравнение индексов и цены записи (каждый вариант в откатываемой транзакции) === + messages_total +---------------- + 120000 +(1 row) + +############ Вариант A: messages_history_idx (chat_id, created_at, id) ############ + index_size +------------ + 10 MB +(1 row) + + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..37.36 rows=50 width=89) (actual time=0.015..0.025 rows=50 loops=1) + Buffers: shared hit=53 + -> Index Scan using messages_history_idx on messages (cost=0.42..5594.06 rows=7570 width=89) (actual time=0.014..0.022 rows=50 loops=1) + Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))) + Buffers: shared hit=53 + Planning: + Buffers: shared hit=17 + Planning Time: 0.098 ms + Execution Time: 0.048 ms +(9 rows) + + pages_measured +---------------- + 5000 +(1 row) + + hundred_pages_duration +------------------------ + 00:00:00.001121 +(1 row) + + insert_10k_duration +--------------------- + 00:00:00.083689 +(1 row) + +############ Вариант B: только (chat_id) ############ + index_size +------------ + 848 kB +(1 row) + + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------ + Limit (cost=3134.85..3134.97 rows=50 width=89) (actual time=1.691..1.695 rows=50 loops=1) + Buffers: shared hit=411 read=30 + I/O Timings: shared read=0.076 + -> Sort (cost=3134.85..3153.65 rows=7522 width=89) (actual time=1.691..1.692 rows=50 loops=1) + Sort Key: created_at, id + Sort Method: top-N heapsort Memory: 33kB + Buffers: shared hit=411 read=30 + I/O Timings: shared read=0.076 + -> Bitmap Heap Scan on messages (cost=368.71..2884.97 rows=7522 width=89) (actual time=1.378..1.560 rows=3294 loops=1) + Recheck Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) + Filter: (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid)) + Rows Removed by Filter: 29650 + Heap Blocks: exact=411 + Buffers: shared hit=411 read=30 + I/O Timings: shared read=0.076 + -> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..366.83 rows=32872 width=0) (actual time=0.333..0.333 rows=32944 loops=1) + Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) + Buffers: shared read=30 + I/O Timings: shared read=0.076 + Planning: + Buffers: shared hit=26 read=1 + I/O Timings: shared read=0.009 + Planning Time: 0.130 ms + Execution Time: 1.728 ms +(24 rows) + + pages_measured +---------------- + 5000 +(1 row) + + hundred_pages_duration +------------------------ + 00:00:02.186353 +(1 row) + + insert_10k_duration +--------------------- + 00:00:00.078473 +(1 row) + +############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############ + index_size +------------ + 14 MB +(1 row) + + QUERY PLAN +------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + Limit (cost=0.42..34.19 rows=50 width=89) (actual time=0.017..0.021 rows=50 loops=1) + Buffers: shared hit=1 read=3 + I/O Timings: shared read=0.006 + -> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..5110.68 rows=7565 width=89) (actual time=0.016..0.019 rows=50 loops=1) + Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))) + Heap Fetches: 0 + Buffers: shared hit=1 read=3 + I/O Timings: shared read=0.006 + Planning: + Buffers: shared hit=28 read=1 + I/O Timings: shared read=0.005 + Planning Time: 0.184 ms + Execution Time: 0.031 ms +(13 rows) + + pages_measured +---------------- + 5000 +(1 row) + + hundred_pages_duration +------------------------ + 00:00:00.000744 +(1 row) + + insert_10k_duration +--------------------- + 00:00:00.084611 +(1 row) + +############ Схема после эксперимента (ROLLBACK вернул индексы) ############ + indexname +---------------------- + messages_history_idx + messages_pkey +(2 rows) + + +Самый большой чат: e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32 + +=== 3. Состояние источника до бэкапа === + relation | rows +--------------+-------- + chat_members | 1036 + chats | 68 + messages | 120000 + sessions | 43 + users | 74 +(5 rows) + + big_chat_rows | big_chat_md5 +---------------+---------------------------------- + 32944 | 6c6725a76404fbb0b8b5b509707e30b5 +(1 row) + + id | created_at | text +--------------------------------------+-------------------------------+---------- + 8ecedfe9-56ef-410d-98b3-e3fc414128d9 | 2026-10-19 15:51:11.010631+00 | load-1-0 + 424bfa46-6e49-4b60-8ca3-ac3c3f9be02a | 2026-10-19 15:51:11.011234+00 | load-3-0 + 05b0e1a2-5862-461a-b8aa-1f91f647e18d | 2026-10-19 15:51:11.01201+00 | load-2-0 +(3 rows) + + marker_rows +------------- + 0 +(1 row) + + +=== 4. Бэкап pg_dump -Fc === +backup_seconds=0.761 +dump_size=5.6M + +=== 5. Запись после бэкапа: граница потери данных === +в источнике маркеров: 1 + +=== 6. Новое хранилище: отдельный контейнер и отдельный том === +/var/run/postgresql:5432 - accepting connections + +=== 7. Восстановление в новое хранилище === +restore_seconds=0.370 + +=== 8. Сверка восстановленной копии === + relation | rows +--------------+-------- + chat_members | 1036 + chats | 68 + messages | 120000 + sessions | 43 + users | 74 +(5 rows) + + big_chat_rows | big_chat_md5 +---------------+---------------------------------- + 32944 | 6c6725a76404fbb0b8b5b509707e30b5 +(1 row) + + id | created_at | text +--------------------------------------+-------------------------------+---------- + 8ecedfe9-56ef-410d-98b3-e3fc414128d9 | 2026-10-19 15:51:11.010631+00 | load-1-0 + 424bfa46-6e49-4b60-8ca3-ac3c3f9be02a | 2026-10-19 15:51:11.011234+00 | load-3-0 + 05b0e1a2-5862-461a-b8aa-1f91f647e18d | 2026-10-19 15:51:11.01201+00 | load-2-0 +(3 rows) + + marker_rows +------------- + 0 +(1 row) + + +=== 9. Итог === +backup_seconds=0.761 restore_seconds=0.370 +messages_source_without_marker=120000 messages_restored=120000 +big_chat_md5_source=6c6725a76404fbb0b8b5b509707e30b5 +big_chat_md5_restored=6c6725a76404fbb0b8b5b509707e30b5 +RESULT: восстановленная копия совпадает с источником на момент бэкапа +маркеров после бэкапа в восстановленной копии: 0 (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует) diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..4de361a9 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,46 @@ +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL UNIQUE + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name bytea NOT NULL + CONSTRAINT users_display_name_size CHECK (octet_length(display_name) BETWEEN 1 AND 400), + password_hash text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title bytea NOT NULL + CONSTRAINT chats_title_size CHECK (octet_length(title) BETWEEN 1 AND 400), + created_at timestamptz NOT NULL +); + +CREATE INDEX chats_created_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + text bytea NOT NULL + CONSTRAINT messages_text_size CHECK (octet_length(text) BETWEEN 1 AND 16000), + created_at timestamptz NOT NULL +); + +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL, + expires_at timestamptz NOT NULL +); + +CREATE INDEX sessions_expires_idx ON sessions (expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..3801ada5 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,22 @@ +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 +httptools==0.9.0 +idna==3.20 +psycopg==3.3.6 +psycopg-binary==3.3.6 +psycopg-pool==3.3.3 +pycparser==3.11 +pydantic==2.14.1 +pydantic-core==2.50.1 +starlette==0.41.3 +typing-extensions==4.16.0 +typing-inspection==0.4.4 +uvicorn==0.34.0 +uvloop==0.23.0 +valkey==6.2.0 diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh new file mode 100755 index 00000000..ea4db66d --- /dev/null +++ b/scripts/bootstrap.sh @@ -0,0 +1,15 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +[ -f .env ] || cp .env.example .env +mkdir -p secrets +if [ ! -f secrets/postgres_password ]; then + python3 -c "import secrets; print(secrets.token_urlsafe(24))" > secrets/postgres_password +fi +password=$(cat secrets/postgres_password) +printf 'postgresql://messenger:%s@postgres:5432/messenger\n' "$password" > secrets/database_url +printf 'valkey://valkey:6379/0\n' > secrets/cache_url +chmod 700 secrets +chmod 600 secrets/postgres_password secrets/database_url secrets/cache_url +echo "ready: .env and secrets/ created locally; they stay out of Git" diff --git a/scripts/migrate.py b/scripts/migrate.py new file mode 100644 index 00000000..c8a1f86a --- /dev/null +++ b/scripts/migrate.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +"""Versioned SQL migrations: applied once, checksum-verified, safe to re-run.""" +import hashlib +import os +import pathlib +import sys + +import psycopg + +ROOT = pathlib.Path(__file__).resolve().parents[1] +MIGRATIONS = ROOT / "migrations" +LOCK_ID = 2026_0002 + + +def database_url() -> str: + path = os.environ.get("DATABASE_URL_FILE") + if path: + return pathlib.Path(path).read_text(encoding="utf-8").strip() + url = os.environ.get("DATABASE_URL", "").strip() + if not url: + sys.exit("DATABASE_URL or DATABASE_URL_FILE is required") + return url + + +def main() -> None: + files = sorted(MIGRATIONS.glob("*.sql")) + if not files: + sys.exit("no migration files found in %s" % MIGRATIONS) + with psycopg.connect(database_url(), autocommit=True, connect_timeout=10) as conn: + conn.execute( + "CREATE TABLE IF NOT EXISTS schema_migrations (" + " version text PRIMARY KEY," + " checksum text NOT NULL," + " applied_at timestamptz NOT NULL DEFAULT now())" + ) + conn.execute("SELECT pg_advisory_lock(%s)", (LOCK_ID,)) + rows = conn.execute("SELECT version, checksum FROM schema_migrations").fetchall() + applied = {row[0]: row[1] for row in rows} + for path in files: + version = path.stem + body = path.read_text(encoding="utf-8") + checksum = hashlib.sha256(body.encode("utf-8")).hexdigest() + if version in applied: + if applied[version] != checksum: + sys.exit("migration %s changed after it was applied" % version) + print("skip %s" % version) + continue + with conn.transaction(): + conn.execute(body) + conn.execute( + "INSERT INTO schema_migrations (version, checksum) VALUES (%s, %s)", + (version, checksum), + ) + print("apply %s" % version) + conn.execute("SELECT pg_advisory_unlock(%s)", (LOCK_ID,)) + print("migrations complete: %d file(s)" % len(files)) + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..b74410ba --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +docker compose --env-file .env restart postgres valkey api diff --git a/student-tests/common.py b/student-tests/common.py new file mode 100644 index 00000000..fe68ef4a --- /dev/null +++ b/student-tests/common.py @@ -0,0 +1,111 @@ +"""Shared HTTP helpers for the student checks; stdlib only, Python 3.9+.""" +import argparse +import base64 +import json +import os +import sys +import urllib.error +import urllib.request +import uuid + +DEFAULT_BASE = os.environ.get("BASE_URL", "http://localhost:8080") + + +class Failed(AssertionError): + pass + + +def expect(condition, message): + if not condition: + raise Failed(message) + + +def call(base, method, path, body=None, token=None, headers=None, timeout=10, raw=None, content_type=None): + sent = {"Accept": "application/json"} + data = raw + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + sent["Content-Type"] = "application/json" + if content_type is not None: + sent["Content-Type"] = content_type + if token: + sent["Authorization"] = "Bearer " + token + sent.update(headers or {}) + request = urllib.request.Request(base + path, data=data, headers=sent, method=method) + try: + response = urllib.request.urlopen(request, timeout=timeout) + except urllib.error.HTTPError as error: + response = error + except (urllib.error.URLError, TimeoutError, OSError) as exc: + raise Failed("%s %s: нет соединения (%s)" % (method, path, type(exc).__name__)) from None + with response: + raw = response.read() + payload = None + if raw: + try: + payload = json.loads(raw) + except ValueError: + payload = None + return {"status": response.code, "headers": response.headers, "json": payload} + + +def credentials(label="check"): + return { + "username": "u_%s_%s" % (label, uuid.uuid4().hex[:10]), + "display_name": "Проверка " + label, + "password": "T3st-" + uuid.uuid4().hex, + } + + +def basic(username, password): + return "Basic " + base64.b64encode(("%s:%s" % (username, password)).encode("utf-8")).decode() + + +def register(base, label="check"): + body = credentials(label) + result = call(base, "POST", "/api/v1/users", body=body) + expect(result["status"] == 201, "регистрация вернула %s" % result["status"]) + return {"registration": body, "user": result["json"], "id": result["json"]["id"]} + + +def login(base, actor): + result = call( + base, + "POST", + "/api/v1/auth/sessions", + headers={"Authorization": basic(actor["registration"]["username"], actor["registration"]["password"])}, + ) + expect(result["status"] == 201, "вход вернул %s" % result["status"]) + actor["token"] = result["json"]["token"] + actor["session"] = result["json"] + return actor + + +def member(base, label="check"): + return login(base, register(base, label)) + + +def chat_with(base, owner, *others): + members = [owner["id"]] + [other["id"] for other in others] + result = call(base, "POST", "/api/v1/chats", body={"title": "Проверка " + uuid.uuid4().hex[:8], "member_ids": members}, token=owner["token"]) + expect(result["status"] == 201, "создание чата вернуло %s" % result["status"]) + return result["json"] + + +def arguments(description): + parser = argparse.ArgumentParser(description=description) + parser.add_argument("--base-url", default=DEFAULT_BASE) + return parser.parse_args() + + +def run(tests, base): + failures = [] + for test in tests: + try: + test(base) + print("PASS %s" % test.__name__) + except AssertionError as exc: + failures.append(test.__name__) + print("FAIL %s: %s" % (test.__name__, exc)) + print("%d/%d checks passed" % (len(tests) - len(failures), len(tests))) + sys.exit(1 if failures else 0) diff --git a/student-tests/dependency.sh b/student-tests/dependency.sh new file mode 100755 index 00000000..aebe6cfa --- /dev/null +++ b/student-tests/dependency.sh @@ -0,0 +1,39 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +COMPOSE="docker compose --env-file .env" + +wait_ready() { + i=0 + while [ "$i" -lt 60 ]; do + if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then return 0; fi + i=$((i + 1)) + sleep 1 + done + echo "API не стал ready" >&2 + return 1 +} + +restore() { + $COMPOSE start valkey postgres >/dev/null 2>&1 || true +} +trap restore EXIT + +echo "=== 1. Останавливаю кэш сессий (valkey) ===" +$COMPOSE stop valkey +$COMPOSE ps --format '{{.Service}} {{.Status}}' +python3 student-tests/test_without_cache.py --base-url http://localhost:8080 +$COMPOSE start valkey +wait_ready + +echo +echo "=== 2. Останавливаю PostgreSQL ===" +$COMPOSE stop postgres +$COMPOSE ps --format '{{.Service}} {{.Status}}' +python3 student-tests/test_without_db.py --base-url http://localhost:8080 +$COMPOSE start postgres +wait_ready +echo +echo "=== 3. Состояние восстановлено ===" +$COMPOSE ps --format '{{.Service}} {{.Status}}' diff --git a/student-tests/evidence.sh b/student-tests/evidence.sh new file mode 100755 index 00000000..1ab3112a --- /dev/null +++ b/student-tests/evidence.sh @@ -0,0 +1,126 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +OUT=${OUT:-evidence} +TOTAL=${TOTAL:-120000} +COMPOSE="docker compose --env-file .env" + +mkdir -p "$OUT" "$OUT/track2" + +step() { + printf '\n######## %s ########\n' "$1" +} + +wait_ready() { + i=0 + while [ "$i" -lt 90 ]; do + if curl -fsS http://localhost:8080/health/ready >/dev/null 2>&1; then return 0; fi + i=$((i + 1)) + sleep 1 + done + echo "API не стал ready" >&2 + return 1 +} + +step "0. Чистый стенд: удаляю том базы и поднимаю заново" +$COMPOSE down -v +$COMPOSE up -d --build +wait_ready +{ + uname -sm + docker --version + $COMPOSE version + $COMPOSE ps --format '{{.Service}} {{.Image}} {{.Status}}' + $COMPOSE exec -T postgres psql -U messenger -d messenger -t -A -c 'select version()' + $COMPOSE exec -T valkey valkey-server --version +} > "$OUT/stand.txt" 2>&1 +cat "$OUT/stand.txt" + +step "1. Миграции с нуля и повторный запуск" +{ + echo '--- первый запуск (из логов сервиса migrate) ---' + $COMPOSE logs migrate --tail=10 + echo '--- повторный запуск ---' + $COMPOSE run --rm migrate + echo '--- схема ---' + $COMPOSE exec -T postgres psql -U messenger -d messenger -X -c '\d+ messages' + $COMPOSE exec -T postgres psql -U messenger -d messenger -X -c 'table schema_migrations' +} > "$OUT/migrations.txt" 2>&1 +tail -5 "$OUT/migrations.txt" + +step "2. Публичный smoke" +make test > "$OUT/smoke.txt" 2>&1 +tail -1 "$OUT/smoke.txt" + +step "3. Свои проверки уровня 4" +{ + python3 student-tests/test_auth_sessions.py + echo + python3 student-tests/test_storage_rules.py +} > "$OUT/level4-tests.txt" 2>&1 +grep 'checks passed' "$OUT/level4-tests.txt" + +step "4. Истечение сессии при коротком TTL" +sh student-tests/expiry.sh > "$OUT/expiry.txt" 2>&1 +grep 'checks passed' "$OUT/expiry.txt" + +step "5. Отзыв сессии против кэша и зависшая БД" +python3 student-tests/test_outages.py > "$OUT/outages.txt" 2>&1 +grep 'checks passed' "$OUT/outages.txt" + +step "6. Отказ Valkey, затем отказ PostgreSQL" +sh student-tests/dependency.sh > "$OUT/dependency.txt" 2>&1 +grep 'checks passed' "$OUT/dependency.txt" + +step "7. Рестарт API и всех хранилищ" +{ + echo '--- состояние контейнеров до рестарта ---' + $COMPOSE ps --format '{{.Service}} {{.Status}}' +} > "$OUT/persistence.txt" 2>&1 +make test-persistence ACTION_SCRIPT=scripts/restart.sh >> "$OUT/persistence.txt" 2>&1 +{ + echo '--- состояние контейнеров после рестарта ---' + $COMPOSE ps --format '{{.Service}} {{.Status}}' + echo '--- логи postgres о перезапуске ---' + $COMPOSE logs postgres --tail=6 +} >> "$OUT/persistence.txt" 2>&1 +grep 'PASS\|FAIL' "$OUT/persistence.txt" + +step "8. Нагрузка с кэшем сессий и без него" +python3 tests/load.py --duration 30 --concurrency 4 --output "$OUT/load-cache.json" > "$OUT/load.txt" 2>&1 +$COMPOSE stop valkey +python3 tests/load.py --duration 30 --concurrency 4 --output "$OUT/load-nocache.json" >> "$OUT/load.txt" 2>&1 +$COMPOSE start valkey +wait_ready +python3 - "$OUT" <<'PYEOF' +import json +import sys + +out = sys.argv[1] +for name in ("load-cache", "load-nocache"): + with open(out + "/" + name + ".json") as handle: + data = json.load(handle) + print(name, data["successful_requests"], "ok,", data["failed_requests"], "fail,", + data["successful_rps"], "rps,", data["successful_latency_ms"]) +PYEOF + +step "9. План запроса истории" +make explain > "$OUT/explain-10k.txt" 2>&1 +grep -E 'messages_total|Execution Time' "$OUT/explain-10k.txt" | head -8 + +step "10. Трек 5: индексы и восстановление" +TOTAL="$TOTAL" sh student-tests/track2.sh > "$OUT/track2/run.txt" 2>&1 +grep -E 'backup_seconds|restore_seconds|RESULT|маркеров' "$OUT/track2/run.txt" + +step "11. Гигиена репозитория" +{ + git status --porcelain + echo '--- правила игнорирования ---' + git check-ignore -v .env secrets/database_url secrets/postgres_password backups || true +} > "$OUT/git-hygiene.txt" 2>&1 +cat "$OUT/git-hygiene.txt" + +step "Готово" +echo "Файлы доказательств: $OUT" +ls -1 "$OUT" "$OUT/track2" diff --git a/student-tests/expiry.sh b/student-tests/expiry.sh new file mode 100755 index 00000000..7226bd1d --- /dev/null +++ b/student-tests/expiry.sh @@ -0,0 +1,35 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +NAME=mtusi-lab2-api-shortttl +PORT=${PORT:-8081} +NETWORK=$(docker compose --env-file .env ps --format '{{.Name}}' api | head -1 | xargs -I{} docker inspect {} --format '{{range $k,$v := .NetworkSettings.Networks}}{{$k}}{{end}}') + +cleanup() { + docker rm -f "$NAME" >/dev/null 2>&1 || true +} +trap cleanup EXIT +cleanup + +echo "Поднимаю отдельный API с SESSION_TTL_SECONDS=2 на порту $PORT (сеть $NETWORK)" +docker run -d --name "$NAME" --network "$NETWORK" \ + -p 127.0.0.1:"$PORT":8080 \ + -v "$PWD/secrets/database_url:/run/secrets/database_url:ro" \ + -v "$PWD/secrets/cache_url:/run/secrets/cache_url:ro" \ + -e DATABASE_URL_FILE=/run/secrets/database_url \ + -e CACHE_URL_FILE=/run/secrets/cache_url \ + -e SESSION_TTL_SECONDS=2 \ + -e SESSION_CACHE_TTL_SECONDS=2 \ + -e SESSION_SWEEP_SECONDS=5 \ + mtusi-messenger:lab2 >/dev/null + +i=0 +while [ "$i" -lt 60 ]; do + if curl -fsS "http://localhost:$PORT/health/ready" >/dev/null 2>&1; then break; fi + i=$((i + 1)) + sleep 1 +done +curl -fsS "http://localhost:$PORT/health/ready" >/dev/null + +python3 student-tests/test_expiry.py --base-url "http://localhost:$PORT" diff --git a/student-tests/explain.sh b/student-tests/explain.sh new file mode 100755 index 00000000..26562f0e --- /dev/null +++ b/student-tests/explain.sh @@ -0,0 +1,15 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +TOTAL=${TOTAL:-10000} +PSQL="docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -X -q" + +echo "=== Стенд ===" +docker compose --env-file .env ps --format '{{.Service}} {{.Image}} {{.Status}}' +echo +echo "=== Засев $TOTAL сообщений с неравномерными чатами ===" +$PSQL -v total="$TOTAL" -f - < student-tests/seed.sql +echo +echo "=== План запроса истории ===" +$PSQL -f - < student-tests/explain.sql diff --git a/student-tests/explain.sql b/student-tests/explain.sql new file mode 100644 index 00000000..130dd9e9 --- /dev/null +++ b/student-tests/explain.sql @@ -0,0 +1,51 @@ +\set ON_ERROR_STOP on + +SELECT version() AS postgres_version; + +SELECT count(*) AS messages_total, + count(DISTINCT chat_id) AS chats_with_messages, + pg_size_pretty(pg_table_size('messages')) AS table_size, + pg_size_pretty(pg_indexes_size('messages')) AS indexes_size +FROM messages; + +\echo '--- распределение истории по чатам: 5 самых больших и 5 самых маленьких ---' +SELECT chat_id, count(*) AS rows FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 5; +SELECT chat_id, count(*) AS rows FROM messages GROUP BY chat_id ORDER BY count(*) ASC LIMIT 5; + +SELECT chat_id AS big_chat, count(*) AS big_rows +FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1 \gset + +SELECT created_at AS cur_ts, id AS cur_id +FROM messages +WHERE chat_id = :'big_chat' +ORDER BY created_at, id +OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 1 \gset + +\echo '--- A. keyset, первая страница самого большого чата ---' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = :'big_chat' +ORDER BY created_at, id +LIMIT 50; + +\echo '--- B. keyset, страница на глубине 90% истории (так работает cursor API) ---' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = :'big_chat' + AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id +LIMIT 50; + +\echo '--- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) ---' +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = :'big_chat' +ORDER BY created_at, id +OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 50; + +\echo '--- индексы таблицы messages ---' +SELECT indexrelname AS index, pg_size_pretty(pg_relation_size(indexrelid)) AS size, idx_scan AS scans +FROM pg_stat_user_indexes WHERE relname = 'messages' ORDER BY indexrelname; diff --git a/student-tests/seed.sql b/student-tests/seed.sql new file mode 100644 index 00000000..927d492c --- /dev/null +++ b/student-tests/seed.sql @@ -0,0 +1,37 @@ +\set ON_ERROR_STOP on + +INSERT INTO users (id, username, display_name, password_hash, created_at) +SELECT gen_random_uuid(), 'load_' || g, convert_to('Нагрузка ' || g, 'UTF8'), 'seed-row-cannot-log-in', now() +FROM generate_series(1, 20) AS g +ON CONFLICT (username) DO NOTHING; + +INSERT INTO chats (id, title, created_at) +SELECT gen_random_uuid(), convert_to('load chat ' || g, 'UTF8'), now() +FROM generate_series(1, 50) AS g +WHERE NOT EXISTS (SELECT 1 FROM chats WHERE title = convert_to('load chat ' || g, 'UTF8')); + +INSERT INTO chat_members (chat_id, user_id) +SELECT c.id, u.id +FROM chats c CROSS JOIN users u +WHERE position(convert_to('load chat ', 'UTF8') in c.title) = 1 AND u.username LIKE 'load\_%' +ON CONFLICT DO NOTHING; + +SELECT greatest(0, :total - (SELECT count(*) FROM messages)) AS to_seed \gset +SELECT clock_timestamp() AS seed_started \gset + +WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1), + u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%') +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int], + u.ids[1 + floor(array_length(u.ids, 1) * random())::int], + convert_to('load message ' || g || ' ' || md5(g::text), 'UTF8'), + now() - make_interval(secs => (:to_seed - g) / 100.0) +FROM generate_series(1, :to_seed) AS g, c, u; + +SELECT clock_timestamp() - :'seed_started'::timestamptz AS seed_duration, + :to_seed AS seeded_rows, + :total AS target_total, + (SELECT count(*) FROM messages) AS messages_total; + +ANALYZE users, chats, chat_members, messages; diff --git a/student-tests/test_auth_sessions.py b/student-tests/test_auth_sessions.py new file mode 100644 index 00000000..6c02e5b2 --- /dev/null +++ b/student-tests/test_auth_sessions.py @@ -0,0 +1,114 @@ +#!/usr/bin/env python3 +"""Level 4: session semantics — wrong password, challenges, logout, token quality.""" +import json +import uuid + +from common import arguments, basic, call, credentials, expect, login, member, register, run + + +def wrong_password_gives_same_401(base): + actor = register(base, "pw") + name = actor["registration"]["username"] + wrong = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": basic(name, "wrong-password-123")}) + unknown = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": basic("u_absent_" + uuid.uuid4().hex[:8], "wrong-password-123")}) + expect(wrong["status"] == unknown["status"] == 401, "ожидался 401 в обоих случаях") + expect(wrong["json"]["error"]["code"] == unknown["json"]["error"]["code"] == "unauthorized", "код ошибки отличается") + expect(wrong["headers"].get("WWW-Authenticate", "").startswith("Basic"), "нет Basic challenge") + expect(wrong["json"]["error"]["request_id"] == wrong["headers"].get("X-Request-Id"), "request_id не совпадает с заголовком") + + +def basic_is_rejected_on_business_endpoints(base): + actor = register(base, "basic") + name = actor["registration"]["username"] + password = actor["registration"]["password"] + result = call(base, "GET", "/api/v1/users/me", headers={"Authorization": basic(name, password)}) + expect(result["status"] == 401, "Basic на /users/me вернул %s" % result["status"]) + expect(result["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "нет Bearer challenge") + + +def x_user_id_does_not_authenticate(base): + alice = member(base, "alice") + bob = register(base, "bob") + anonymous = call(base, "GET", "/api/v1/users/me", headers={"X-User-Id": alice["id"]}) + expect(anonymous["status"] == 401, "X-User-Id без Bearer дал %s" % anonymous["status"]) + overridden = call(base, "GET", "/api/v1/users/me", token=alice["token"], headers={"X-User-Id": bob["id"]}) + expect(overridden["status"] == 200 and overridden["json"]["id"] == alice["id"], "X-User-Id подменил владельца сессии") + + +def logout_revokes_only_its_own_token(base): + actor = member(base, "logout") + second = login(base, dict(actor)) + first_token = actor["token"] + revoked = call(base, "DELETE", "/api/v1/auth/sessions/current", token=first_token) + expect(revoked["status"] == 204, "logout вернул %s" % revoked["status"]) + expect(call(base, "GET", "/api/v1/users/me", token=first_token)["status"] == 401, "отозванный токен всё ещё работает") + expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=first_token)["status"] == 401, "повторный logout не 401") + expect(call(base, "GET", "/api/v1/users/me", token=second["token"])["status"] == 200, "logout убил вторую сессию") + + +def token_is_opaque_and_unique(base): + actor = member(base, "token") + name = actor["registration"]["username"] + expect(len(actor["token"]) >= 32, "токен короче 32 символов") + expect(name not in actor["token"] and actor["id"] not in actor["token"], "токен раскрывает имя или id пользователя") + again = login(base, dict(actor)) + expect(again["token"] != actor["token"], "повторный вход выдал тот же токен") + expect(actor["session"]["token_type"] == "Bearer", "token_type не Bearer") + + +def short_password_is_rejected(base): + body = credentials("short") + body["password"] = "short" + expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "короткий пароль принят") + body = credentials("long") + body["password"] = "x" * 129 + expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "пароль длиннее 128 принят") + + +def password_is_never_returned(base): + actor = member(base, "leak") + expect("password" not in actor["user"] and "password_hash" not in actor["user"], "User содержит пароль") + me = call(base, "GET", "/api/v1/users/me", token=actor["token"])["json"] + expect(set(me) == {"id", "username", "display_name", "created_at"}, "в /users/me лишние поля: %s" % sorted(me)) + expect("password" not in str(actor["session"]["user"]), "сессия раскрывает пароль") + + +def login_rejects_a_request_body(base): + actor = register(base, "body") + header = basic(actor["registration"]["username"], actor["registration"]["password"]) + with_body = call(base, "POST", "/api/v1/auth/sessions", body={"username": actor["registration"]["username"]}, headers={"Authorization": header}) + expect(with_body["status"] == 400, "вход с JSON-телом дал %s" % with_body["status"]) + raw_body = call(base, "POST", "/api/v1/auth/sessions", raw=b"anything", headers={"Authorization": header}, content_type="text/plain") + expect(raw_body["status"] == 400, "вход с произвольным телом дал %s" % raw_body["status"]) + clean = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header}) + expect(clean["status"] == 201, "вход без тела дал %s" % clean["status"]) + + +def broken_utf8_credentials_are_rejected(base): + actor = register(base, "utf8") + name = actor["registration"]["username"] + import base64 as b64 + + header = "Basic " + b64.b64encode(name.encode() + b":" + actor["registration"]["password"].encode() + b"\xff").decode() + result = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header}) + expect(result["status"] == 401, "повреждённый UTF-8 в пароле дал %s" % result["status"]) + body = credentials("utf8reg") + bad_body = json.dumps(body, ensure_ascii=False).encode("utf-8").replace(b'"password"', b'"passw\xffrd"') + broken = call(base, "POST", "/api/v1/users", raw=bad_body, content_type="application/json") + expect(broken["status"] == 400, "повреждённый UTF-8 в теле дал %s" % broken["status"]) + + +TESTS = [ + wrong_password_gives_same_401, + basic_is_rejected_on_business_endpoints, + x_user_id_does_not_authenticate, + logout_revokes_only_its_own_token, + token_is_opaque_and_unique, + short_password_is_rejected, + password_is_never_returned, + login_rejects_a_request_body, + broken_utf8_credentials_are_rejected, +] + +if __name__ == "__main__": + run(TESTS, arguments(__doc__).base_url) diff --git a/student-tests/test_expiry.py b/student-tests/test_expiry.py new file mode 100644 index 00000000..c471c7e1 --- /dev/null +++ b/student-tests/test_expiry.py @@ -0,0 +1,44 @@ +#!/usr/bin/env python3 +"""Level 4: session expiry on a short SESSION_TTL_SECONDS instance.""" +import time + +from common import arguments, call, expect, member, run + +TTL = 2 + + +def session_expires_after_ttl(base): + actor = member(base, "ttl") + alive = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(alive["status"] == 200, "свежая сессия дала %s" % alive["status"]) + time.sleep(TTL + 2) + expired = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(expired["status"] == 401, "истёкшая сессия дала %s" % expired["status"]) + expect(expired["headers"].get("WWW-Authenticate", "").startswith("Bearer"), "нет Bearer challenge") + expect(expired["json"]["error"]["code"] == "unauthorized", "код ошибки %s" % expired["json"]["error"]["code"]) + + +def expired_session_cannot_write_or_logout(base): + alice = member(base, "ttlwrite") + bob = member(base, "ttlwrite2") + chat = call(base, "POST", "/api/v1/chats", body={"title": "Срок жизни", "member_ids": [alice["id"], bob["id"]]}, token=alice["token"]) + expect(chat["status"] == 201, "создание чата дало %s" % chat["status"]) + time.sleep(TTL + 2) + write = call(base, "POST", "/api/v1/chats/%s/messages" % chat["json"]["id"], body={"text": "после истечения"}, token=alice["token"]) + expect(write["status"] == 401, "запись истёкшим токеном дала %s" % write["status"]) + expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=alice["token"])["status"] == 401, "logout истёкшим токеном не 401") + + +def expires_at_matches_configured_ttl(base): + import datetime as dt + + actor = member(base, "ttlvalue") + expires_at = dt.datetime.fromisoformat(actor["session"]["expires_at"][:-1] + "+00:00") + remaining = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds() + expect(0 < remaining <= TTL + 1, "expires_at обещает %.1f c при TTL=%d" % (remaining, TTL)) + + +TESTS = [session_expires_after_ttl, expired_session_cannot_write_or_logout, expires_at_matches_configured_ttl] + +if __name__ == "__main__": + run(TESTS, arguments(__doc__).base_url) diff --git a/student-tests/test_outages.py b/student-tests/test_outages.py new file mode 100644 index 00000000..b9caa3ba --- /dev/null +++ b/student-tests/test_outages.py @@ -0,0 +1,93 @@ +#!/usr/bin/env python3 +"""Level 4/5: revocation must outlive the cache and outages must never grant trust.""" +import pathlib +import subprocess +import time + +from common import arguments, call, chat_with, expect, member, run + +ROOT = pathlib.Path(__file__).resolve().parents[1] +COMPOSE = ["docker", "compose", "--env-file", ".env"] + + +def compose(*args): + subprocess.run(COMPOSE + list(args), cwd=str(ROOT), check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def wait_ready(base, seconds=90): + deadline = time.monotonic() + seconds + while time.monotonic() < deadline: + try: + if call(base, "GET", "/health/ready")["status"] == 200: + return + except AssertionError: + pass + time.sleep(0.5) + raise AssertionError("API не стал ready за %d с" % seconds) + + +def revoked_session_stays_revoked_after_cache_restart(base): + actor = member(base, "revoke") + expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 200, "свежая сессия не работает") + expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])["status"] == 204, "logout не вернул 204") + compose("restart", "valkey") + wait_ready(base) + after = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(after["status"] == 401, "отозванная сессия вернула доступ после рестарта кэша: %s" % after["status"]) + + +def logout_is_not_confirmed_while_cache_is_down(base): + actor = member(base, "logoutdown") + expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 200, "свежая сессия не работает") + compose("stop", "valkey") + try: + refused = call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"]) + expect(refused["status"] == 503, "logout без кэша дал %s вместо 503" % refused["status"]) + still = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(still["status"] == 200, "сессия не отозвана, но доступ уже потерян: %s" % still["status"]) + finally: + compose("start", "valkey") + wait_ready(base) + expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=actor["token"])["status"] == 204, "повторный logout не прошёл") + expect(call(base, "GET", "/api/v1/users/me", token=actor["token"])["status"] == 401, "после подтверждённого logout токен жив") + + +def cached_sessions_do_not_cross_users(base): + alice = member(base, "cross") + bob = member(base, "cross2") + for _ in range(3): + first = call(base, "GET", "/api/v1/users/me", token=alice["token"])["json"] + second = call(base, "GET", "/api/v1/users/me", token=bob["token"])["json"] + expect(first["id"] == alice["id"] and second["id"] == bob["id"], "кэш перепутал владельцев сессий") + chat = chat_with(base, alice, bob) + sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "от боба"}, token=bob["token"]) + expect(sent["json"]["sender_id"] == bob["id"], "sender_id взят не из сессии") + + +def hung_database_fails_fast(base): + actor = member(base, "hang") + compose("pause", "postgres") + try: + started = time.monotonic() + result = call(base, "GET", "/api/v1/chats", token=actor["token"], timeout=60) + elapsed = time.monotonic() - started + expect(result["status"] == 503, "зависшая БД дала %s вместо 503" % result["status"]) + expect(elapsed < 10, "ответ пришёл за %.1f с при заявленном клиентском лимите 6 с" % elapsed) + ready = call(base, "GET", "/health/ready", timeout=60) + expect(ready["status"] == 503, "/health/ready при зависшей БД дал %s" % ready["status"]) + expect(call(base, "GET", "/health/live", timeout=60)["status"] == 200, "/health/live упал вместе с БД") + finally: + compose("unpause", "postgres") + wait_ready(base) + expect(call(base, "GET", "/api/v1/chats", token=actor["token"])["status"] == 200, "после возврата БД доступ не восстановился") + + +TESTS = [ + revoked_session_stays_revoked_after_cache_restart, + logout_is_not_confirmed_while_cache_is_down, + cached_sessions_do_not_cross_users, + hung_database_fails_fast, +] + +if __name__ == "__main__": + run(TESTS, arguments(__doc__).base_url) diff --git a/student-tests/test_storage_rules.py b/student-tests/test_storage_rules.py new file mode 100644 index 00000000..630eb532 --- /dev/null +++ b/student-tests/test_storage_rules.py @@ -0,0 +1,242 @@ +#!/usr/bin/env python3 +"""Level 4: PostgreSQL rules — username race, transaction rollback, keyset paging, injection.""" +import threading +import uuid +from urllib.parse import quote + +from common import arguments, call, chat_with, credentials, expect, member, run + +RACE_CLIENTS = 12 + + +def duplicate_username_race_creates_one_user(base): + body = credentials("race") + results = [] + lock = threading.Lock() + ready = threading.Barrier(RACE_CLIENTS) + + def attempt(): + ready.wait() + result = call(base, "POST", "/api/v1/users", body=body) + with lock: + results.append(result["status"]) + + threads = [threading.Thread(target=attempt) for _ in range(RACE_CLIENTS)] + for thread in threads: + thread.start() + for thread in threads: + thread.join() + created = results.count(201) + conflicts = results.count(409) + expect(created == 1, "создано %d пользователей с одним username (ожидался 1): %s" % (created, results)) + expect(created + conflicts == RACE_CLIENTS, "неожиданные ответы в гонке: %s" % results) + + +def unknown_member_rolls_chat_back(base): + alice = member(base, "rollback") + title = "Откат " + uuid.uuid4().hex[:8] + body = {"title": title, "member_ids": [alice["id"], str(uuid.uuid4())]} + result = call(base, "POST", "/api/v1/chats", body=body, token=alice["token"]) + expect(result["status"] == 400, "неизвестный участник дал %s" % result["status"]) + listed = call(base, "GET", "/api/v1/chats?limit=100", token=alice["token"])["json"] + expect(all(chat["title"] != title for chat in listed["items"]), "чат остался в базе после отката") + + +def keyset_pagination_is_complete(base): + alice = member(base, "pages") + bob = member(base, "pages2") + chat = chat_with(base, alice, bob) + total = 25 + for index in range(total): + result = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "сообщение %d" % index}, token=alice["token"]) + expect(result["status"] == 201, "отправка %d вернула %s" % (index, result["status"])) + seen = [] + cursor = None + for _ in range(total): + path = "/api/v1/chats/%s/messages?limit=7" % chat["id"] + if cursor: + path += "&cursor=" + quote(cursor, safe="") + page = call(base, "GET", path, token=bob["token"])["json"] + seen.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + expect(cursor is None, "обход истории не завершился") + ids = [item["id"] for item in seen] + expect(len(ids) == total, "прочитано %d сообщений из %d" % (len(ids), total)) + expect(len(set(ids)) == total, "в обходе есть повторы") + keys = [(item["created_at"], uuid.UUID(item["id"]).int) for item in seen] + expect(keys == sorted(keys), "порядок (created_at, id) нарушен") + + +def cursor_is_bound_to_its_chat(base): + alice = member(base, "cursor") + bob = member(base, "cursor2") + first = chat_with(base, alice, bob) + second = chat_with(base, alice, bob) + for chat in (first, second): + for index in range(3): + call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "текст %d" % index}, token=alice["token"]) + page = call(base, "GET", "/api/v1/chats/%s/messages?limit=1" % first["id"], token=alice["token"])["json"] + expect(page["next_cursor"], "нет курсора для проверки") + foreign = call(base, "GET", "/api/v1/chats/%s/messages?limit=1&cursor=%s" % (second["id"], quote(page["next_cursor"], safe="")), token=alice["token"]) + expect(foreign["status"] == 400, "курсор другого чата принят: %s" % foreign["status"]) + tampered = page["next_cursor"][:-2] + ("aa" if not page["next_cursor"].endswith("aa") else "bb") + altered = call(base, "GET", "/api/v1/chats/%s/messages?cursor=%s" % (first["id"], quote(tampered, safe="")), token=alice["token"]) + expect(altered["status"] == 400, "изменённый курсор принят: %s" % altered["status"]) + + +def limit_bounds_are_enforced(base): + alice = member(base, "limit") + bob = member(base, "limit2") + chat = chat_with(base, alice, bob) + for value in ("0", "101", "abc", "-1", "1.5", ""): + result = call(base, "GET", "/api/v1/chats/%s/messages?limit=%s" % (chat["id"], quote(value, safe="")), token=alice["token"]) + expect(result["status"] == 400, "limit=%r дал %s" % (value, result["status"])) + valid = call(base, "GET", "/api/v1/chats/%s/messages?limit=100" % chat["id"], token=alice["token"]) + expect(valid["status"] == 200, "limit=100 дал %s" % valid["status"]) + + +def sql_injection_is_not_executed(base): + probes = ["ad'; DROP TABLE users; --", "' OR '1'='1", "admin\"--", "ad\\'; SELECT 1"] + for probe in probes: + body = credentials("inj") + body["username"] = probe + result = call(base, "POST", "/api/v1/users", body=body) + expect(result["status"] == 400, "username %r дал %s" % (probe, result["status"])) + alice = member(base, "after") + bob = member(base, "after2") + chat = chat_with(base, alice, bob) + text = "текст с кавычкой ' и ; DROP TABLE messages; --" + created = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": text}, token=alice["token"]) + expect(created["status"] == 201 and created["json"]["text"] == text, "текст с кавычками испорчен или отклонён") + history = call(base, "GET", "/api/v1/chats/%s/messages" % chat["id"], token=bob["token"])["json"] + expect(any(item["text"] == text for item in history["items"]), "сообщение не читается после вставки") + + +def malformed_requests_are_rejected(base): + alice = member(base, "shape") + bob = member(base, "shape2") + chat = chat_with(base, alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + expect(call(base, "POST", path, body={"text": "ок", "sender_id": alice["id"]}, token=alice["token"])["status"] == 400, "лишнее поле принято") + expect(call(base, "POST", path, body={}, token=alice["token"])["status"] == 400, "пустой объект принят") + expect(call(base, "POST", path, body={"text": " "}, token=alice["token"])["status"] == 400, "пробельный текст принят") + expect(call(base, "POST", path, body={"text": "x" * 4001}, token=alice["token"])["status"] == 400, "текст длиннее 4000 принят") + expect(call(base, "GET", "/api/v1/chats/not-a-uuid", token=alice["token"])["status"] == 400, "неверный UUID дал не 400") + expect(call(base, "GET", "/api/v1/chats/%s" % uuid.uuid4(), token=alice["token"])["status"] == 404, "чужой чат дал не 404") + + +def nul_and_unicode_text_round_trips(base): + alice = member(base, "unicode") + bob = member(base, "unicode2") + chat = chat_with(base, alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + samples = [ + "a\u0000b", + "\u0000", + "emoji \U0001f44b и ZWJ \U0001f469\u200d\U0001f4bb", + "комбинация e\u0301 и RTL \u05d0\u05d1", + "край \u0007\u001b\u007f", + ] + created = [] + for sample in samples: + result = call(base, "POST", path, body={"text": sample}, token=alice["token"]) + expect(result["status"] == 201, "текст %r дал %s" % (sample, result["status"])) + expect(result["json"]["text"] == sample, "текст изменён при записи: %r -> %r" % (sample, result["json"]["text"])) + created.append(result["json"]) + history = call(base, "GET", path + "?limit=100", token=bob["token"])["json"]["items"] + by_id = {item["id"]: item["text"] for item in history} + for item in created: + expect(by_id.get(item["id"]) == item["text"], "текст изменён при чтении: %r" % item["text"]) + + +def text_length_limit_counts_code_points(base): + alice = member(base, "length") + bob = member(base, "length2") + chat = chat_with(base, alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + exact = "\U0001f600" * 4000 + result = call(base, "POST", path, body={"text": exact}, token=alice["token"]) + expect(result["status"] == 201, "4000 code points дали %s" % result["status"]) + expect(result["json"]["text"] == exact, "текст на границе изменён") + over = call(base, "POST", path, body={"text": "\U0001f600" * 4001}, token=alice["token"]) + expect(over["status"] == 400, "4001 code point дал %s" % over["status"]) + + +def unicode_blanks_are_rejected(base): + alice = member(base, "blank") + bob = member(base, "blank2") + chat = chat_with(base, alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + blanks = [" ", "\t\n", "\u00a0", "\u2007", "\u3000", "\u200b", "\u200b \u200b", "\ufeff"] + for blank in blanks: + result = call(base, "POST", path, body={"text": blank}, token=alice["token"]) + expect(result["status"] == 400, "пробельный текст %r дал %s" % (blank, result["status"])) + for field in ("display_name",): + body = credentials("blank") + body[field] = "\u200b" + expect(call(base, "POST", "/api/v1/users", body=body)["status"] == 400, "пустой %s принят" % field) + titles = call(base, "POST", "/api/v1/chats", body={"title": "\u00a0", "member_ids": [alice["id"]]}, token=alice["token"]) + expect(titles["status"] == 400, "пробельный title принят: %s" % titles["status"]) + + +def broken_json_does_not_break_the_api(base): + alice = member(base, "json") + bob = member(base, "json2") + chat = chat_with(base, alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + payloads = [ + b'{"text": 1e999}', + b'{"text": NaN}', + b'{"text": Infinity}', + b'{"text": 1e+}', + b'{"text": ' + b"9" * 5000 + b"}", + b'{"text": ' + b"[" * 2000 + b"]" * 2000 + b"}", + b"[" * 2000, + b'{"text": {"text": "nested object"}}', + b'{"text": "\xff\xfe"}', + b"", + b"{", + ] + for payload in payloads: + result = call(base, "POST", path, raw=payload, token=alice["token"], content_type="application/json") + expect(result["status"] == 400, "тело %r дало %s" % (payload[:24], result["status"])) + alive = call(base, "POST", path, body={"text": "после битого JSON"}, token=alice["token"]) + expect(alive["status"] == 201, "API не отвечает после битых тел: %s" % alive["status"]) + + +def content_type_is_required(base): + alice = member(base, "ctype") + bob = member(base, "ctype2") + chat = chat_with(base, alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + for content_type in ("text/plain", "application/x-www-form-urlencoded", "", "application/jsonx"): + result = call(base, "POST", path, raw=b'{"text":"x"}', token=alice["token"], content_type=content_type) + expect(result["status"] == 415, "Content-Type %r дал %s" % (content_type, result["status"])) + body = credentials("ctype") + import json as jsonlib + + plain = call(base, "POST", "/api/v1/users", raw=jsonlib.dumps(body).encode(), content_type="text/plain") + expect(plain["status"] == 415, "регистрация с text/plain дала %s" % plain["status"]) + charset = call(base, "POST", path, raw=b'{"text":"charset"}', token=alice["token"], content_type="application/json; charset=utf-8") + expect(charset["status"] == 201, "application/json с charset дал %s" % charset["status"]) + + +TESTS = [ + duplicate_username_race_creates_one_user, + unknown_member_rolls_chat_back, + keyset_pagination_is_complete, + cursor_is_bound_to_its_chat, + limit_bounds_are_enforced, + sql_injection_is_not_executed, + malformed_requests_are_rejected, + nul_and_unicode_text_round_trips, + text_length_limit_counts_code_points, + unicode_blanks_are_rejected, + broken_json_does_not_break_the_api, + content_type_is_required, +] + +if __name__ == "__main__": + run(TESTS, arguments(__doc__).base_url) diff --git a/student-tests/test_without_cache.py b/student-tests/test_without_cache.py new file mode 100644 index 00000000..b75b1041 --- /dev/null +++ b/student-tests/test_without_cache.py @@ -0,0 +1,32 @@ +#!/usr/bin/env python3 +"""Level 4: the API keeps working from PostgreSQL while the session cache is down.""" +from common import arguments, call, chat_with, expect, member, run + + +def login_and_read_work_without_cache(base): + alice = member(base, "nocache") + bob = member(base, "nocache2") + me = call(base, "GET", "/api/v1/users/me", token=alice["token"]) + expect(me["status"] == 200 and me["json"]["id"] == alice["id"], "/users/me без кэша дал %s" % me["status"]) + chat = chat_with(base, alice, bob) + sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "кэш выключен"}, token=alice["token"]) + expect(sent["status"] == 201, "запись без кэша дала %s" % sent["status"]) + history = call(base, "GET", "/api/v1/chats/%s/messages" % chat["id"], token=bob["token"]) + expect(history["status"] == 200, "чтение без кэша дало %s" % history["status"]) + expect(any(item["id"] == sent["json"]["id"] for item in history["json"]["items"]), "сообщение не видно без кэша") + + +def unknown_token_is_still_rejected(base): + expect(call(base, "GET", "/api/v1/users/me", token="definitely-not-a-valid-session-token")["status"] == 401, "неизвестный токен принят") + expect(call(base, "GET", "/api/v1/users/me")["status"] == 401, "анонимный запрос принят") + + +def readiness_ignores_the_cache(base): + ready = call(base, "GET", "/health/ready") + expect(ready["status"] == 200, "/health/ready без кэша дал %s" % ready["status"]) + + +TESTS = [login_and_read_work_without_cache, unknown_token_is_still_rejected, readiness_ignores_the_cache] + +if __name__ == "__main__": + run(TESTS, arguments(__doc__).base_url) diff --git a/student-tests/test_without_db.py b/student-tests/test_without_db.py new file mode 100644 index 00000000..bb55208a --- /dev/null +++ b/student-tests/test_without_db.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python3 +"""Level 4: with PostgreSQL stopped the API degrades to a bounded error, never to trust.""" +import uuid + +from common import arguments, call, expect, run + + +def readiness_reports_the_outage(base): + ready = call(base, "GET", "/health/ready") + expect(ready["status"] == 503, "/health/ready без БД дал %s" % ready["status"]) + expect(ready["json"]["error"]["code"] == "unavailable", "код ошибки %s" % ready["json"]["error"]["code"]) + live = call(base, "GET", "/health/live") + expect(live["status"] == 200, "/health/live без БД дал %s" % live["status"]) + + +def writes_fail_with_503(base): + body = {"username": "u_nodb_" + uuid.uuid4().hex[:8], "display_name": "Без БД", "password": "T3st-" + uuid.uuid4().hex} + created = call(base, "POST", "/api/v1/users", body=body) + expect(created["status"] == 503, "регистрация без БД дала %s" % created["status"]) + + +def unknown_token_never_becomes_trusted(base): + for token in ("definitely-not-a-valid-session-token", uuid.uuid4().hex): + result = call(base, "GET", "/api/v1/users/me", token=token) + expect(result["status"] in (401, 503), "неизвестный токен без БД дал %s" % result["status"]) + anonymous = call(base, "GET", "/api/v1/chats", token=None) + expect(anonymous["status"] == 401, "анонимный запрос без БД дал %s" % anonymous["status"]) + + +def login_fails_closed(base): + import base64 + + header = "Basic " + base64.b64encode(b"u_any_user:any-password-123").decode() + result = call(base, "POST", "/api/v1/auth/sessions", headers={"Authorization": header}) + expect(result["status"] in (401, 503), "вход без БД дал %s" % result["status"]) + + +TESTS = [readiness_reports_the_outage, writes_fail_with_503, unknown_token_never_becomes_trusted, login_fails_closed] + +if __name__ == "__main__": + run(TESTS, arguments(__doc__).base_url) diff --git a/student-tests/track2.sh b/student-tests/track2.sh new file mode 100755 index 00000000..acf8a0d0 --- /dev/null +++ b/student-tests/track2.sh @@ -0,0 +1,113 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." + +TOTAL=${TOTAL:-120000} +IMAGE=postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d141f6d0a0ee371a6e7c0f2 +RNAME=mtusi-lab2-restore +RVOL=mtusi-lab2-restore-data +PSQL="docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -X -q" +RPSQL="docker exec -i $RNAME psql -U messenger -d messenger_restored -X -q" +STAMP=$(date +%Y%m%d-%H%M%S) +DUMP="backups/messenger-$STAMP.dump" + +now_ms() { + python3 -c 'import time; print(int(time.time() * 1000))' +} + +elapsed() { + python3 -c "print('%.3f' % ((int('$2') - int('$1')) / 1000.0))" +} + +cleanup() { + if [ "${KEEP:-0}" != "1" ]; then + docker rm -f "$RNAME" >/dev/null 2>&1 || true + docker volume rm "$RVOL" >/dev/null 2>&1 || true + fi +} +trap cleanup EXIT + +mkdir -p backups + +echo "=== Стенд и версии ===" +docker compose --env-file .env ps --format '{{.Service}} {{.Image}} {{.Status}}' +uname -sm +docker --version + +echo +echo "=== 1. Засев истории: цель $TOTAL сообщений, чаты неравномерные ===" +$PSQL -v total="$TOTAL" -f - < student-tests/seed.sql + +echo +echo "=== 2. Сравнение индексов и цены записи (каждый вариант в откатываемой транзакции) ===" +$PSQL -f - < student-tests/track2_indexes.sql + +BIG_CHAT=$($PSQL -t -A -c "SELECT chat_id FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1") +echo +echo "Самый большой чат: $BIG_CHAT" + +echo +echo "=== 3. Состояние источника до бэкапа ===" +$PSQL -v big_chat="$BIG_CHAT" -f - < student-tests/track2_verify.sql + +echo +echo "=== 4. Бэкап pg_dump -Fc ===" +BACKUP_START=$(now_ms) +docker compose --env-file .env exec -T postgres pg_dump -U messenger -d messenger -Fc > "$DUMP" +BACKUP_END=$(now_ms) +echo "backup_seconds=$(elapsed "$BACKUP_START" "$BACKUP_END")" +echo "dump_size=$(du -h "$DUMP" | cut -f1)" + +echo +echo "=== 5. Запись после бэкапа: граница потери данных ===" +$PSQL -c "INSERT INTO messages (id, chat_id, sender_id, text, created_at) SELECT gen_random_uuid(), '$BIG_CHAT', sender_id, convert_to('marker after backup $STAMP', 'UTF8'), clock_timestamp() FROM messages WHERE chat_id = '$BIG_CHAT' LIMIT 1" +$PSQL -t -A -c "SELECT 'в источнике маркеров: ' || count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1" + +echo +echo "=== 6. Новое хранилище: отдельный контейнер и отдельный том ===" +docker volume create "$RVOL" >/dev/null +docker run -d --name "$RNAME" \ + -e POSTGRES_USER=messenger \ + -e POSTGRES_DB=messenger_restored \ + -e POSTGRES_PASSWORD_FILE=/run/secrets/postgres_password \ + -v "$PWD/secrets/postgres_password:/run/secrets/postgres_password:ro" \ + -v "$RVOL:/var/lib/postgresql/data" \ + "$IMAGE" >/dev/null +i=0 +while [ "$i" -lt 60 ]; do + if docker exec "$RNAME" pg_isready -U messenger -d messenger_restored >/dev/null 2>&1; then break; fi + i=$((i + 1)) + sleep 1 +done +docker exec "$RNAME" pg_isready -U messenger -d messenger_restored + +echo +echo "=== 7. Восстановление в новое хранилище ===" +docker cp "$DUMP" "$RNAME:/tmp/restore.dump" >/dev/null +RESTORE_START=$(now_ms) +docker exec "$RNAME" pg_restore -U messenger -d messenger_restored --no-owner --exit-on-error /tmp/restore.dump +RESTORE_END=$(now_ms) +echo "restore_seconds=$(elapsed "$RESTORE_START" "$RESTORE_END")" + +echo +echo "=== 8. Сверка восстановленной копии ===" +$RPSQL -v big_chat="$BIG_CHAT" -f - < student-tests/track2_verify.sql + +echo +echo "=== 9. Итог ===" +SRC_MD5=$($PSQL -t -A -c "SELECT md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) FROM messages WHERE chat_id = '$BIG_CHAT' AND position(convert_to('marker after backup', 'UTF8') in text) <> 1") +DST_MD5=$($RPSQL -t -A -c "SELECT md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) FROM messages WHERE chat_id = '$BIG_CHAT'") +SRC_ROWS=$($PSQL -t -A -c "SELECT count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) <> 1") +DST_ROWS=$($RPSQL -t -A -c "SELECT count(*) FROM messages") +echo "backup_seconds=$(elapsed "$BACKUP_START" "$BACKUP_END") restore_seconds=$(elapsed "$RESTORE_START" "$RESTORE_END")" +echo "messages_source_without_marker=$SRC_ROWS messages_restored=$DST_ROWS" +echo "big_chat_md5_source=$SRC_MD5" +echo "big_chat_md5_restored=$DST_MD5" +if [ "$SRC_MD5" = "$DST_MD5" ] && [ "$SRC_ROWS" = "$DST_ROWS" ]; then + echo "RESULT: восстановленная копия совпадает с источником на момент бэкапа" +else + echo "RESULT: расхождение, смотри таблицы выше" + exit 1 +fi +MARKERS=$($RPSQL -t -A -c "SELECT count(*) FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1") +echo "маркеров после бэкапа в восстановленной копии: $MARKERS (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует)" diff --git a/student-tests/track2_indexes.sql b/student-tests/track2_indexes.sql new file mode 100644 index 00000000..82bc10c0 --- /dev/null +++ b/student-tests/track2_indexes.sql @@ -0,0 +1,104 @@ +\set ON_ERROR_STOP on + +SELECT count(*) AS messages_total FROM messages; + +SELECT chat_id AS big_chat, count(*) AS big_rows +FROM messages GROUP BY chat_id ORDER BY count(*) DESC LIMIT 1 \gset + +SELECT created_at AS cur_ts, id AS cur_id +FROM messages WHERE chat_id = :'big_chat' +ORDER BY created_at, id OFFSET (:'big_rows'::bigint * 9 / 10) LIMIT 1 \gset + +\echo '############ Вариант A: messages_history_idx (chat_id, created_at, id) ############' +BEGIN; +ANALYZE messages; +SELECT pg_size_pretty(pg_relation_size('messages_history_idx')) AS index_size; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id LIMIT 50; +SELECT clock_timestamp() AS q0 \gset +SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g, +LATERAL ( + SELECT id FROM messages + WHERE chat_id = :'big_chat' + AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid) + ORDER BY created_at, id LIMIT 50 +) AS page; +SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration; +SELECT clock_timestamp() AS t0 \gset +WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1), + u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%') +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int], + u.ids[1 + floor(array_length(u.ids, 1) * random())::int], + convert_to('write cost A ' || g, 'UTF8'), now() +FROM generate_series(1, 10000) AS g, c, u; +SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration; +ROLLBACK; + +\echo '############ Вариант B: только (chat_id) ############' +BEGIN; +DROP INDEX messages_history_idx; +CREATE INDEX messages_chat_only_idx ON messages (chat_id); +ANALYZE messages; +SELECT pg_size_pretty(pg_relation_size('messages_chat_only_idx')) AS index_size; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id LIMIT 50; +SELECT clock_timestamp() AS q0 \gset +SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g, +LATERAL ( + SELECT id FROM messages + WHERE chat_id = :'big_chat' + AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid) + ORDER BY created_at, id LIMIT 50 +) AS page; +SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration; +SELECT clock_timestamp() AS t0 \gset +WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1), + u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%') +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int], + u.ids[1 + floor(array_length(u.ids, 1) * random())::int], + convert_to('write cost B ' || g, 'UTF8'), now() +FROM generate_series(1, 10000) AS g, c, u; +SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration; +ROLLBACK; + +\echo '############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############' +BEGIN; +DROP INDEX messages_history_idx; +CREATE INDEX messages_history_covering_idx ON messages (chat_id, created_at, id) INCLUDE (sender_id, text); +ANALYZE messages; +SELECT pg_size_pretty(pg_relation_size('messages_history_covering_idx')) AS index_size; +EXPLAIN (ANALYZE, BUFFERS) +SELECT id, chat_id, sender_id, text, created_at FROM messages +WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id LIMIT 50; +SELECT clock_timestamp() AS q0 \gset +SELECT count(*) AS pages_measured FROM generate_series(1, 100) AS g, +LATERAL ( + SELECT id FROM messages + WHERE chat_id = :'big_chat' + AND (created_at, id) > (:'cur_ts'::timestamptz + make_interval(secs => g * 0.001), :'cur_id'::uuid) + ORDER BY created_at, id LIMIT 50 +) AS page; +SELECT clock_timestamp() - :'q0'::timestamptz AS hundred_pages_duration; +SELECT clock_timestamp() AS t0 \gset +WITH c AS (SELECT array_agg(id ORDER BY title) AS ids FROM chats WHERE position(convert_to('load chat ', 'UTF8') in title) = 1), + u AS (SELECT array_agg(id ORDER BY username) AS ids FROM users WHERE username LIKE 'load\_%') +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), + c.ids[1 + floor(array_length(c.ids, 1) * power(random(), 3))::int], + u.ids[1 + floor(array_length(u.ids, 1) * random())::int], + convert_to('write cost C ' || g, 'UTF8'), now() +FROM generate_series(1, 10000) AS g, c, u; +SELECT clock_timestamp() - :'t0'::timestamptz AS insert_10k_duration; +ROLLBACK; + +\echo '############ Схема после эксперимента (ROLLBACK вернул индексы) ############' +SELECT indexname FROM pg_indexes WHERE tablename = 'messages' ORDER BY indexname; diff --git a/student-tests/track2_verify.sql b/student-tests/track2_verify.sql new file mode 100644 index 00000000..563ec45d --- /dev/null +++ b/student-tests/track2_verify.sql @@ -0,0 +1,17 @@ +\set ON_ERROR_STOP on + +SELECT 'users' AS relation, count(*) AS rows FROM users +UNION ALL SELECT 'chats', count(*) FROM chats +UNION ALL SELECT 'chat_members', count(*) FROM chat_members +UNION ALL SELECT 'messages', count(*) FROM messages +UNION ALL SELECT 'sessions', count(*) FROM sessions +ORDER BY relation; + +SELECT count(*) AS big_chat_rows, + md5(string_agg(id::text || '|' || created_at::text || '|' || encode(text, 'hex'), E'\n' ORDER BY created_at, id)) AS big_chat_md5 +FROM messages WHERE chat_id = :'big_chat'; + +SELECT id, created_at, left(encode(text, 'escape'), 40) AS text FROM messages +WHERE chat_id = :'big_chat' ORDER BY created_at, id LIMIT 3; + +SELECT count(*) AS marker_rows FROM messages WHERE position(convert_to('marker after backup', 'UTF8') in text) = 1; -- 2.54.0 From a0c16afa33c9d9197af8abbfdee1be826c3ed8ef Mon Sep 17 00:00:00 2001 From: alenchha Date: Mon, 19 Oct 2026 19:20:16 +0300 Subject: [PATCH 2/4] =?UTF-8?q?=D0=A1=D1=81=D1=8B=D0=BB=D0=BA=D0=B0=20?= =?UTF-8?q?=D0=BD=D0=B0=20PR=20=D0=B2=20=D0=BE=D1=82=D1=87=D1=91=D1=82?= =?UTF-8?q?=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 1687ca91..c951a0dc 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Курлова Алёна Алексеевна, БВТ2301 - Целевая оценка; выбранный трек 5: 5, трек 2 «План запроса и восстановление» -- Commit/PR: TODO после публикации +- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/68 - Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, psycopg 3.3.6 (+psycopg-pool), valkey-py 6.2.0, argon2-cffi 25.1.0 — документация перечисленных библиотек; документация PostgreSQL 17 (transactions, EXPLAIN, pg_dump/pg_restore, типы данных), Valkey persistence, RFC 7617, RFC 9106. Реализация, свои тесты и стенд эксперимента написаны с помощью ИИ-ассистента (Claude Code); все прогоны и доказательства выполнены автором. Отдельно просмотрены публичные ревью преподавателя к PR других студентов этой же лабораторной и проверено, закрыты ли названные там случаи в этой работе: сохранение NUL в тексте, отзыв сессии против возврата кэша, зависшая БД, тело запроса на входе, Unicode-пробелы. Четыре из них требовали правок, остальные уже работали; на каждый добавлен свой тест. ## Запуск из чистого clone -- 2.54.0 From 1a60b9cd1fd65e36dc0dacf8c31fb61bcfd4f939 Mon Sep 17 00:00:00 2001 From: alenchha Date: Fri, 23 Oct 2026 17:42:38 +0300 Subject: [PATCH 3/4] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=BF=D0=BE=20=D0=B7=D0=B0=D0=BC?= =?UTF-8?q?=D0=B5=D1=87=D0=B0=D0=BD=D0=B8=D1=8E:=20=D0=BA=D1=8D=D1=88=20?= =?UTF-8?q?=D1=81=D0=B5=D1=81=D1=81=D0=B8=D0=B9=20=D0=BD=D0=B0=D0=BF=D0=BE?= =?UTF-8?q?=D0=BB=D0=BD=D1=8F=D0=B5=D1=82=D1=81=D1=8F=20=D0=BF=D0=BE=D1=81?= =?UTF-8?q?=D0=BB=D0=B5=20=D0=BF=D1=80=D0=BE=D0=BC=D0=B0=D1=85=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 39 +++++----- app/sessions.py | 12 ++-- evidence/dependency.txt | 4 +- evidence/explain-10k.txt | 72 +++++++++---------- evidence/git-hygiene.txt | 41 ++++------- evidence/load-cache.json | 12 ++-- evidence/load-nocache.json | 12 ++-- evidence/load.txt | 24 +++---- evidence/migrations.txt | 6 +- evidence/outages.txt | 4 +- evidence/persistence.txt | 16 ++--- evidence/stand.txt | 8 +++ evidence/track2/run.txt | 132 +++++++++++++++++----------------- scripts/bootstrap.sh | 27 ++++++- student-tests/evidence.sh | 4 ++ student-tests/test_outages.py | 44 +++++++++++- 16 files changed, 263 insertions(+), 194 deletions(-) diff --git a/REPORT.md b/REPORT.md index c951a0dc..d768bd24 100644 --- a/REPORT.md +++ b/REPORT.md @@ -92,7 +92,7 @@ docker compose --env-file .env start valkey **Валидация входа.** Тело читается потоком с лимитом `MAX_BODY_BYTES` (413), `Content-Type` обязателен (415 на любой другой), лишние и недостающие поля — 400. Некорректный JSON, в том числе битые числа (`1e999`, `NaN`), обрезанное тело и глубокая вложенность, вызывающая `RecursionError`, дают 400, а не 500. Обязательные строки не могут состоять только из пробельных символов, причём к пробельным приравнены и невидимые `U+200B..U+200D`, `U+2060`, `U+FEFF`. -**Кэш сессий.** Ключ `session:` — коллизий между пользователями быть не может, значение — публичные поля владельца токена, TTL = `min(SESSION_CACHE_TTL_SECONDS, остаток до expires_at)`. Промах читает `sessions JOIN users` с условием `expires_at > now()` и снова наполняет кэш. Истёкшие строки убирает фоновая задача раз в `SESSION_SWEEP_SECONDS`; TTL абсолютный, рестарт его не продлевает. +**Кэш сессий.** Ключ `session:` — коллизий между пользователями быть не может, значение — публичные поля владельца токена, TTL = `min(SESSION_CACHE_TTL_SECONDS, остаток до expires_at)`. Промах читает `sessions JOIN users` с условием `expires_at > now()` и снова наполняет кэш, причём публичный вид пользователя и при входе, и при промахе строит одна функция `repo.public_user`, поэтому тело ответа не зависит от того, откуда оно пришло. Сериализация значения выполняется до сетевого вызова: иначе ошибка сериализации попадала бы в тот же `except`, что и недоступность кэша, и выглядела бы как обычный сбой сети, хотя кэш при этом не наполнялся бы никогда. Истёкшие строки убирает фоновая задача раз в `SESSION_SWEEP_SECONDS`; TTL абсолютный, рестарт его не продлевает. **Пул и таймауты.** `AsyncConnectionPool` с `min_size=1`, `max_size=10`, ожиданием свободного соединения 3 с, `connect_timeout=3`; на каждом соединении выставлены `statement_timeout=5000`, `lock_timeout=5000`, `idle_in_transaction_session_timeout=10000`. Серверных таймаутов недостаточно: если процесс БД заморожен, он не успеет их применить, поэтому каждый SQL-запрос дополнительно обёрнут клиентским лимитом `DB_OP_TIMEOUT`, а весь HTTP-запрос — потолком `REQUEST_TIMEOUT` в middleware. Соединение, на котором сработал клиентский таймаут, закрывается, чтобы пул заменил его, а не выдал следующему запросу. Все запросы параметризованы psycopg (`%s`), конкатенации пользовательских данных в SQL нет. @@ -106,7 +106,7 @@ docker compose --env-file .env start valkey ## Доказательства критериев -Окружение: Apple M4, 10 ядер, 16 ГБ RAM, Docker Desktop (лимит 10 CPU / 7.7 ГБ), macOS Darwin 25.6.0 arm64, Docker 29.7.2, Compose v5.5.1, PostgreSQL 17.7 (aarch64, musl), Valkey 8.1.10, образ API — python 3.12.8-slim, хост-Python 3.9.6, 2026-10-19. Полный состав стенда и версии — в `evidence/stand.txt`. Все числа ниже получены одним прогоном `make evidence`, начатым с удаления тома базы, поэтому относятся к одному и тому же состоянию стенда. +Окружение: Apple M4, 10 ядер, 16 ГБ RAM, Docker Desktop (лимит 10 CPU / 7.7 ГБ), macOS Darwin 25.6.0 arm64, Docker 29.7.2, Compose v5.5.1, PostgreSQL 17.7 (aarch64, musl), Valkey 8.1.10, образ API — python 3.12.8-slim, хост-Python 3.9.6, 2026-10-23. Полный состав стенда, версии и строка старта API с действующими лимитами — в `evidence/stand.txt`. Все числа ниже получены одним прогоном `make evidence`, начатым с удаления тома базы, поэтому относятся к одному и тому же состоянию стенда. | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | @@ -116,15 +116,17 @@ docker compose --env-file .env start valkey | Составная операция создания чата атомарна | `test_storage_rules.py::unknown_member_rolls_chat_back` | 400 на неизвестного участника, чат в списке отсутствует | `evidence/level4-tests.txt` | | Basic только на `POST /auth/sessions`, остальное — Bearer; `X-User-Id` не даёт доступа | `test_auth_sessions.py` | 9/9 PASS, в том числе Basic на `/users/me` → 401 Bearer, вход с телом → 400, повреждённый UTF-8 → 400/401 | `evidence/level4-tests.txt` | | Срок жизни сессии и отзыв | `make expiry` (TTL=2 с) | 3/3 PASS: истёкший токен → 401, запись истёкшим → 401, `expires_at` соответствует TTL | `evidence/expiry.txt` | -| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 4/4 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` | +| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 6/6 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` | +| Кэш наполняется после промаха, а не только при входе | `make outages::cache_is_repopulated_after_a_miss`, `::cache_survives_its_own_restart` | после удаления ключа `session:` ответ 200 из PostgreSQL совпадает с кэшированным телом, ключ восстановлен с TTL; после рестарта Valkey кэш пуст и снова наполняется | `evidence/outages.txt` | | Пароли хешируются password KDF | `app/passwords.py`, формат хеша в БД | `$argon2id$v=19$m=19456,t=2,p=1$…`, в API пароль не возвращается | `evidence/level4-tests.txt` | | Любая строка Unicode сохраняется без искажений | `test_storage_rules.py::nul_and_unicode_text_round_trips`, `::text_length_limit_counts_code_points` | `a\u0000b`, одиночный `\u0000`, emoji с ZWJ, комбинирующие и RTL, 4000 code points — 201 и точный round-trip; 4001 — 400 | `evidence/level4-tests.txt` | | Secrets/volumes не попадают в Git | `git status --porcelain`, `git check-ignore -v` | `.env`, `secrets/`, `backups/` игнорируются; в рабочем дереве только код, тесты и `evidence/` | `evidence/git-hygiene.txt` | -| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1097.7 RPS / p95 6.06 мс против 691.7 RPS / p95 8.15 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` | +| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1209.7 RPS / p95 4.57 мс против 550.9 RPS / p95 9.41 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` | | Параметризованные запросы, ограниченный пул и таймауты | `test_storage_rules.py::sql_injection_is_not_executed`, `::content_type_is_required`, `::broken_json_does_not_break_the_api`, `app/db.py` | SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, `statement_timeout=5000`, клиентский лимит 6 с, потолок запроса 8 с | `evidence/level4-tests.txt` | | Гонка регистрации одинакового username | `test_storage_rules.py::duplicate_username_race_creates_one_user` (12 потоков) | один 201, одиннадцать 409 | `evidence/level4-tests.txt` | -| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (53 764 сообщения в таблице) | keyset, первая страница: 24 буфера, 0.026 мс; keyset на глубине 90 %: 53 буфера, 0.063 мс; OFFSET той же глубины: 29 813 буферов, 4.17 мс (29 699 строк пройдено ради 50) | `evidence/explain-10k.txt` | +| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (52 887 сообщений в таблице) | keyset, первая страница: 21 буфер, 0.018 мс; keyset на глубине 90 %: 54 буфера, 0.034 мс; OFFSET той же глубины: 33 082 буфера, 4.15 мс (32 724 строки пройдено ради 50) | `evidence/explain-10k.txt` | | Проверка expiry, logout, неверного пароля и недоступности Redis/БД | `make dependency`, `make outages` | без Valkey 3/3 PASS (кэш обойдён, ошибок нет); без PostgreSQL 4/4 PASS: `/health/ready` 503, запись 503, неизвестный токен не становится доверенным; зависшая БД (`pause`) отвечает 503 быстрее 10 с | `evidence/dependency.txt`, `evidence/outages.txt` | +| Переменные `.env.example` соответствуют реальной конфигурации | `make bootstrap` на существующем `.env`, затем сверка ключей | отсутствующие переменные дописываются из `.env.example`, расхождений по ключам нет | `evidence/stand.txt` (строка `cache_ttl` в логе старта API) | | Трек 5 (трек 2): ≥100 000 сообщений, ≥2 индекса, цена записи, backup → restore → сверка | `TOTAL=120000 make track2` | 120 000 сообщений в 68 чатах; варианты A/B/C сравнены; md5 истории источника и копии совпали; маркер после бэкапа в копии отсутствует | `evidence/track2/run.txt` | Проверка инфраструктурного hook: `scripts/restart.sh` выполняет `docker compose --env-file .env restart postgres valkey api`, то есть перезапускаются и API, и PostgreSQL, и Valkey; тома не удаляются. Подтверждение — состояние контейнеров до и после в `evidence/persistence.txt` (у всех трёх сервисов новое время старта) плюс строки `database system was shut down` → `database system is ready to accept connections` в логах postgres из того же файла. @@ -133,17 +135,17 @@ docker compose --env-file .env start valkey ### Трек 2, часть 1: план запроса и цена индекса -**Гипотеза.** Для keyset-пагинации по контракту (`ORDER BY created_at, id` внутри одного чата) составной индекс `(chat_id, created_at, id)` даёт цену страницы, не зависящую от её глубины, а индекс только по `chat_id` вынуждает читать и сортировать всю историю чата на каждую страницу. Покрывающий индекс с `INCLUDE (sender_id, text)` должен убрать обращения к heap, но увеличить размер индекса и цену записи. +**Гипотеза.** Для keyset-пагинации по контракту (`ORDER BY created_at, id` внутри одного чата) составной индекс `(chat_id, created_at, id)` даёт цену страницы, не зависящую от её глубины, а индекс только по `chat_id` вынуждает поднимать из heap всю историю чата на каждую страницу. Покрывающий индекс с `INCLUDE (sender_id, text)` должен убрать обращения к heap, но увеличить размер индекса и цену записи. -**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 66 236 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 32 944 строки в самом большом, 20 775 во втором, затем 25, 5 и 3 — то есть разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый. +**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 67 113 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 36 305 строк в самом большом, 16 537 во втором, затем 25, 5 и 3 — разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый. | Вариант индекса | План страницы на глубине 90 % | Буферы | Время одной страницы | 100 страниц | Размер индекса | Вставка 10 000 строк | | --- | --- | --- | --- | --- | --- | --- | -| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 53 | 0.048 мс | 1.12 мс | 10 МБ | 0.084 с | -| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 29 650` | 441 | 1.73 мс | 2186 мс | 848 кБ | 0.078 с | -| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.031 мс | 0.74 мс | 14 МБ | 0.085 с | +| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 54 | 0.042 мс | 1.05 мс | 11 МБ | 0.084 с | +| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 32 675` | 484 | 1.88 мс | 2461 мс | 848 кБ | 0.078 с | +| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.056 мс | 0.72 мс | 14 МБ | 0.086 с | -**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 29 650 строк ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 1950 раз (2186 мс против 1.12 мс), причём отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 53) и на серии страниц быстрее A примерно на треть, платя 14 МБ индекса против 10 МБ. Ожидаемого удорожания записи у C на этих данных не видно: 0.085 с против 0.084 с на 10 000 строк — разница в пределах шума, потому что засеянные тексты короткие и однотипные. B пишет быстрее всех (0.078 с) просто потому, что его индекс меньше. +**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 32 675 строк ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 2300 раз (2461 мс против 1.05 мс), и отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 54) и на серии страниц быстрее A примерно на треть (0.72 мс против 1.05 мс); по одной странице времена A и C различать нельзя — 0.042 и 0.056 мс лежат в пределах разброса единичного замера, поэтому вывод делается по серии и по числу буферов. Цена C — индекс 14 МБ против 11 МБ; разницы во времени вставки между A и C на этих данных не видно (0.086 с против 0.084 с). B пишет быстрее всех (0.078 с) просто потому, что его индекс меньше. **Вывод.** В схему взят вариант A: постоянная цена страницы при умеренном размере индекса. C даёт измеримый выигрыш по буферам и по серии страниц и остаётся кандидатом, если история читается существенно чаще, чем пишется; прежде чем переключаться, его цену записи нужно перемерять на длинных текстах, где дублирование текста в индексе должно проявиться. Переключение — одна миграция. @@ -155,28 +157,29 @@ docker compose --env-file .env start valkey | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.6 МБ | бэкап 0.761 с | -| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 74/74, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 43/43; md5 истории большого чата (32 944 строки) `6c6725a76404fbb0b8b5b509707e30b5` в обеих базах; первые три сообщения совпали | восстановление 0.370 с; потерь на момент снимка нет | +| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.7 МБ | бэкап 0.741 с | +| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 76/76, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 45/45; md5 истории большого чата (36 305 строк) `1841fdf890f6207bc78cb973bedeec27` в обеих базах; первые три сообщения совпали | восстановление 0.357 с; потерь на момент снимка нет | | Запись после снимка (маркерное сообщение) | в копии отсутствует | в источнике 1 маркер, в восстановленной копии 0 | потеряно всё, подтверждённое после начала дампа | | Рестарт API и обоих хранилищ с сохранением томов | данные и действующая сессия живы | `PASS` публичного persistence-теста: тот же токен читает ту же историю, дублей нет | простой до readiness < 10 с, потерь нет | -| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 691.7 RPS против 1097.7 RPS, p95 8.15 мс против 6.06 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×1.6 | +| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 550.9 RPS против 1209.7 RPS, p95 9.41 мс против 4.57 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×2.2 | | Остановка PostgreSQL | ограниченная ошибка, доверия нет | `/health/ready` 503, регистрация 503, неизвестный токен → 503/401, анонимный → 401, `/health/live` 200 | запись недоступна полностью до возврата БД | | Заморозка PostgreSQL (`docker compose pause`) | быстрый 503, а не зависший запрос | 503 быстрее 10 с при потолке запроса 8 с; после `unpause` доступ восстановился | потерь нет | | Рестарт Valkey после подтверждённого logout | отозванный токен остаётся мёртвым | 401 после рестарта кэша | потерь нет | +| Удаление ключа сессии из кэша | ответ из PostgreSQL совпадает с кэшированным, ключ восстановлен с TTL | тело идентично, `EXISTS` = 1, TTL 30 с | потерь нет | -**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 32 944 успешных POST, 0 ошибок, 1097.706 RPS, p50 3.248 / p95 6.063 / p99 10.603 мс. С остановленным Valkey: 20 775 успешных POST, 0 ошибок, 691.741 RPS, p50 5.447 / p95 8.152 / p99 11.778 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда. +**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 36 305 успешных POST, 0 ошибок, 1209.659 RPS, p50 3.130 / p95 4.568 / p99 6.509 мс. С остановленным Valkey: 16 537 успешных POST, 0 ошибок, 550.943 RPS, p50 6.908 / p95 9.405 / p99 12.388 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда. -**Ограничения измерений.** Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до `VACUUM` — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам. +**Ограничения измерений.** Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. По одной странице времена вариантов A и C неразличимы, поэтому для них опорой служат серия из 100 страниц и число буферов. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до `VACUUM` — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам. ## Ограничения и следующие шаги -**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 1.7 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть. +**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 2.2 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть. **Какие отказы не выдерживаются.** PostgreSQL — единственная точка истины без реплики: при потере тома `pgdata` данные восстанавливаются только из дампа, то есть теряется всё после последнего `pg_dump`. WAL-архивирование и PITR не настроены, непрерывного бэкапа нет. API — один экземпляр, балансировщика нет (это тема lab3), поэтому его перезапуск — простой сервиса, а не бесшовное переключение. Rate limiting по пользователю и HTTPS в объём lab2 не входят. **Учебные упрощения.** Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в `bytea` усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (`load_*` пользователи, `load chat *`) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов. -**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 1950 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.085 с против 0.084 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось). +**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 2300 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.085 с против 0.084 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось). **Следующие шаги.** Настроить WAL-архивирование и проверить PITR с восстановлением на момент времени; добавить реплику PostgreSQL и измерить переключение; подобрать `DB_POOL_MAX` и профиль Argon2id под целевой p95; перенести эксперименты на отдельную базу; в lab3 добавить балансировщик и идемпотентность записи. diff --git a/app/sessions.py b/app/sessions.py index 4fae2bcd..c257316b 100644 --- a/app/sessions.py +++ b/app/sessions.py @@ -7,7 +7,7 @@ from typing import Optional import valkey.asyncio as valkey -from app import config +from app import config, repo from app.cursor import fmt from app.errors import unavailable @@ -74,12 +74,7 @@ class SessionStore: row = await cur.fetchone() if row is None: return None - user = { - "id": str(row["id"]), - "username": row["username"], - "display_name": row["display_name"], - "created_at": fmt(row["created_at"]), - } + user = repo.public_user(row) await self._cache_put(digest, user, row["expires_at"]) return user @@ -119,8 +114,9 @@ class SessionStore: ttl = self._cache_ttl(expires_at) if ttl <= 0: return + payload = json.dumps(user) try: - await self.client.set(self.key(digest), json.dumps(user), ex=ttl) + await self.client.set(self.key(digest), payload, ex=ttl) except Exception: self._cache_failed("set") diff --git a/evidence/dependency.txt b/evidence/dependency.txt index d1c33172..f47c5c87 100644 --- a/evidence/dependency.txt +++ b/evidence/dependency.txt @@ -13,7 +13,7 @@ PASS readiness_ignores_the_cache === 2. Останавливаю PostgreSQL === Container mtusi-lab2-postgres-1 Stopping Container mtusi-lab2-postgres-1 Stopped -api Up 31 seconds (healthy) +api Up 32 seconds (healthy) valkey Up Less than a second (health: starting) PASS readiness_reports_the_outage PASS writes_fail_with_503 @@ -25,5 +25,5 @@ PASS login_fails_closed === 3. Состояние восстановлено === api Up 38 seconds (healthy) -postgres Up Less than a second (health: starting) +postgres Up 3 seconds (health: starting) valkey Up 7 seconds (healthy) diff --git a/evidence/explain-10k.txt b/evidence/explain-10k.txt index 484df0a1..967e5acc 100644 --- a/evidence/explain-10k.txt +++ b/evidence/explain-10k.txt @@ -7,7 +7,7 @@ valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682f === Засев 10000 сообщений с неравномерными чатами === seed_duration | seeded_rows | target_total | messages_total -----------------+-------------+--------------+---------------- - 00:00:00.001309 | 0 | 10000 | 53764 + 00:00:00.000975 | 0 | 10000 | 52887 (1 row) @@ -19,70 +19,70 @@ valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682f messages_total | chats_with_messages | table_size | indexes_size ----------------+---------------------+------------+-------------- - 53764 | 14 | 5368 kB | 6320 kB + 52887 | 14 | 5280 kB | 7024 kB (1 row) --- распределение истории по чатам: 5 самых больших и 5 самых маленьких --- chat_id | rows --------------------------------------+------- - e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32 | 32944 - c995246c-35ed-422d-b097-c71f8829a0e0 | 20775 - d73dc509-7b93-4fc3-b6de-b7079bcc294f | 25 - 7485e75e-455e-4a7b-b164-3dbc84099fc0 | 5 - 63d536a7-78d4-4502-92fa-9bbac4e7c5c4 | 3 + 174a0477-1fd5-47a9-ab90-ee8b7ef903af | 36305 + fb87d20c-528a-4bb7-9cd5-e1d4486bdfca | 16537 + 3e751b33-08b7-4433-a2be-bb355af7bf62 | 25 + 11bd8f2b-db27-4c63-89f0-469ee53c6cad | 5 + 30e5554f-e2e0-411e-b5bd-ab86e1fd9c5f | 3 (5 rows) chat_id | rows --------------------------------------+------ - 143b0ced-4c1a-4742-a4ad-02c4b606ba0f | 1 - b4faa937-91fc-4f41-b25e-f3f692878c1f | 1 - 84d473db-544b-4a24-995b-43a4852c68ab | 1 - 574fc146-1610-484a-85a9-cb084afa7d28 | 1 - 836ed5bf-8ccb-419e-96d5-2c4fe7342292 | 1 + b490286c-39b8-4940-92cf-23817def915a | 1 + 6fc32369-98df-4387-b07f-00dfa6e0b391 | 1 + f4c1fdcc-0ddd-4fb5-a962-c8901deac9e2 | 1 + 903d0035-1bda-4ac6-9fbf-52f28fe0b94c | 1 + fb6df905-d5d2-4300-b74f-1f0196f9e2b0 | 1 (5 rows) --- A. keyset, первая страница самого большого чата --- QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.41..6.89 rows=50 width=67) (actual time=0.006..0.016 rows=50 loops=1) - Buffers: shared hit=24 - -> Index Scan using messages_history_idx on messages (cost=0.41..4269.16 rows=32968 width=67) (actual time=0.006..0.014 rows=50 loops=1) - Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) - Buffers: shared hit=24 + Limit (cost=0.41..5.46 rows=50 width=67) (actual time=0.005..0.011 rows=50 loops=1) + Buffers: shared hit=21 + -> Index Scan using messages_history_idx on messages (cost=0.41..3662.26 rows=36288 width=67) (actual time=0.005..0.009 rows=50 loops=1) + Index Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) + Buffers: shared hit=21 Planning: - Buffers: shared hit=6 - Planning Time: 0.046 ms - Execution Time: 0.026 ms + Buffers: shared hit=8 + Planning Time: 0.049 ms + Execution Time: 0.018 ms (9 rows) --- B. keyset, страница на глубине 90% истории (так работает cursor API) --- QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.41..11.51 rows=50 width=67) (actual time=0.017..0.025 rows=50 loops=1) - Buffers: shared hit=53 - -> Index Scan using messages_history_idx on messages (cost=0.41..3272.65 rows=14746 width=67) (actual time=0.017..0.023 rows=50 loops=1) - Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))) - Buffers: shared hit=53 - Planning Time: 0.027 ms - Execution Time: 0.063 ms + Limit (cost=0.41..8.17 rows=50 width=67) (actual time=0.006..0.014 rows=50 loops=1) + Buffers: shared hit=54 + -> Index Scan using messages_history_idx on messages (cost=0.41..2148.72 rows=13857 width=67) (actual time=0.005..0.012 rows=50 loops=1) + Index Cond: ((chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid))) + Buffers: shared hit=54 + Planning Time: 0.022 ms + Execution Time: 0.034 ms (7 rows) --- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) --- QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=3839.41..3845.89 rows=50 width=67) (actual time=4.152..4.159 rows=50 loops=1) - Buffers: shared hit=29813 - -> Index Scan using messages_history_idx on messages (cost=0.41..4269.16 rows=32968 width=67) (actual time=0.008..3.474 rows=29699 loops=1) - Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) - Buffers: shared hit=29813 - Planning Time: 0.018 ms - Execution Time: 4.172 ms + Limit (cost=3297.57..3302.61 rows=50 width=67) (actual time=4.132..4.139 rows=50 loops=1) + Buffers: shared hit=33082 + -> Index Scan using messages_history_idx on messages (cost=0.41..3662.26 rows=36288 width=67) (actual time=0.012..3.519 rows=32724 loops=1) + Index Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) + Buffers: shared hit=33082 + Planning Time: 0.020 ms + Execution Time: 4.146 ms (7 rows) --- индексы таблицы messages --- index | size | scans ----------------------+---------+------- - messages_history_idx | 4072 kB | 12 - messages_pkey | 2248 kB | 0 + messages_history_idx | 4720 kB | 12 + messages_pkey | 2304 kB | 0 (2 rows) diff --git a/evidence/git-hygiene.txt b/evidence/git-hygiene.txt index efee0f42..df9f81d7 100644 --- a/evidence/git-hygiene.txt +++ b/evidence/git-hygiene.txt @@ -1,30 +1,19 @@ - M .env.example - M Makefile M REPORT.md -?? .github/workflows/app.yml -?? Dockerfile -?? app/ -?? compose.yaml -?? evidence/dependency.txt -?? evidence/expiry.txt -?? evidence/explain-10k.txt -?? evidence/git-hygiene.txt -?? evidence/level4-tests.txt -?? evidence/load-cache.json -?? evidence/load-nocache.json -?? evidence/load.txt -?? evidence/migrations.txt -?? evidence/outages.txt -?? evidence/persistence.txt -?? evidence/smoke.txt -?? evidence/stand.txt -?? evidence/track2/ -?? migrations/ -?? requirements.txt -?? scripts/bootstrap.sh -?? scripts/migrate.py -?? scripts/restart.sh -?? student-tests/ + M app/sessions.py + M evidence/dependency.txt + M evidence/explain-10k.txt + M evidence/git-hygiene.txt + M evidence/load-cache.json + M evidence/load-nocache.json + M evidence/load.txt + M evidence/migrations.txt + M evidence/outages.txt + M evidence/persistence.txt + M evidence/stand.txt + M evidence/track2/run.txt + M scripts/bootstrap.sh + M student-tests/evidence.sh + M student-tests/test_outages.py --- правила игнорирования --- .gitignore:2:.env .env .gitignore:5:secrets/ secrets/database_url diff --git a/evidence/load-cache.json b/evidence/load-cache.json index e8babd6c..47bf2fb9 100644 --- a/evidence/load-cache.json +++ b/evidence/load-cache.json @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.012, + "elapsed_seconds": 30.013, "concurrency": 4, - "successful_requests": 32944, + "successful_requests": 36305, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 1097.706, + "successful_rps": 1209.659, "successful_latency_ms": { - "p50": 3.248, - "p95": 6.063, - "p99": 10.603 + "p50": 3.13, + "p95": 4.568, + "p99": 6.509 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/load-nocache.json b/evidence/load-nocache.json index 376f4e77..660666da 100644 --- a/evidence/load-nocache.json +++ b/evidence/load-nocache.json @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.033, + "elapsed_seconds": 30.016, "concurrency": 4, - "successful_requests": 20775, + "successful_requests": 16537, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 691.741, + "successful_rps": 550.943, "successful_latency_ms": { - "p50": 5.447, - "p95": 8.152, - "p99": 11.778 + "p50": 6.908, + "p95": 9.405, + "p99": 12.388 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/load.txt b/evidence/load.txt index a0ad4007..11b0fe6d 100644 --- a/evidence/load.txt +++ b/evidence/load.txt @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.012, + "elapsed_seconds": 30.013, "concurrency": 4, - "successful_requests": 32944, + "successful_requests": 36305, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 1097.706, + "successful_rps": 1209.659, "successful_latency_ms": { - "p50": 3.248, - "p95": 6.063, - "p99": 10.603 + "p50": 3.13, + "p95": 4.568, + "p99": 6.509 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } @@ -19,16 +19,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.033, + "elapsed_seconds": 30.016, "concurrency": 4, - "successful_requests": 20775, + "successful_requests": 16537, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 691.741, + "successful_rps": 550.943, "successful_latency_ms": { - "p50": 5.447, - "p95": 8.152, - "p99": 11.778 + "p50": 6.908, + "p95": 9.405, + "p99": 12.388 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/migrations.txt b/evidence/migrations.txt index f1a3e852..f2ce92aa 100644 --- a/evidence/migrations.txt +++ b/evidence/migrations.txt @@ -5,8 +5,8 @@ migrate-1 | migrations complete: 1 file(s) Container mtusi-lab2-postgres-1 Running Container mtusi-lab2-postgres-1 Waiting Container mtusi-lab2-postgres-1 Healthy - Container mtusi-lab2-migrate-run-d04acc691283 Creating - Container mtusi-lab2-migrate-run-d04acc691283 Created + Container mtusi-lab2-migrate-run-6c5706582141 Creating + Container mtusi-lab2-migrate-run-6c5706582141 Created skip 0001_init migrations complete: 1 file(s) --- схема --- @@ -30,6 +30,6 @@ Access method: heap version | checksum | applied_at -----------+------------------------------------------------------------------+------------------------------- - 0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-19 15:50:30.673311+00 + 0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-23 14:36:13.656522+00 (1 row) diff --git a/evidence/outages.txt b/evidence/outages.txt index 1058d561..7e7b0c00 100644 --- a/evidence/outages.txt +++ b/evidence/outages.txt @@ -1,5 +1,7 @@ PASS revoked_session_stays_revoked_after_cache_restart PASS logout_is_not_confirmed_while_cache_is_down PASS cached_sessions_do_not_cross_users +PASS cache_is_repopulated_after_a_miss +PASS cache_survives_its_own_restart PASS hung_database_fails_fast -4/4 checks passed +6/6 checks passed diff --git a/evidence/persistence.txt b/evidence/persistence.txt index 99d3c113..28cd5941 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -1,6 +1,6 @@ --- состояние контейнеров до рестарта --- -api Up 38 seconds (healthy) -postgres Up Less than a second (health: starting) +api Up 39 seconds (healthy) +postgres Up 3 seconds (health: starting) valkey Up 7 seconds (healthy) python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. @@ -10,9 +10,9 @@ api Up Less than a second (health: starting) postgres Up Less than a second (health: starting) valkey Up Less than a second (health: starting) --- логи postgres о перезапуске --- -postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit -postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432 -postgres-1 | 2026-10-19 15:51:09.945 UTC [1] LOG: listening on IPv6 address "::", port 5432 -postgres-1 | 2026-10-19 15:51:09.946 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432" -postgres-1 | 2026-10-19 15:51:09.949 UTC [29] LOG: database system was shut down at 2026-10-19 15:51:09 UTC -postgres-1 | 2026-10-19 15:51:09.951 UTC [1] LOG: database system is ready to accept connections +postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit +postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432 +postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: listening on IPv6 address "::", port 5432 +postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432" +postgres-1 | 2026-10-23 14:36:53.366 UTC [29] LOG: database system was shut down at 2026-10-23 14:36:53 UTC +postgres-1 | 2026-10-23 14:36:53.368 UTC [1] LOG: database system is ready to accept connections diff --git a/evidence/stand.txt b/evidence/stand.txt index 09af0175..7d25bad0 100644 --- a/evidence/stand.txt +++ b/evidence/stand.txt @@ -6,3 +6,11 @@ postgres postgres:17.7-alpine@sha256:bb377b7239d2774ac8cc76f481596ce96c5a6b5e9d1 valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682fd35e1ebb4b0990a4a4a8507 Up 7 seconds (healthy) PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit Valkey server v=8.1.10 sha=00000000:1 malloc=jemalloc-5.3.0 bits=64 build=2cb63ac0e4567989 +--- строка старта API: действующие лимиты и TTL --- +api-1 | INFO: Waiting for application startup. +api-1 | 2026-10-23 14:36:14,347 INFO messenger started: instance=9b4feca99e44 session_store=postgres session_ttl=3600 cache_ttl=30 pool=1..10 max_inflight=64 max_body=65536 +api-1 | INFO: Application startup complete. +api-1 | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit) +api-1 | INFO: 172.18.0.1:56506 - "GET /health/ready HTTP/1.1" 200 OK +--- сверка .env с .env.example --- +ready: .env and secrets/ created locally; they stay out of Git diff --git a/evidence/track2/run.txt b/evidence/track2/run.txt index 4f2ca729..3e5e8e7d 100644 --- a/evidence/track2/run.txt +++ b/evidence/track2/run.txt @@ -6,9 +6,9 @@ Darwin arm64 Docker version 29.7.2, build a7dcaa6 === 1. Засев истории: цель 120000 сообщений, чаты неравномерные === - seed_duration | seeded_rows | target_total | messages_total -----------------+-------------+--------------+---------------- - 00:00:00.63315 | 66236 | 120000 | 120000 + seed_duration | seeded_rows | target_total | messages_total +-----------------+-------------+--------------+---------------- + 00:00:00.616654 | 67113 | 120000 | 120000 (1 row) @@ -21,20 +21,20 @@ Docker version 29.7.2, build a7dcaa6 ############ Вариант A: messages_history_idx (chat_id, created_at, id) ############ index_size ------------ - 10 MB + 11 MB (1 row) QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.42..37.36 rows=50 width=89) (actual time=0.015..0.025 rows=50 loops=1) - Buffers: shared hit=53 - -> Index Scan using messages_history_idx on messages (cost=0.42..5594.06 rows=7570 width=89) (actual time=0.014..0.022 rows=50 loops=1) - Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))) - Buffers: shared hit=53 + Limit (cost=0.42..47.47 rows=50 width=90) (actual time=0.009..0.020 rows=50 loops=1) + Buffers: shared hit=54 + -> Index Scan using messages_history_idx on messages (cost=0.42..6827.62 rows=7255 width=90) (actual time=0.008..0.018 rows=50 loops=1) + Index Cond: ((chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid))) + Buffers: shared hit=54 Planning: - Buffers: shared hit=17 - Planning Time: 0.098 ms - Execution Time: 0.048 ms + Buffers: shared hit=19 + Planning Time: 0.086 ms + Execution Time: 0.042 ms (9 rows) pages_measured @@ -44,12 +44,12 @@ Docker version 29.7.2, build a7dcaa6 hundred_pages_duration ------------------------ - 00:00:00.001121 + 00:00:00.00105 (1 row) insert_10k_duration --------------------- - 00:00:00.083689 + 00:00:00.083522 (1 row) ############ Вариант B: только (chat_id) ############ @@ -60,30 +60,30 @@ Docker version 29.7.2, build a7dcaa6 QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------ - Limit (cost=3134.85..3134.97 rows=50 width=89) (actual time=1.691..1.695 rows=50 loops=1) - Buffers: shared hit=411 read=30 - I/O Timings: shared read=0.076 - -> Sort (cost=3134.85..3153.65 rows=7522 width=89) (actual time=1.691..1.692 rows=50 loops=1) + Limit (cost=3231.76..3231.89 rows=50 width=90) (actual time=1.856..1.860 rows=50 loops=1) + Buffers: shared hit=451 read=33 + I/O Timings: shared read=0.074 + -> Sort (cost=3231.76..3249.63 rows=7146 width=90) (actual time=1.855..1.857 rows=50 loops=1) Sort Key: created_at, id Sort Method: top-N heapsort Memory: 33kB - Buffers: shared hit=411 read=30 - I/O Timings: shared read=0.076 - -> Bitmap Heap Scan on messages (cost=368.71..2884.97 rows=7522 width=89) (actual time=1.378..1.560 rows=3294 loops=1) - Recheck Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) - Filter: (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid)) - Rows Removed by Filter: 29650 - Heap Blocks: exact=411 - Buffers: shared hit=411 read=30 - I/O Timings: shared read=0.076 - -> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..366.83 rows=32872 width=0) (actual time=0.333..0.333 rows=32944 loops=1) - Index Cond: (chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) - Buffers: shared read=30 - I/O Timings: shared read=0.076 + Buffers: shared hit=451 read=33 + I/O Timings: shared read=0.074 + -> Bitmap Heap Scan on messages (cost=408.67..2994.38 rows=7146 width=90) (actual time=1.514..1.710 rows=3630 loops=1) + Recheck Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) + Filter: (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid)) + Rows Removed by Filter: 32675 + Heap Blocks: exact=451 + Buffers: shared hit=451 read=33 + I/O Timings: shared read=0.074 + -> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..406.88 rows=36612 width=0) (actual time=0.362..0.362 rows=36305 loops=1) + Index Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) + Buffers: shared read=33 + I/O Timings: shared read=0.074 Planning: - Buffers: shared hit=26 read=1 + Buffers: shared hit=28 read=1 I/O Timings: shared read=0.009 - Planning Time: 0.130 ms - Execution Time: 1.728 ms + Planning Time: 0.126 ms + Execution Time: 1.879 ms (24 rows) pages_measured @@ -93,12 +93,12 @@ Docker version 29.7.2, build a7dcaa6 hundred_pages_duration ------------------------ - 00:00:02.186353 + 00:00:02.460907 (1 row) insert_10k_duration --------------------- - 00:00:00.078473 + 00:00:00.077769 (1 row) ############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############ @@ -109,19 +109,19 @@ Docker version 29.7.2, build a7dcaa6 QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.42..34.19 rows=50 width=89) (actual time=0.017..0.021 rows=50 loops=1) + Limit (cost=0.42..43.36 rows=50 width=90) (actual time=0.039..0.045 rows=50 loops=1) Buffers: shared hit=1 read=3 - I/O Timings: shared read=0.006 - -> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..5110.68 rows=7565 width=89) (actual time=0.016..0.019 rows=50 loops=1) - Index Cond: ((chat_id = 'e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-19 15:51:38.025965+00'::timestamp with time zone, '0375fd16-e024-4391-93a5-0d5a1a21786d'::uuid))) + I/O Timings: shared read=0.012 + -> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..6095.87 rows=7098 width=90) (actual time=0.038..0.041 rows=50 loops=1) + Index Cond: ((chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid))) Heap Fetches: 0 Buffers: shared hit=1 read=3 - I/O Timings: shared read=0.006 + I/O Timings: shared read=0.012 Planning: - Buffers: shared hit=28 read=1 - I/O Timings: shared read=0.005 - Planning Time: 0.184 ms - Execution Time: 0.031 ms + Buffers: shared hit=29 read=1 + I/O Timings: shared read=0.007 + Planning Time: 0.144 ms + Execution Time: 0.056 ms (13 rows) pages_measured @@ -131,12 +131,12 @@ Docker version 29.7.2, build a7dcaa6 hundred_pages_duration ------------------------ - 00:00:00.000744 + 00:00:00.000723 (1 row) insert_10k_duration --------------------- - 00:00:00.084611 + 00:00:00.085783 (1 row) ############ Схема после эксперимента (ROLLBACK вернул индексы) ############ @@ -147,7 +147,7 @@ Docker version 29.7.2, build a7dcaa6 (2 rows) -Самый большой чат: e8b55eec-ce6b-4cc4-9003-e6f1f33ddd32 +Самый большой чат: 174a0477-1fd5-47a9-ab90-ee8b7ef903af === 3. Состояние источника до бэкапа === relation | rows @@ -155,20 +155,20 @@ Docker version 29.7.2, build a7dcaa6 chat_members | 1036 chats | 68 messages | 120000 - sessions | 43 - users | 74 + sessions | 45 + users | 76 (5 rows) big_chat_rows | big_chat_md5 ---------------+---------------------------------- - 32944 | 6c6725a76404fbb0b8b5b509707e30b5 + 36305 | 1841fdf890f6207bc78cb973bedeec27 (1 row) id | created_at | text --------------------------------------+-------------------------------+---------- - 8ecedfe9-56ef-410d-98b3-e3fc414128d9 | 2026-10-19 15:51:11.010631+00 | load-1-0 - 424bfa46-6e49-4b60-8ca3-ac3c3f9be02a | 2026-10-19 15:51:11.011234+00 | load-3-0 - 05b0e1a2-5862-461a-b8aa-1f91f647e18d | 2026-10-19 15:51:11.01201+00 | load-2-0 + 1d15f9ed-952e-45e7-9553-dcd3bc3dd76e | 2026-10-23 14:36:54.449674+00 | load-2-0 + 4bc8c702-07e1-42d2-be14-8cdd6dad31a7 | 2026-10-23 14:36:54.450312+00 | load-0-0 + 3993ceca-7c29-400d-a1e9-287137672829 | 2026-10-23 14:36:54.450773+00 | load-1-0 (3 rows) marker_rows @@ -178,8 +178,8 @@ Docker version 29.7.2, build a7dcaa6 === 4. Бэкап pg_dump -Fc === -backup_seconds=0.761 -dump_size=5.6M +backup_seconds=0.741 +dump_size=5.7M === 5. Запись после бэкапа: граница потери данных === в источнике маркеров: 1 @@ -188,7 +188,7 @@ dump_size=5.6M /var/run/postgresql:5432 - accepting connections === 7. Восстановление в новое хранилище === -restore_seconds=0.370 +restore_seconds=0.357 === 8. Сверка восстановленной копии === relation | rows @@ -196,20 +196,20 @@ restore_seconds=0.370 chat_members | 1036 chats | 68 messages | 120000 - sessions | 43 - users | 74 + sessions | 45 + users | 76 (5 rows) big_chat_rows | big_chat_md5 ---------------+---------------------------------- - 32944 | 6c6725a76404fbb0b8b5b509707e30b5 + 36305 | 1841fdf890f6207bc78cb973bedeec27 (1 row) id | created_at | text --------------------------------------+-------------------------------+---------- - 8ecedfe9-56ef-410d-98b3-e3fc414128d9 | 2026-10-19 15:51:11.010631+00 | load-1-0 - 424bfa46-6e49-4b60-8ca3-ac3c3f9be02a | 2026-10-19 15:51:11.011234+00 | load-3-0 - 05b0e1a2-5862-461a-b8aa-1f91f647e18d | 2026-10-19 15:51:11.01201+00 | load-2-0 + 1d15f9ed-952e-45e7-9553-dcd3bc3dd76e | 2026-10-23 14:36:54.449674+00 | load-2-0 + 4bc8c702-07e1-42d2-be14-8cdd6dad31a7 | 2026-10-23 14:36:54.450312+00 | load-0-0 + 3993ceca-7c29-400d-a1e9-287137672829 | 2026-10-23 14:36:54.450773+00 | load-1-0 (3 rows) marker_rows @@ -219,9 +219,9 @@ restore_seconds=0.370 === 9. Итог === -backup_seconds=0.761 restore_seconds=0.370 +backup_seconds=0.741 restore_seconds=0.357 messages_source_without_marker=120000 messages_restored=120000 -big_chat_md5_source=6c6725a76404fbb0b8b5b509707e30b5 -big_chat_md5_restored=6c6725a76404fbb0b8b5b509707e30b5 +big_chat_md5_source=1841fdf890f6207bc78cb973bedeec27 +big_chat_md5_restored=1841fdf890f6207bc78cb973bedeec27 RESULT: восстановленная копия совпадает с источником на момент бэкапа маркеров после бэкапа в восстановленной копии: 0 (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует) diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh index ea4db66d..073319ba 100755 --- a/scripts/bootstrap.sh +++ b/scripts/bootstrap.sh @@ -2,7 +2,32 @@ set -eu cd "$(dirname "$0")/.." -[ -f .env ] || cp .env.example .env +if [ -f .env ]; then + added=$(python3 - <<'PYEOF' +def pairs(path): + result = [] + for line in open(path, encoding="utf-8"): + stripped = line.strip() + if stripped and not stripped.startswith("#") and "=" in stripped: + result.append((stripped.split("=", 1)[0], line.rstrip("\n"))) + return result + +present = {name for name, _ in pairs(".env")} +missing = [line for name, line in pairs(".env.example") if name not in present] +if missing: + with open(".env", "a", encoding="utf-8") as handle: + handle.write("\n# Добавлено bootstrap из .env.example\n") + for line in missing: + handle.write(line + "\n") +print(" ".join(line.split("=", 1)[0] for line in missing)) +PYEOF +) + if [ -n "$added" ]; then + echo "в .env добавлены отсутствующие переменные: $added" + fi +else + cp .env.example .env +fi mkdir -p secrets if [ ! -f secrets/postgres_password ]; then python3 -c "import secrets; print(secrets.token_urlsafe(24))" > secrets/postgres_password diff --git a/student-tests/evidence.sh b/student-tests/evidence.sh index 1ab3112a..d4406b36 100755 --- a/student-tests/evidence.sh +++ b/student-tests/evidence.sh @@ -34,6 +34,10 @@ wait_ready $COMPOSE ps --format '{{.Service}} {{.Image}} {{.Status}}' $COMPOSE exec -T postgres psql -U messenger -d messenger -t -A -c 'select version()' $COMPOSE exec -T valkey valkey-server --version + echo '--- строка старта API: действующие лимиты и TTL ---' + $COMPOSE logs api --tail=5 + echo '--- сверка .env с .env.example ---' + sh scripts/bootstrap.sh } > "$OUT/stand.txt" 2>&1 cat "$OUT/stand.txt" diff --git a/student-tests/test_outages.py b/student-tests/test_outages.py index b9caa3ba..cc5b63cb 100644 --- a/student-tests/test_outages.py +++ b/student-tests/test_outages.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 """Level 4/5: revocation must outlive the cache and outages must never grant trust.""" +import hashlib import pathlib import subprocess import time @@ -14,6 +15,16 @@ def compose(*args): subprocess.run(COMPOSE + list(args), cwd=str(ROOT), check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) +def valkey(*args): + done = subprocess.run(COMPOSE + ["exec", "-T", "valkey", "valkey-cli", *args], + cwd=str(ROOT), capture_output=True, text=True, check=True) + return done.stdout.strip() + + +def session_key(token): + return "session:" + hashlib.sha256(token.encode("utf-8")).hexdigest() + + def wait_ready(base, seconds=90): deadline = time.monotonic() + seconds while time.monotonic() < deadline: @@ -58,7 +69,7 @@ def cached_sessions_do_not_cross_users(base): for _ in range(3): first = call(base, "GET", "/api/v1/users/me", token=alice["token"])["json"] second = call(base, "GET", "/api/v1/users/me", token=bob["token"])["json"] - expect(first["id"] == alice["id"] and second["id"] == bob["id"], "кэш перепутал владельцев сессий") + expect(first == alice["user"] and second == bob["user"], "кэш отдал не того владельца сессии: %r / %r" % (first, second)) chat = chat_with(base, alice, bob) sent = call(base, "POST", "/api/v1/chats/%s/messages" % chat["id"], body={"text": "от боба"}, token=bob["token"]) expect(sent["json"]["sender_id"] == bob["id"], "sender_id взят не из сессии") @@ -82,10 +93,41 @@ def hung_database_fails_fast(base): expect(call(base, "GET", "/api/v1/chats", token=actor["token"])["status"] == 200, "после возврата БД доступ не восстановился") +def cache_is_repopulated_after_a_miss(base): + actor = member(base, "miss") + key = session_key(actor["token"]) + cached = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(cached["status"] == 200, "свежая сессия дала %s" % cached["status"]) + expect(valkey("exists", key) == "1", "после входа сессии нет в кэше") + expect(valkey("del", key) == "1", "ключ сессии не удалился") + served = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(served["status"] == 200, "после промаха кэша ответ %s" % served["status"]) + expect(served["json"] == cached["json"], "тело из PostgreSQL отличается от кэшированного: %r против %r" % (served["json"], cached["json"])) + expect(valkey("exists", key) == "1", "кэш не наполнился после промаха") + ttl = int(valkey("ttl", key)) + expect(ttl > 0, "у восстановленного ключа нет срока жизни: ttl=%d" % ttl) + again = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(again["json"] == cached["json"], "ответ из восстановленного кэша отличается: %r" % again["json"]) + + +def cache_survives_its_own_restart(base): + actor = member(base, "warm") + expected = call(base, "GET", "/api/v1/users/me", token=actor["token"])["json"] + compose("restart", "valkey") + wait_ready(base) + key = session_key(actor["token"]) + expect(valkey("exists", key) == "0", "кэш переживает рестарт, хотя persistence выключен") + after = call(base, "GET", "/api/v1/users/me", token=actor["token"]) + expect(after["status"] == 200 and after["json"] == expected, "после рестарта кэша ответ изменился: %r" % after["json"]) + expect(valkey("exists", key) == "1", "после рестарта кэш больше не наполняется") + + TESTS = [ revoked_session_stays_revoked_after_cache_restart, logout_is_not_confirmed_while_cache_is_down, cached_sessions_do_not_cross_users, + cache_is_repopulated_after_a_miss, + cache_survives_its_own_restart, hung_database_fails_fast, ] -- 2.54.0 From 4ee3cbb4eacef36c76f7ed3225a0f509fabf1c17 Mon Sep 17 00:00:00 2001 From: alenchha Date: Fri, 23 Oct 2026 23:15:21 +0300 Subject: [PATCH 4/4] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=D0=B8=D0=B5=20=D0=BF=D0=BE=20=D0=B7=D0=B0=D0=BC?= =?UTF-8?q?=D0=B5=D1=87=D0=B0=D0=BD=D0=B8=D1=8E:=20=D0=BE=D1=82=D0=B7?= =?UTF-8?q?=D1=8B=D0=B2=20=D1=81=D0=B5=D1=81=D1=81=D0=B8=D0=B8=20=D0=B2?= =?UTF-8?q?=D1=8B=D0=B4=D0=B5=D1=80=D0=B6=D0=B8=D0=B2=D0=B0=D0=B5=D1=82=20?= =?UTF-8?q?=D0=B3=D0=BE=D0=BD=D0=BA=D1=83=20=D1=81=20=D0=BD=D0=B0=D0=BF?= =?UTF-8?q?=D0=BE=D0=BB=D0=BD=D0=B5=D0=BD=D0=B8=D0=B5=D0=BC=20=D0=BA=D1=8D?= =?UTF-8?q?=D1=88=D0=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 2 + REPORT.md | 38 ++++++----- app/config.py | 4 ++ app/sessions.py | 31 +++++++-- evidence/dependency.txt | 12 ++-- evidence/explain-10k.txt | 70 ++++++++++---------- evidence/git-hygiene.txt | 32 ++++----- evidence/load-cache.json | 12 ++-- evidence/load-nocache.json | 12 ++-- evidence/load.txt | 24 +++---- evidence/migrations.txt | 6 +- evidence/outages.txt | 4 +- evidence/persistence.txt | 18 ++--- evidence/stand.txt | 4 +- evidence/track2/run.txt | 120 +++++++++++++++++----------------- student-tests/test_outages.py | 78 ++++++++++++++++++++++ 16 files changed, 288 insertions(+), 179 deletions(-) diff --git a/.env.example b/.env.example index 001b3362..70ea4924 100644 --- a/.env.example +++ b/.env.example @@ -26,4 +26,6 @@ DB_READY_TIMEOUT=1.5 # --- Реализация lab2: кэш сессий в Valkey --- SESSION_CACHE_TTL_SECONDS=30 SESSION_SWEEP_SECONDS=60 +# Надгробие отозванной сессии в кэше: не меньше SESSION_CACHE_TTL_SECONDS + REQUEST_TIMEOUT +SESSION_REVOKED_TTL_SECONDS=60 CACHE_TIMEOUT=0.2 diff --git a/REPORT.md b/REPORT.md index d768bd24..029a6178 100644 --- a/REPORT.md +++ b/REPORT.md @@ -52,6 +52,7 @@ docker compose --env-file .env start valkey | `SESSION_TTL_SECONDS` | срок жизни сессии | 3600 | | `SESSION_CACHE_TTL_SECONDS` | срок жизни записи в кэше сессий | 30 | | `SESSION_SWEEP_SECONDS` | период удаления истёкших сессий из БД | 60 | +| `SESSION_REVOKED_TTL_SECONDS` | срок жизни надгробия отозванной сессии в кэше | 60 | | `SESSION_STORE` | источник истины для сессий | postgres | | `DB_POOL_MIN`, `DB_POOL_MAX` | границы пула соединений | 1, 10 | | `DB_POOL_TIMEOUT`, `DB_CONNECT_TIMEOUT` | ожидание свободного соединения и подключения, с | 3, 3 | @@ -76,7 +77,7 @@ docker compose --env-file .env start valkey **Кэш сессий намеренно без persistence.** У Valkey выключены и RDB (`--save ""`), и AOF (`--appendonly no`). Это не упущение, а требование безопасности: если кэш переживает рестарт, он может воскресить запись об уже отозванной сессии и вернуть доступ по мёртвому токену. С volatile-кэшом после любого рестарта таблица сессий в PostgreSQL остаётся единственным источником правды, и каждый токен проверяется заново. Persistence кэша обязателен только если он единственное хранилище сессий — у нас это не так. -**Отзыв сессии устойчив к кэшу.** `DELETE /auth/sessions/current` сначала удаляет ключ из Valkey и только потом строку из PostgreSQL. Поэтому 204 означает, что токен мёртв в обоих местах; обратного порядка (сначала БД, потом кэш) мы избегаем именно потому, что при сбое второго шага кэш продолжал бы отдавать отозванную сессию. Если кэш недоступен, logout возвращает 503 и сессию не удаляет: выход не подтверждается, пока нельзя гарантировать, что кэш больше не отдаст токен. Клиент повторяет запрос; проверено тестом `logout_is_not_confirmed_while_cache_is_down`. +**Отзыв сессии устойчив к кэшу и к гонке.** `DELETE /auth/sessions/current` сначала пишет в Valkey надгробие — значение `revoked` с собственным TTL — и только потом удаляет строку из PostgreSQL. Простого удаления ключа недостаточно: между удалением ключа и удалением строки параллельный запрос успевает прочитать ещё живую строку и заново положить ключ, и тогда после подтверждённого 204 токен продолжает работать до истечения кэша. Надгробие закрывает это окно, потому что наполнение кэша после промаха выполняется условно (`SET … NX`) и не может перезаписать надгробие, а `resolve` трактует это значение как «сессии нет» без похода в базу. TTL надгробия не меньше суммы срока жизни кэша и потолка запроса, поэтому ни один начатый до отзыва запрос не успеет положить устаревшую копию. Если кэш недоступен, logout возвращает 503 и сессию не удаляет: выход не подтверждается, пока нельзя гарантировать, что кэш больше не отдаст токен. Проверено тестами `logout_is_not_confirmed_while_cache_is_down` и `revoked_session_cannot_be_resurrected_by_a_race` — второй удерживает строку сессии под `SELECT … FOR UPDATE`, чтобы гонка воспроизводилась детерминированно. **Схема и ограничения** (`migrations/0001_init.sql`). `users.username` — `UNIQUE` плюс `CHECK (username ~ '^[a-z0-9_]{3,32}$')`, так что уникальность username гарантирует база, а не только проверка в коде. `chat_members` — таблица связи с `PRIMARY KEY (chat_id, user_id)` и внешними ключами на `chats` и `users`. `messages` ссылается на `chats` и `users`. `sessions` хранит `token_hash bytea PRIMARY KEY`, `user_id`, `created_at`, `expires_at`. @@ -116,15 +117,16 @@ docker compose --env-file .env start valkey | Составная операция создания чата атомарна | `test_storage_rules.py::unknown_member_rolls_chat_back` | 400 на неизвестного участника, чат в списке отсутствует | `evidence/level4-tests.txt` | | Basic только на `POST /auth/sessions`, остальное — Bearer; `X-User-Id` не даёт доступа | `test_auth_sessions.py` | 9/9 PASS, в том числе Basic на `/users/me` → 401 Bearer, вход с телом → 400, повреждённый UTF-8 → 400/401 | `evidence/level4-tests.txt` | | Срок жизни сессии и отзыв | `make expiry` (TTL=2 с) | 3/3 PASS: истёкший токен → 401, запись истёкшим → 401, `expires_at` соответствует TTL | `evidence/expiry.txt` | -| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 6/6 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` | +| Отозванная сессия не возвращается вместе с кэшом | `make outages` | 8/8 PASS; после 204 и `restart valkey` токен даёт 401 | `evidence/outages.txt` | +| Отзыв сессии выдерживает гонку с параллельным запросом | `make outages::revoked_session_cannot_be_resurrected_by_a_race` | строка сессии удерживается `SELECT … FOR UPDATE`, параллельный `/users/me` наполняет кэш во время logout; после 204 токен даёт 401 на чтение и на список чатов | `evidence/outages.txt` | | Кэш наполняется после промаха, а не только при входе | `make outages::cache_is_repopulated_after_a_miss`, `::cache_survives_its_own_restart` | после удаления ключа `session:` ответ 200 из PostgreSQL совпадает с кэшированным телом, ключ восстановлен с TTL; после рестарта Valkey кэш пуст и снова наполняется | `evidence/outages.txt` | | Пароли хешируются password KDF | `app/passwords.py`, формат хеша в БД | `$argon2id$v=19$m=19456,t=2,p=1$…`, в API пароль не возвращается | `evidence/level4-tests.txt` | | Любая строка Unicode сохраняется без искажений | `test_storage_rules.py::nul_and_unicode_text_round_trips`, `::text_length_limit_counts_code_points` | `a\u0000b`, одиночный `\u0000`, emoji с ZWJ, комбинирующие и RTL, 4000 code points — 201 и точный round-trip; 4001 — 400 | `evidence/level4-tests.txt` | | Secrets/volumes не попадают в Git | `git status --porcelain`, `git check-ignore -v` | `.env`, `secrets/`, `backups/` игнорируются; в рабочем дереве только код, тесты и `evidence/` | `evidence/git-hygiene.txt` | -| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1209.7 RPS / p95 4.57 мс против 550.9 RPS / p95 9.41 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` | -| Параметризованные запросы, ограниченный пул и таймауты | `test_storage_rules.py::sql_injection_is_not_executed`, `::content_type_is_required`, `::broken_json_does_not_break_the_api`, `app/db.py` | SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, `statement_timeout=5000`, клиентский лимит 6 с, потолок запроса 8 с | `evidence/level4-tests.txt` | +| Redis/Valkey реально используется для сессий с TTL | `tests/load.py` с кэшем и без него | 1276.0 RPS / p95 4.34 мс против 498.2 RPS / p95 11.46 мс, `failed_requests: 0` в обоих прогонах | `evidence/load-cache.json`, `evidence/load-nocache.json`, `evidence/load.txt` | +| Параметризованные запросы, ограниченный пул и таймауты | `test_storage_rules.py` целиком — 12/12 PASS, в том числе `::sql_injection_is_not_executed`, `::content_type_is_required`, `::broken_json_does_not_break_the_api`; настройки в `app/db.py` | SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, `statement_timeout=5000`, клиентский лимит 6 с, потолок запроса 8 с | `evidence/level4-tests.txt` | | Гонка регистрации одинакового username | `test_storage_rules.py::duplicate_username_race_creates_one_user` (12 потоков) | один 201, одиннадцать 409 | `evidence/level4-tests.txt` | -| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (52 887 сообщений в таблице) | keyset, первая страница: 21 буфер, 0.018 мс; keyset на глубине 90 %: 54 буфера, 0.034 мс; OFFSET той же глубины: 33 082 буфера, 4.15 мс (32 724 строки пройдено ради 50) | `evidence/explain-10k.txt` | +| Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана | `make explain` (53 293 сообщения в таблице) | keyset, первая страница: 24 буфера, 0.021 мс; keyset на глубине 90 %: 53 буфера, 0.032 мс; OFFSET той же глубины: 34 920 буферов, 4.48 мс (34 513 строк пройдено ради 50) | `evidence/explain-10k.txt` | | Проверка expiry, logout, неверного пароля и недоступности Redis/БД | `make dependency`, `make outages` | без Valkey 3/3 PASS (кэш обойдён, ошибок нет); без PostgreSQL 4/4 PASS: `/health/ready` 503, запись 503, неизвестный токен не становится доверенным; зависшая БД (`pause`) отвечает 503 быстрее 10 с | `evidence/dependency.txt`, `evidence/outages.txt` | | Переменные `.env.example` соответствуют реальной конфигурации | `make bootstrap` на существующем `.env`, затем сверка ключей | отсутствующие переменные дописываются из `.env.example`, расхождений по ключам нет | `evidence/stand.txt` (строка `cache_ttl` в логе старта API) | | Трек 5 (трек 2): ≥100 000 сообщений, ≥2 индекса, цена записи, backup → restore → сверка | `TOTAL=120000 make track2` | 120 000 сообщений в 68 чатах; варианты A/B/C сравнены; md5 истории источника и копии совпали; маркер после бэкапа в копии отсутствует | `evidence/track2/run.txt` | @@ -137,15 +139,15 @@ docker compose --env-file .env start valkey **Гипотеза.** Для keyset-пагинации по контракту (`ORDER BY created_at, id` внутри одного чата) составной индекс `(chat_id, created_at, id)` даёт цену страницы, не зависящую от её глубины, а индекс только по `chat_id` вынуждает поднимать из heap всю историю чата на каждую страницу. Покрывающий индекс с `INCLUDE (sender_id, text)` должен убрать обращения к heap, но увеличить размер индекса и цену записи. -**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 67 113 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 36 305 строк в самом большом, 16 537 во втором, затем 25, 5 и 3 — разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый. +**Методика.** Стенд описан выше, PostgreSQL запущен с `shared_buffers=128MB`, `work_mem=8MB`, `track_io_timing=on`. Данные: `student-tests/seed.sql` добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом `power(random(), 3)`; поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 66 707 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 38 293 строки в самом большом, 14 955 во втором, затем 25, 5 и 3 — разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (`BEGIN … ROLLBACK`), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план `EXPLAIN (ANALYZE, BUFFERS)` одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный `LATERAL`: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и `ANALYZE` выполняются до измерений, кэш БД тёплый. | Вариант индекса | План страницы на глубине 90 % | Буферы | Время одной страницы | 100 страниц | Размер индекса | Вставка 10 000 строк | | --- | --- | --- | --- | --- | --- | --- | -| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 54 | 0.042 мс | 1.05 мс | 11 МБ | 0.084 с | -| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 32 675` | 484 | 1.88 мс | 2461 мс | 848 кБ | 0.078 с | -| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.056 мс | 0.72 мс | 14 МБ | 0.086 с | +| A `(chat_id, created_at, id)` — рабочий | `Index Scan using messages_history_idx` | 53 | 0.047 мс | 1.08 мс | 11 МБ | 0.085 с | +| B `(chat_id)` | `Bitmap Heap Scan` + `Sort`, `Rows Removed by Filter: 34 464` | 510 | 2.06 мс | 2529 мс | 856 кБ | 0.081 с | +| C `(chat_id, created_at, id) INCLUDE (sender_id, text)` | `Index Only Scan`, `Heap Fetches: 0` | 4 | 0.027 мс | 0.73 мс | 14 МБ | 0.086 с | -**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 32 675 строк ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 2300 раз (2461 мс против 1.05 мс), и отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 54) и на серии страниц быстрее A примерно на треть (0.72 мс против 1.05 мс); по одной странице времена A и C различать нельзя — 0.042 и 0.056 мс лежат в пределах разброса единичного замера, поэтому вывод делается по серии и по числу буферов. Цена C — индекс 14 МБ против 11 МБ; разницы во времени вставки между A и C на этих данных не видно (0.086 с против 0.084 с). B пишет быстрее всех (0.078 с) просто потому, что его индекс меньше. +**Что наблюдали.** Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 34 464 строки ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 2350 раз (2529 мс против 1.08 мс), и отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (`Heap Fetches: 0`, 4 буфера против 53) и на серии страниц быстрее A примерно на треть (0.73 мс против 1.08 мс); по одной странице времена A и C различать нельзя — 0.047 и 0.027 мс лежат в пределах разброса единичного замера, поэтому вывод делается по серии и по числу буферов. Цена C — индекс 14 МБ против 11 МБ; разницы во времени вставки между A и C на этих данных не видно (0.086 с против 0.085 с). B пишет быстрее всех (0.081 с) просто потому, что его индекс меньше. **Вывод.** В схему взят вариант A: постоянная цена страницы при умеренном размере индекса. C даёт измеримый выигрыш по буферам и по серии страниц и остаётся кандидатом, если история читается существенно чаще, чем пишется; прежде чем переключаться, его цену записи нужно перемерять на длинных текстах, где дублирование текста в индексе должно проявиться. Переключение — одна миграция. @@ -157,29 +159,31 @@ docker compose --env-file .env start valkey | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.7 МБ | бэкап 0.741 с | -| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 76/76, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 45/45; md5 истории большого чата (36 305 строк) `1841fdf890f6207bc78cb973bedeec27` в обеих базах; первые три сообщения совпали | восстановление 0.357 с; потерь на момент снимка нет | +| `pg_dump -Fc` базы с 120 000 сообщений | согласованный дамп | файл 5.7 МБ | бэкап 0.743 с | +| `pg_restore` в новый том и новую базу | совпадение количества и содержимого | users 78/78, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 45/45; md5 истории большого чата (38 293 строки) `f18725746ed1acbdda044e804cdc4c7c` в обеих базах; первые три сообщения совпали | восстановление 0.354 с; потерь на момент снимка нет | | Запись после снимка (маркерное сообщение) | в копии отсутствует | в источнике 1 маркер, в восстановленной копии 0 | потеряно всё, подтверждённое после начала дампа | | Рестарт API и обоих хранилищ с сохранением томов | данные и действующая сессия живы | `PASS` публичного persistence-теста: тот же токен читает ту же историю, дублей нет | простой до readiness < 10 с, потерь нет | -| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 550.9 RPS против 1209.7 RPS, p95 9.41 мс против 4.57 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×2.2 | +| Остановка Valkey под нагрузкой | кэш обходится, ошибок нет | 498.2 RPS против 1276.0 RPS, p95 11.46 мс против 4.34 мс, `failed_requests: 0` | потерь нет, деградация по скорости ×2.6 | | Остановка PostgreSQL | ограниченная ошибка, доверия нет | `/health/ready` 503, регистрация 503, неизвестный токен → 503/401, анонимный → 401, `/health/live` 200 | запись недоступна полностью до возврата БД | | Заморозка PostgreSQL (`docker compose pause`) | быстрый 503, а не зависший запрос | 503 быстрее 10 с при потолке запроса 8 с; после `unpause` доступ восстановился | потерь нет | | Рестарт Valkey после подтверждённого logout | отозванный токен остаётся мёртвым | 401 после рестарта кэша | потерь нет | +| Гонка logout и параллельного чтения | подтверждённый отзыв нельзя отменить наполнением кэша | до правки токен жил ещё 30 с после 204; после правки — 401 сразу | потерь нет | +| Неудавшийся logout при замороженной базе | кэш не отказывает сессии, которая ещё жива в базе | 503 клиенту, надгробие снято, ответ API совпадает с наличием строки в базе | потерь нет | | Удаление ключа сессии из кэша | ответ из PostgreSQL совпадает с кэшированным, ключ восстановлен с TTL | тело идентично, `EXISTS` = 1, TTL 30 с | потерь нет | -**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 36 305 успешных POST, 0 ошибок, 1209.659 RPS, p50 3.130 / p95 4.568 / p99 6.509 мс. С остановленным Valkey: 16 537 успешных POST, 0 ошибок, 550.943 RPS, p50 6.908 / p95 9.405 / p99 12.388 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда. +**Нагрузочный профиль** (для контекста, не доказательство ёмкости): `tests/load.py`, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 38 293 успешных POST, 0 ошибок, 1275.960 RPS, p50 2.933 / p95 4.335 / p99 7.548 мс. С остановленным Valkey: 14 955 успешных POST, 0 ошибок, 498.216 RPS, p50 7.457 / p95 11.462 / p99 14.472 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда. **Ограничения измерений.** Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. По одной странице времена вариантов A и C неразличимы, поэтому для них опорой служат серия из 100 страниц и число буферов. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до `VACUUM` — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам. ## Ограничения и следующие шаги -**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 2.2 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть. +**Какие отказы выдерживаются.** Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 2.6 раза. Потеря соединения с БД: запросы получают 503 с `Retry-After`, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть. **Какие отказы не выдерживаются.** PostgreSQL — единственная точка истины без реплики: при потере тома `pgdata` данные восстанавливаются только из дампа, то есть теряется всё после последнего `pg_dump`. WAL-архивирование и PITR не настроены, непрерывного бэкапа нет. API — один экземпляр, балансировщика нет (это тема lab3), поэтому его перезапуск — простой сервиса, а не бесшовное переключение. Rate limiting по пользователю и HTTPS в объём lab2 не входят. -**Учебные упрощения.** Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в `bytea` усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (`load_*` пользователи, `load chat *`) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов. +**Учебные упрощения.** Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Надгробие живёт в кэше дольше самой записи о сессии — это сознательная плата за то, чтобы отзыв нельзя было отменить гонкой. Если удаление строки в базе не удалось, надгробие снимается обратно, поэтому кэш не отказывает сессии, которая в базе ещё существует. При этом клиентский таймаут не означает, что запрос не выполнился: после 503 исход отзыва честно неизвестен, и оба ответа на следующий запрос этим токеном законны. Тест `failed_logout_leaves_cache_and_database_consistent` поэтому проверяет не конкретный код ответа, а согласованность: смотрит, есть ли строка сессии в базе, и требует от API ровно соответствующего ей ответа. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в `bytea` усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (`load_*` пользователи, `load chat *`) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов. -**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 2300 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.085 с против 0.084 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось). +**Что подтверждено, а что пока гипотеза.** Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 2350 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.086 с против 0.085 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что `max_size=10` в пуле — оптимум (значение взято с запасом под `max_connections=50`, но под нагрузкой не подбиралось). **Следующие шаги.** Настроить WAL-архивирование и проверить PITR с восстановлением на момент времени; добавить реплику PostgreSQL и измерить переключение; подобрать `DB_POOL_MAX` и профиль Argon2id под целевой p95; перенести эксперименты на отдельную базу; в lab3 добавить балансировщик и идемпотентность записи. diff --git a/app/config.py b/app/config.py index 83685a6f..37625df7 100644 --- a/app/config.py +++ b/app/config.py @@ -40,4 +40,8 @@ MAX_BODY_BYTES = _int("MAX_BODY_BYTES", 65536) MAX_RSS_MB = _int("MAX_RSS_MB", 0) PASSWORD_MIN = 12 PASSWORD_MAX = 128 +SESSION_REVOKED_TTL_SECONDS = max( + _int("SESSION_REVOKED_TTL_SECONDS", 60), + SESSION_CACHE_TTL_SECONDS + int(REQUEST_TIMEOUT) + 5, +) INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname() diff --git a/app/sessions.py b/app/sessions.py index c257316b..31d472f4 100644 --- a/app/sessions.py +++ b/app/sessions.py @@ -13,6 +13,8 @@ from app.errors import unavailable log = logging.getLogger("messenger.sessions") +REVOKED = "revoked" + class SessionStore: def __init__(self, db) -> None: @@ -60,6 +62,9 @@ class SessionStore: async def resolve(self, token: str) -> Optional[dict]: digest = self.digest(token) cached = await self._cache_get(digest) + if cached == REVOKED: + self.stats["hits"] += 1 + return None if cached is not None: self.stats["hits"] += 1 return cached @@ -80,9 +85,13 @@ class SessionStore: async def revoke(self, token: str) -> None: digest = self.digest(token) - await self._cache_drop(digest) - async with self.db.connection() as conn: - await conn.execute("DELETE FROM sessions WHERE token_hash = %s", (digest,)) + await self._cache_revoke(digest) + try: + async with self.db.connection() as conn: + await conn.execute("DELETE FROM sessions WHERE token_hash = %s", (digest,)) + except Exception: + await self._cache_release(digest) + raise async def sweep(self) -> int: async with self.db.connection() as conn: @@ -103,6 +112,8 @@ class SessionStore: return None if not raw: return None + if raw == REVOKED: + return REVOKED try: return json.loads(raw) except ValueError: @@ -116,17 +127,25 @@ class SessionStore: return payload = json.dumps(user) try: - await self.client.set(self.key(digest), payload, ex=ttl) + await self.client.set(self.key(digest), payload, ex=ttl, nx=True) except Exception: self._cache_failed("set") - async def _cache_drop(self, digest: bytes) -> None: + async def _cache_release(self, digest: bytes) -> None: if self.client is None: return try: await self.client.delete(self.key(digest)) except Exception: - self._cache_failed("delete") + self._cache_failed("release") + + async def _cache_revoke(self, digest: bytes) -> None: + if self.client is None: + return + try: + await self.client.set(self.key(digest), REVOKED, ex=config.SESSION_REVOKED_TTL_SECONDS) + except Exception: + self._cache_failed("revoke") raise unavailable("Кэш сессий недоступен, выход из сессии не подтверждён") from None def _cache_failed(self, operation: str) -> None: diff --git a/evidence/dependency.txt b/evidence/dependency.txt index f47c5c87..905ffa98 100644 --- a/evidence/dependency.txt +++ b/evidence/dependency.txt @@ -1,8 +1,8 @@ === 1. Останавливаю кэш сессий (valkey) === Container mtusi-lab2-valkey-1 Stopping Container mtusi-lab2-valkey-1 Stopped -api Up 31 seconds (healthy) -postgres Up 37 seconds (unhealthy) +api Up 40 seconds (healthy) +postgres Up 46 seconds (unhealthy) PASS login_and_read_work_without_cache PASS unknown_token_is_still_rejected PASS readiness_ignores_the_cache @@ -13,7 +13,7 @@ PASS readiness_ignores_the_cache === 2. Останавливаю PostgreSQL === Container mtusi-lab2-postgres-1 Stopping Container mtusi-lab2-postgres-1 Stopped -api Up 32 seconds (healthy) +api Up 41 seconds (healthy) valkey Up Less than a second (health: starting) PASS readiness_reports_the_outage PASS writes_fail_with_503 @@ -24,6 +24,6 @@ PASS login_fails_closed Container mtusi-lab2-postgres-1 Started === 3. Состояние восстановлено === -api Up 38 seconds (healthy) -postgres Up 3 seconds (health: starting) -valkey Up 7 seconds (healthy) +api Up 44 seconds (healthy) +postgres Up Less than a second (health: starting) +valkey Up 3 seconds (health: starting) diff --git a/evidence/explain-10k.txt b/evidence/explain-10k.txt index 967e5acc..66941c23 100644 --- a/evidence/explain-10k.txt +++ b/evidence/explain-10k.txt @@ -7,7 +7,7 @@ valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682f === Засев 10000 сообщений с неравномерными чатами === seed_duration | seeded_rows | target_total | messages_total -----------------+-------------+--------------+---------------- - 00:00:00.000975 | 0 | 10000 | 52887 + 00:00:00.001099 | 0 | 10000 | 53293 (1 row) @@ -19,70 +19,70 @@ valkey valkey/valkey:8.1-alpine@sha256:081c2f5cb575efc901aa80ff9cdbd1ec6a301682f messages_total | chats_with_messages | table_size | indexes_size ----------------+---------------------+------------+-------------- - 52887 | 14 | 5280 kB | 7024 kB + 53293 | 14 | 5320 kB | 7152 kB (1 row) --- распределение истории по чатам: 5 самых больших и 5 самых маленьких --- chat_id | rows --------------------------------------+------- - 174a0477-1fd5-47a9-ab90-ee8b7ef903af | 36305 - fb87d20c-528a-4bb7-9cd5-e1d4486bdfca | 16537 - 3e751b33-08b7-4433-a2be-bb355af7bf62 | 25 - 11bd8f2b-db27-4c63-89f0-469ee53c6cad | 5 - 30e5554f-e2e0-411e-b5bd-ab86e1fd9c5f | 3 + 69ee7d45-68b4-4606-befe-efaeecdedd32 | 38293 + e95dc135-101e-442f-baf7-b21f0ed7edaf | 14955 + 20948a76-f794-4765-9fcc-7a9ebccafd2e | 25 + b2bd268f-f9b6-40fb-8039-1bde44c0f9ee | 5 + f4d3517a-4afa-4461-a4fc-16c6302f3d7c | 3 (5 rows) chat_id | rows --------------------------------------+------ - b490286c-39b8-4940-92cf-23817def915a | 1 - 6fc32369-98df-4387-b07f-00dfa6e0b391 | 1 - f4c1fdcc-0ddd-4fb5-a962-c8901deac9e2 | 1 - 903d0035-1bda-4ac6-9fbf-52f28fe0b94c | 1 - fb6df905-d5d2-4300-b74f-1f0196f9e2b0 | 1 + 6dbc6664-e048-4858-9ce5-f507afb9fd7c | 1 + ac1c8e3d-4e29-44fc-b770-d3ef6f2351ae | 1 + 5a65b658-2555-4ac9-b10a-9a081f81f37b | 1 + 17c53c09-19a0-4c0c-87f8-2f8c66468119 | 1 + 451812c7-05dc-4b1d-9ddb-3679c4ccd15f | 1 (5 rows) --- A. keyset, первая страница самого большого чата --- QUERY PLAN ---------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.41..5.46 rows=50 width=67) (actual time=0.005..0.011 rows=50 loops=1) - Buffers: shared hit=21 - -> Index Scan using messages_history_idx on messages (cost=0.41..3662.26 rows=36288 width=67) (actual time=0.005..0.009 rows=50 loops=1) - Index Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) - Buffers: shared hit=21 + Limit (cost=0.41..5.43 rows=50 width=67) (actual time=0.005..0.013 rows=50 loops=1) + Buffers: shared hit=24 + -> Index Scan using messages_history_idx on messages (cost=0.41..3813.50 rows=38014 width=67) (actual time=0.005..0.010 rows=50 loops=1) + Index Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) + Buffers: shared hit=24 Planning: Buffers: shared hit=8 - Planning Time: 0.049 ms - Execution Time: 0.018 ms + Planning Time: 0.036 ms + Execution Time: 0.021 ms (9 rows) --- B. keyset, страница на глубине 90% истории (так работает cursor API) --- QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.41..8.17 rows=50 width=67) (actual time=0.006..0.014 rows=50 loops=1) - Buffers: shared hit=54 - -> Index Scan using messages_history_idx on messages (cost=0.41..2148.72 rows=13857 width=67) (actual time=0.005..0.012 rows=50 loops=1) - Index Cond: ((chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid))) - Buffers: shared hit=54 - Planning Time: 0.022 ms - Execution Time: 0.034 ms + Limit (cost=0.41..8.31 rows=50 width=67) (actual time=0.006..0.013 rows=50 loops=1) + Buffers: shared hit=53 + -> Index Scan using messages_history_idx on messages (cost=0.41..2141.23 rows=13555 width=67) (actual time=0.006..0.011 rows=50 loops=1) + Index Cond: ((chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid))) + Buffers: shared hit=53 + Planning Time: 0.023 ms + Execution Time: 0.032 ms (7 rows) --- C. OFFSET на той же глубине (так API не делает: цена растёт со страницей) --- QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=3297.57..3302.61 rows=50 width=67) (actual time=4.132..4.139 rows=50 loops=1) - Buffers: shared hit=33082 - -> Index Scan using messages_history_idx on messages (cost=0.41..3662.26 rows=36288 width=67) (actual time=0.012..3.519 rows=32724 loops=1) - Index Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) - Buffers: shared hit=33082 - Planning Time: 0.020 ms - Execution Time: 4.146 ms + Limit (cost=3457.31..3462.32 rows=50 width=67) (actual time=4.463..4.470 rows=50 loops=1) + Buffers: shared hit=34920 + -> Index Scan using messages_history_idx on messages (cost=0.41..3813.50 rows=38014 width=67) (actual time=0.005..3.799 rows=34513 loops=1) + Index Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) + Buffers: shared hit=34920 + Planning Time: 0.016 ms + Execution Time: 4.476 ms (7 rows) --- индексы таблицы messages --- index | size | scans ----------------------+---------+------- - messages_history_idx | 4720 kB | 12 - messages_pkey | 2304 kB | 0 + messages_history_idx | 4832 kB | 12 + messages_pkey | 2320 kB | 0 (2 rows) diff --git a/evidence/git-hygiene.txt b/evidence/git-hygiene.txt index df9f81d7..6efc6fba 100644 --- a/evidence/git-hygiene.txt +++ b/evidence/git-hygiene.txt @@ -1,19 +1,19 @@ - M REPORT.md - M app/sessions.py - M evidence/dependency.txt - M evidence/explain-10k.txt - M evidence/git-hygiene.txt - M evidence/load-cache.json - M evidence/load-nocache.json - M evidence/load.txt - M evidence/migrations.txt - M evidence/outages.txt - M evidence/persistence.txt - M evidence/stand.txt - M evidence/track2/run.txt - M scripts/bootstrap.sh - M student-tests/evidence.sh - M student-tests/test_outages.py +M .env.example +MM REPORT.md +M app/config.py +MM app/sessions.py +MM evidence/dependency.txt +MM evidence/explain-10k.txt +MM evidence/git-hygiene.txt +MM evidence/load-cache.json +MM evidence/load-nocache.json +MM evidence/load.txt +MM evidence/migrations.txt +MM evidence/outages.txt +MM evidence/persistence.txt +MM evidence/stand.txt +MM evidence/track2/run.txt +MM student-tests/test_outages.py --- правила игнорирования --- .gitignore:2:.env .env .gitignore:5:secrets/ secrets/database_url diff --git a/evidence/load-cache.json b/evidence/load-cache.json index 47bf2fb9..9a772232 100644 --- a/evidence/load-cache.json +++ b/evidence/load-cache.json @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.013, + "elapsed_seconds": 30.011, "concurrency": 4, - "successful_requests": 36305, + "successful_requests": 38293, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 1209.659, + "successful_rps": 1275.96, "successful_latency_ms": { - "p50": 3.13, - "p95": 4.568, - "p99": 6.509 + "p50": 2.933, + "p95": 4.335, + "p99": 7.548 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/load-nocache.json b/evidence/load-nocache.json index 660666da..39c7a958 100644 --- a/evidence/load-nocache.json +++ b/evidence/load-nocache.json @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.016, + "elapsed_seconds": 30.017, "concurrency": 4, - "successful_requests": 16537, + "successful_requests": 14955, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 550.943, + "successful_rps": 498.216, "successful_latency_ms": { - "p50": 6.908, - "p95": 9.405, - "p99": 12.388 + "p50": 7.457, + "p95": 11.462, + "p99": 14.472 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/load.txt b/evidence/load.txt index 11b0fe6d..d93fb9a2 100644 --- a/evidence/load.txt +++ b/evidence/load.txt @@ -2,16 +2,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.013, + "elapsed_seconds": 30.011, "concurrency": 4, - "successful_requests": 36305, + "successful_requests": 38293, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 1209.659, + "successful_rps": 1275.96, "successful_latency_ms": { - "p50": 3.13, - "p95": 4.568, - "p99": 6.509 + "p50": 2.933, + "p95": 4.335, + "p99": 7.548 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } @@ -19,16 +19,16 @@ "lab": 2, "workload": "closed-loop POST messages; no automatic retries", "requested_duration_seconds": 30.0, - "elapsed_seconds": 30.016, + "elapsed_seconds": 30.017, "concurrency": 4, - "successful_requests": 16537, + "successful_requests": 14955, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 550.943, + "successful_rps": 498.216, "successful_latency_ms": { - "p50": 6.908, - "p95": 9.405, - "p99": 12.388 + "p50": 7.457, + "p95": 11.462, + "p99": 14.472 }, "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." } diff --git a/evidence/migrations.txt b/evidence/migrations.txt index f2ce92aa..53210d27 100644 --- a/evidence/migrations.txt +++ b/evidence/migrations.txt @@ -5,8 +5,8 @@ migrate-1 | migrations complete: 1 file(s) Container mtusi-lab2-postgres-1 Running Container mtusi-lab2-postgres-1 Waiting Container mtusi-lab2-postgres-1 Healthy - Container mtusi-lab2-migrate-run-6c5706582141 Creating - Container mtusi-lab2-migrate-run-6c5706582141 Created + Container mtusi-lab2-migrate-run-003b830c021a Creating + Container mtusi-lab2-migrate-run-003b830c021a Created skip 0001_init migrations complete: 1 file(s) --- схема --- @@ -30,6 +30,6 @@ Access method: heap version | checksum | applied_at -----------+------------------------------------------------------------------+------------------------------- - 0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-23 14:36:13.656522+00 + 0001_init | 4fd0a8c68a5cffd3ae67a21646eb1928477d18b8716e68c1220469d858ccb9c1 | 2026-10-23 20:10:21.263237+00 (1 row) diff --git a/evidence/outages.txt b/evidence/outages.txt index 7e7b0c00..0bca96b3 100644 --- a/evidence/outages.txt +++ b/evidence/outages.txt @@ -3,5 +3,7 @@ PASS logout_is_not_confirmed_while_cache_is_down PASS cached_sessions_do_not_cross_users PASS cache_is_repopulated_after_a_miss PASS cache_survives_its_own_restart +PASS revoked_session_cannot_be_resurrected_by_a_race +PASS failed_logout_leaves_cache_and_database_consistent PASS hung_database_fails_fast -6/6 checks passed +8/8 checks passed diff --git a/evidence/persistence.txt b/evidence/persistence.txt index 28cd5941..132c670c 100644 --- a/evidence/persistence.txt +++ b/evidence/persistence.txt @@ -1,7 +1,7 @@ --- состояние контейнеров до рестарта --- -api Up 39 seconds (healthy) -postgres Up 3 seconds (health: starting) -valkey Up 7 seconds (healthy) +api Up 44 seconds (healthy) +postgres Up Less than a second (health: starting) +valkey Up 3 seconds (health: starting) python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. @@ -10,9 +10,9 @@ api Up Less than a second (health: starting) postgres Up Less than a second (health: starting) valkey Up Less than a second (health: starting) --- логи postgres о перезапуске --- -postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit -postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432 -postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: listening on IPv6 address "::", port 5432 -postgres-1 | 2026-10-23 14:36:53.364 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432" -postgres-1 | 2026-10-23 14:36:53.366 UTC [29] LOG: database system was shut down at 2026-10-23 14:36:53 UTC -postgres-1 | 2026-10-23 14:36:53.368 UTC [1] LOG: database system is ready to accept connections +postgres-1 | 2026-10-23 20:11:06.649 UTC [1] LOG: starting PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 15.2.0, 64-bit +postgres-1 | 2026-10-23 20:11:06.649 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432 +postgres-1 | 2026-10-23 20:11:06.649 UTC [1] LOG: listening on IPv6 address "::", port 5432 +postgres-1 | 2026-10-23 20:11:06.650 UTC [1] LOG: listening on Unix socket "/var/run/postgresql/.s.PGSQL.5432" +postgres-1 | 2026-10-23 20:11:06.652 UTC [29] LOG: database system was shut down at 2026-10-23 20:11:06 UTC +postgres-1 | 2026-10-23 20:11:06.654 UTC [1] LOG: database system is ready to accept connections diff --git a/evidence/stand.txt b/evidence/stand.txt index 7d25bad0..9645d169 100644 --- a/evidence/stand.txt +++ b/evidence/stand.txt @@ -8,9 +8,9 @@ PostgreSQL 17.7 on aarch64-unknown-linux-musl, compiled by gcc (Alpine 15.2.0) 1 Valkey server v=8.1.10 sha=00000000:1 malloc=jemalloc-5.3.0 bits=64 build=2cb63ac0e4567989 --- строка старта API: действующие лимиты и TTL --- api-1 | INFO: Waiting for application startup. -api-1 | 2026-10-23 14:36:14,347 INFO messenger started: instance=9b4feca99e44 session_store=postgres session_ttl=3600 cache_ttl=30 pool=1..10 max_inflight=64 max_body=65536 +api-1 | 2026-10-23 20:10:21,987 INFO messenger started: instance=b9f88891f2b8 session_store=postgres session_ttl=3600 cache_ttl=30 pool=1..10 max_inflight=64 max_body=65536 api-1 | INFO: Application startup complete. api-1 | INFO: Uvicorn running on http://0.0.0.0:8080 (Press CTRL+C to quit) -api-1 | INFO: 172.18.0.1:56506 - "GET /health/ready HTTP/1.1" 200 OK +api-1 | INFO: 172.18.0.1:57028 - "GET /health/ready HTTP/1.1" 200 OK --- сверка .env с .env.example --- ready: .env and secrets/ created locally; they stay out of Git diff --git a/evidence/track2/run.txt b/evidence/track2/run.txt index 3e5e8e7d..cd55a8eb 100644 --- a/evidence/track2/run.txt +++ b/evidence/track2/run.txt @@ -8,7 +8,7 @@ Docker version 29.7.2, build a7dcaa6 === 1. Засев истории: цель 120000 сообщений, чаты неравномерные === seed_duration | seeded_rows | target_total | messages_total -----------------+-------------+--------------+---------------- - 00:00:00.616654 | 67113 | 120000 | 120000 + 00:00:00.637022 | 66707 | 120000 | 120000 (1 row) @@ -26,15 +26,15 @@ Docker version 29.7.2, build a7dcaa6 QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.42..47.47 rows=50 width=90) (actual time=0.009..0.020 rows=50 loops=1) - Buffers: shared hit=54 - -> Index Scan using messages_history_idx on messages (cost=0.42..6827.62 rows=7255 width=90) (actual time=0.008..0.018 rows=50 loops=1) - Index Cond: ((chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid))) - Buffers: shared hit=54 + Limit (cost=0.42..52.46 rows=50 width=89) (actual time=0.015..0.024 rows=50 loops=1) + Buffers: shared hit=53 + -> Index Scan using messages_history_idx on messages (cost=0.42..7478.52 rows=7184 width=89) (actual time=0.014..0.021 rows=50 loops=1) + Index Cond: ((chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid))) + Buffers: shared hit=53 Planning: Buffers: shared hit=19 - Planning Time: 0.086 ms - Execution Time: 0.042 ms + Planning Time: 0.097 ms + Execution Time: 0.047 ms (9 rows) pages_measured @@ -44,46 +44,46 @@ Docker version 29.7.2, build a7dcaa6 hundred_pages_duration ------------------------ - 00:00:00.00105 + 00:00:00.001077 (1 row) insert_10k_duration --------------------- - 00:00:00.083522 + 00:00:00.085221 (1 row) ############ Вариант B: только (chat_id) ############ index_size ------------ - 848 kB + 856 kB (1 row) QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------ - Limit (cost=3231.76..3231.89 rows=50 width=90) (actual time=1.856..1.860 rows=50 loops=1) - Buffers: shared hit=451 read=33 - I/O Timings: shared read=0.074 - -> Sort (cost=3231.76..3249.63 rows=7146 width=90) (actual time=1.855..1.857 rows=50 loops=1) + Limit (cost=3274.42..3274.55 rows=50 width=90) (actual time=2.027..2.031 rows=50 loops=1) + Buffers: shared hit=475 read=35 + I/O Timings: shared read=0.088 + -> Sort (cost=3274.42..3292.14 rows=7088 width=90) (actual time=2.026..2.028 rows=50 loops=1) Sort Key: created_at, id Sort Method: top-N heapsort Memory: 33kB - Buffers: shared hit=451 read=33 - I/O Timings: shared read=0.074 - -> Bitmap Heap Scan on messages (cost=408.67..2994.38 rows=7146 width=90) (actual time=1.514..1.710 rows=3630 loops=1) - Recheck Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) - Filter: (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid)) - Rows Removed by Filter: 32675 - Heap Blocks: exact=451 - Buffers: shared hit=451 read=33 - I/O Timings: shared read=0.074 - -> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..406.88 rows=36612 width=0) (actual time=0.362..0.362 rows=36305 loops=1) - Index Cond: (chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) - Buffers: shared read=33 - I/O Timings: shared read=0.074 + Buffers: shared hit=475 read=35 + I/O Timings: shared read=0.088 + -> Bitmap Heap Scan on messages (cost=428.23..3038.96 rows=7088 width=90) (actual time=1.631..1.839 rows=3829 loops=1) + Recheck Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) + Filter: (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid)) + Rows Removed by Filter: 34464 + Heap Blocks: exact=475 + Buffers: shared hit=475 read=35 + I/O Timings: shared read=0.088 + -> Bitmap Index Scan on messages_chat_only_idx (cost=0.00..426.46 rows=38156 width=0) (actual time=0.397..0.397 rows=38293 loops=1) + Index Cond: (chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) + Buffers: shared read=35 + I/O Timings: shared read=0.088 Planning: - Buffers: shared hit=28 read=1 + Buffers: shared hit=27 read=1 I/O Timings: shared read=0.009 - Planning Time: 0.126 ms - Execution Time: 1.879 ms + Planning Time: 0.123 ms + Execution Time: 2.056 ms (24 rows) pages_measured @@ -93,12 +93,12 @@ Docker version 29.7.2, build a7dcaa6 hundred_pages_duration ------------------------ - 00:00:02.460907 + 00:00:02.52905 (1 row) insert_10k_duration --------------------- - 00:00:00.077769 + 00:00:00.080589 (1 row) ############ Вариант C: (chat_id, created_at, id) INCLUDE (sender_id, text) ############ @@ -109,19 +109,19 @@ Docker version 29.7.2, build a7dcaa6 QUERY PLAN ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- - Limit (cost=0.42..43.36 rows=50 width=90) (actual time=0.039..0.045 rows=50 loops=1) + Limit (cost=0.42..45.99 rows=50 width=89) (actual time=0.014..0.018 rows=50 loops=1) Buffers: shared hit=1 read=3 - I/O Timings: shared read=0.012 - -> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..6095.87 rows=7098 width=90) (actual time=0.038..0.041 rows=50 loops=1) - Index Cond: ((chat_id = '174a0477-1fd5-47a9-ab90-ee8b7ef903af'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 14:37:21.481035+00'::timestamp with time zone, 'b34cffc1-608f-4281-89b6-d598a0000a8d'::uuid))) + I/O Timings: shared read=0.005 + -> Index Only Scan using messages_history_covering_idx on messages (cost=0.42..6560.61 rows=7197 width=89) (actual time=0.013..0.015 rows=50 loops=1) + Index Cond: ((chat_id = '69ee7d45-68b4-4606-befe-efaeecdedd32'::uuid) AND (ROW(created_at, id) > ROW('2026-10-23 20:11:34.584521+00'::timestamp with time zone, 'aa6010bb-02c6-4d17-986b-0f5103547576'::uuid))) Heap Fetches: 0 Buffers: shared hit=1 read=3 - I/O Timings: shared read=0.012 + I/O Timings: shared read=0.005 Planning: - Buffers: shared hit=29 read=1 - I/O Timings: shared read=0.007 - Planning Time: 0.144 ms - Execution Time: 0.056 ms + Buffers: shared hit=28 read=1 + I/O Timings: shared read=0.003 + Planning Time: 0.118 ms + Execution Time: 0.027 ms (13 rows) pages_measured @@ -131,12 +131,12 @@ Docker version 29.7.2, build a7dcaa6 hundred_pages_duration ------------------------ - 00:00:00.000723 + 00:00:00.000734 (1 row) insert_10k_duration --------------------- - 00:00:00.085783 + 00:00:00.08596 (1 row) ############ Схема после эксперимента (ROLLBACK вернул индексы) ############ @@ -147,7 +147,7 @@ Docker version 29.7.2, build a7dcaa6 (2 rows) -Самый большой чат: 174a0477-1fd5-47a9-ab90-ee8b7ef903af +Самый большой чат: 69ee7d45-68b4-4606-befe-efaeecdedd32 === 3. Состояние источника до бэкапа === relation | rows @@ -156,19 +156,19 @@ Docker version 29.7.2, build a7dcaa6 chats | 68 messages | 120000 sessions | 45 - users | 76 + users | 78 (5 rows) big_chat_rows | big_chat_md5 ---------------+---------------------------------- - 36305 | 1841fdf890f6207bc78cb973bedeec27 + 38293 | f18725746ed1acbdda044e804cdc4c7c (1 row) id | created_at | text --------------------------------------+-------------------------------+---------- - 1d15f9ed-952e-45e7-9553-dcd3bc3dd76e | 2026-10-23 14:36:54.449674+00 | load-2-0 - 4bc8c702-07e1-42d2-be14-8cdd6dad31a7 | 2026-10-23 14:36:54.450312+00 | load-0-0 - 3993ceca-7c29-400d-a1e9-287137672829 | 2026-10-23 14:36:54.450773+00 | load-1-0 + 39cb2935-f53c-4e54-a75d-8b197126a6b4 | 2026-10-23 20:11:07.699544+00 | load-3-0 + 62d3d8a1-fdaa-4a6c-812f-79ef268ada42 | 2026-10-23 20:11:07.700168+00 | load-1-0 + 4fa775f1-6033-4d84-9e6c-0f39844e6201 | 2026-10-23 20:11:07.700828+00 | load-0-0 (3 rows) marker_rows @@ -178,7 +178,7 @@ Docker version 29.7.2, build a7dcaa6 === 4. Бэкап pg_dump -Fc === -backup_seconds=0.741 +backup_seconds=0.743 dump_size=5.7M === 5. Запись после бэкапа: граница потери данных === @@ -188,7 +188,7 @@ dump_size=5.7M /var/run/postgresql:5432 - accepting connections === 7. Восстановление в новое хранилище === -restore_seconds=0.357 +restore_seconds=0.354 === 8. Сверка восстановленной копии === relation | rows @@ -197,19 +197,19 @@ restore_seconds=0.357 chats | 68 messages | 120000 sessions | 45 - users | 76 + users | 78 (5 rows) big_chat_rows | big_chat_md5 ---------------+---------------------------------- - 36305 | 1841fdf890f6207bc78cb973bedeec27 + 38293 | f18725746ed1acbdda044e804cdc4c7c (1 row) id | created_at | text --------------------------------------+-------------------------------+---------- - 1d15f9ed-952e-45e7-9553-dcd3bc3dd76e | 2026-10-23 14:36:54.449674+00 | load-2-0 - 4bc8c702-07e1-42d2-be14-8cdd6dad31a7 | 2026-10-23 14:36:54.450312+00 | load-0-0 - 3993ceca-7c29-400d-a1e9-287137672829 | 2026-10-23 14:36:54.450773+00 | load-1-0 + 39cb2935-f53c-4e54-a75d-8b197126a6b4 | 2026-10-23 20:11:07.699544+00 | load-3-0 + 62d3d8a1-fdaa-4a6c-812f-79ef268ada42 | 2026-10-23 20:11:07.700168+00 | load-1-0 + 4fa775f1-6033-4d84-9e6c-0f39844e6201 | 2026-10-23 20:11:07.700828+00 | load-0-0 (3 rows) marker_rows @@ -219,9 +219,9 @@ restore_seconds=0.357 === 9. Итог === -backup_seconds=0.741 restore_seconds=0.357 +backup_seconds=0.743 restore_seconds=0.354 messages_source_without_marker=120000 messages_restored=120000 -big_chat_md5_source=1841fdf890f6207bc78cb973bedeec27 -big_chat_md5_restored=1841fdf890f6207bc78cb973bedeec27 +big_chat_md5_source=f18725746ed1acbdda044e804cdc4c7c +big_chat_md5_restored=f18725746ed1acbdda044e804cdc4c7c RESULT: восстановленная копия совпадает с источником на момент бэкапа маркеров после бэкапа в восстановленной копии: 0 (ожидается 0: всё, что подтверждено после снимка, в дампе отсутствует) diff --git a/student-tests/test_outages.py b/student-tests/test_outages.py index cc5b63cb..d179dc7b 100644 --- a/student-tests/test_outages.py +++ b/student-tests/test_outages.py @@ -3,6 +3,7 @@ import hashlib import pathlib import subprocess +import threading import time from common import arguments, call, chat_with, expect, member, run @@ -25,6 +26,15 @@ def session_key(token): return "session:" + hashlib.sha256(token.encode("utf-8")).hexdigest() +def session_rows(token): + digest = hashlib.sha256(token.encode("utf-8")).hexdigest() + done = subprocess.run( + COMPOSE + ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-t", "-A", + "-c", "select count(*) from sessions where token_hash = '\\x%s'::bytea" % digest], + cwd=str(ROOT), capture_output=True, text=True, check=True) + return int(done.stdout.strip()) + + def wait_ready(base, seconds=90): deadline = time.monotonic() + seconds while time.monotonic() < deadline: @@ -122,12 +132,80 @@ def cache_survives_its_own_restart(base): expect(valkey("exists", key) == "1", "после рестарта кэш больше не наполняется") +def revoked_session_cannot_be_resurrected_by_a_race(base): + actor = member(base, "race") + token = actor["token"] + key = session_key(token) + digest = hashlib.sha256(token.encode("utf-8")).hexdigest() + expect(call(base, "GET", "/api/v1/users/me", token=token)["status"] == 200, "свежая сессия не работает") + expect(valkey("exists", key) == "1", "после входа сессии нет в кэше") + + holder = subprocess.Popen( + COMPOSE + ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-X", "-q"], + cwd=str(ROOT), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, + ) + holder.stdin.write("BEGIN;\nSELECT 1 FROM sessions WHERE token_hash = '\\x%s'::bytea FOR UPDATE;\n" % digest) + holder.stdin.flush() + time.sleep(0.5) + + outcome = {} + + def logout(): + outcome["status"] = call(base, "DELETE", "/api/v1/auth/sessions/current", token=token, timeout=30)["status"] + + worker = threading.Thread(target=logout) + worker.start() + try: + deadline = time.monotonic() + 5 + while time.monotonic() < deadline and valkey("get", key).startswith("{"): + time.sleep(0.05) + during = call(base, "GET", "/api/v1/users/me", token=token) + finally: + holder.stdin.write("COMMIT;\n\\q\n") + holder.stdin.flush() + holder.wait(timeout=15) + worker.join(timeout=30) + + expect(outcome.get("status") == 204, "logout вернул %s вместо 204" % outcome.get("status")) + after = call(base, "GET", "/api/v1/users/me", token=token) + expect(after["status"] == 401, + "после подтверждённого logout токен ожил: /users/me дал %s, ttl ключа %s (запрос во время гонки дал %s)" + % (after["status"], valkey("ttl", key), during["status"])) + wrote = call(base, "GET", "/api/v1/chats", token=token) + expect(wrote["status"] == 401, "отозванный токен всё ещё читает список чатов: %s" % wrote["status"]) + + +def failed_logout_leaves_cache_and_database_consistent(base): + actor = member(base, "rollback") + token = actor["token"] + key = session_key(token) + expect(call(base, "GET", "/api/v1/users/me", token=token)["status"] == 200, "свежая сессия не работает") + compose("pause", "postgres") + try: + refused = call(base, "DELETE", "/api/v1/auth/sessions/current", token=token, timeout=60) + expect(refused["status"] == 503, "logout при недоступной базе дал %s вместо 503" % refused["status"]) + finally: + compose("unpause", "postgres") + wait_ready(base) + expect(valkey("get", key) != "revoked", "неподтверждённый logout оставил надгробие в кэше") + rows = session_rows(token) + answer = call(base, "GET", "/api/v1/users/me", token=token)["status"] + if rows == 1: + expect(answer == 200, "строка сессии в базе есть, но API отвечает %s" % answer) + expect(call(base, "DELETE", "/api/v1/auth/sessions/current", token=token)["status"] == 204, "повторный logout не прошёл") + expect(call(base, "GET", "/api/v1/users/me", token=token)["status"] == 401, "после подтверждённого logout токен жив") + else: + expect(answer == 401, "строки сессии в базе нет, но API отвечает %s" % answer) + + TESTS = [ revoked_session_stays_revoked_after_cache_restart, logout_is_not_confirmed_while_cache_is_down, cached_sessions_do_not_cross_users, cache_is_repopulated_after_a_miss, cache_survives_its_own_restart, + revoked_session_cannot_be_resurrected_by_a_race, + failed_logout_leaves_cache_and_database_consistent, hung_database_fails_fast, ] -- 2.54.0