From 95556845e68bcb12156f87d2b39682ca9238031b Mon Sep 17 00:00:00 2001 From: ZapcMihail Date: Thu, 5 Nov 2026 17:35:58 +0300 Subject: [PATCH 1/3] =?UTF-8?q?=D0=9B=D0=A03=20=D0=91=D0=92=D0=A22304=20?= =?UTF-8?q?=D0=97=D0=B0=D0=BF=D0=BE=D1=80=D0=BE=D0=B6=D0=B5=D1=86=20=D0=BD?= =?UTF-8?q?=D0=B0=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit HAProxy + 2 API-реплики, общие PostgreSQL/Valkey, обязательный Idempotency-Key, graceful drain по SIGTERM, stop-one/restart/rolling-update, серии отказов и REPORT.md. Co-Authored-By: Claude Opus 5.5 --- .env.example | 23 +- .gitattributes | 6 + .github/workflows/app.yml | 26 ++ Dockerfile | 30 ++ REPORT.md | 159 +++++++- app/__init__.py | 0 app/__main__.py | 48 +++ app/config.py | 63 +++ app/db.py | 65 ++++ app/errors.py | 48 +++ app/lifecycle.py | 16 + app/main.py | 414 ++++++++++++++++++++ app/migrate.py | 57 +++ app/security.py | 47 +++ app/sessions.py | 187 +++++++++ app/validation.py | 108 ++++++ compose.yaml | 184 +++++++++ evidence/failover-hook.txt | 17 + evidence/failover-kill.json | 456 ++++++++++++++++++++++ evidence/failover-stop.json | 456 ++++++++++++++++++++++ evidence/fresh-start.txt | 14 + evidence/instances.txt | 10 + evidence/load-stats.txt | 8 + evidence/load.json | 17 + evidence/persistence.txt | 17 + evidence/public-tests.txt | 8 + evidence/rolling-update.json | 537 ++++++++++++++++++++++++++ evidence/scale.txt | 23 ++ evidence/student-tests.txt | 20 + infra/haproxy/haproxy.cfg | 89 +++++ migrations/0001_init.sql | 59 +++ migrations/0002_idempotency.sql | 21 + migrations/0003_cache_state.sql | 10 + requirements.txt | 20 + scripts/collect-evidence.sh | 47 +++ scripts/init-secrets.sh | 36 ++ scripts/restart.sh | 14 + scripts/restore.sh | 13 + scripts/rolling-update.sh | 36 ++ scripts/stop-one.sh | 29 ++ scripts/test-lab3.sh | 12 + student-tests/failover_series.py | 312 +++++++++++++++ student-tests/show_instances.py | 15 + student-tests/test_lab2_regression.py | 256 ++++++++++++ student-tests/test_lab3.py | 279 +++++++++++++ tools/tester.Dockerfile | 4 + 46 files changed, 4300 insertions(+), 16 deletions(-) create mode 100644 .gitattributes create mode 100644 .github/workflows/app.yml create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/config.py create mode 100644 app/db.py create mode 100644 app/errors.py create mode 100644 app/lifecycle.py create mode 100644 app/main.py create mode 100644 app/migrate.py create mode 100644 app/security.py create mode 100644 app/sessions.py create mode 100644 app/validation.py create mode 100644 compose.yaml create mode 100644 evidence/failover-hook.txt create mode 100644 evidence/failover-kill.json create mode 100644 evidence/failover-stop.json create mode 100644 evidence/fresh-start.txt create mode 100644 evidence/instances.txt create mode 100644 evidence/load-stats.txt create mode 100644 evidence/load.json create mode 100644 evidence/persistence.txt create mode 100644 evidence/public-tests.txt create mode 100644 evidence/rolling-update.json create mode 100644 evidence/scale.txt create mode 100644 evidence/student-tests.txt create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 migrations/0001_init.sql create mode 100644 migrations/0002_idempotency.sql create mode 100644 migrations/0003_cache_state.sql create mode 100644 requirements.txt create mode 100755 scripts/collect-evidence.sh create mode 100755 scripts/init-secrets.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/restore.sh create mode 100755 scripts/rolling-update.sh create mode 100755 scripts/stop-one.sh create mode 100755 scripts/test-lab3.sh create mode 100644 student-tests/failover_series.py create mode 100644 student-tests/show_instances.py create mode 100644 student-tests/test_lab2_regression.py create mode 100644 student-tests/test_lab3.py create mode 100644 tools/tester.Dockerfile diff --git a/.env.example b/.env.example index d32b9be0..1e9012bf 100644 --- a/.env.example +++ b/.env.example @@ -7,7 +7,28 @@ SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +# postgres - sessions only in PostgreSQL +# postgres+valkey - PostgreSQL is the source of truth, Valkey is a shared read-through session cache with TTL +SESSION_STORE=postgres+valkey CACHE_URL_FILE=/run/secrets/cache_url API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 +# --- solution-specific (lab3) --- +# Max lifetime of a cached session copy (also the cache-distrust window after a Valkey error) +SESSION_CACHE_TTL_SECONDS=60 +# On SIGTERM a replica keeps serving but reports not-ready this long, so the LB drains it +SHUTDOWN_DRAIN_MS=3000 +# Bounded pool and timeouts, per replica +DB_POOL_MAX=10 +DB_STATEMENT_TIMEOUT_MS=5000 +DB_ACQUIRE_TIMEOUT_MS=2000 +CACHE_TIMEOUT_MS=300 +# Parallel Argon2id computations per replica (each uses 64 MiB) +PASSWORD_HASH_WORKERS=2 +# Per-replica limits +API_CPUS=1.0 +API_MEMORY=384M +PG_CPUS=2.0 +# Host ports bound to 127.0.0.1: LB entrypoint and LB stats page +LB_PUBLISHED_PORT=8080 +LB_STATS_PORT=8404 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..7558e95a --- /dev/null +++ b/.gitattributes @@ -0,0 +1,6 @@ +# Shell-скрипты выполняются в Linux-контейнерах: всегда LF, даже при checkout на Windows. +*.sh text eol=lf +*.sql text eol=lf +*.conf text eol=lf +Dockerfile text eol=lf +*.Dockerfile text eol=lf diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..d6be5940 --- /dev/null +++ b/.github/workflows/app.yml @@ -0,0 +1,26 @@ +name: Application stack +# Сборка решения, готовность стенда, публичный smoke и failover. Без секретов репозитория: +# синтетические credentials генерирует scripts/init-secrets.sh прямо в runner. +on: [push, pull_request] +permissions: + contents: read +jobs: + stack: + runs-on: ubuntu-latest + timeout-minutes: 20 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.12' + - run: sh scripts/init-secrets.sh + - run: docker compose --env-file .env config --quiet + - run: docker compose --env-file .env up -d --build --wait + - run: make test PYTHON=python + - run: make test-failover PYTHON=python ACTION_SCRIPT=scripts/stop-one.sh + - run: sh scripts/restore.sh + - run: make test-persistence PYTHON=python ACTION_SCRIPT=scripts/restart.sh + - if: always() + run: docker compose --env-file .env logs --no-color --tail 200 lb api migrate + - if: always() + run: docker compose --env-file .env down -v diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..ac7edda9 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,30 @@ +# API мессенджера lab3 (stateless-реплика). Образ собирается из исходников этого репозитория. +FROM python:3.12.12-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 + +WORKDIR /srv + +# Сначала зависимости (кэшируемый слой), потом код. +COPY requirements.txt . +RUN pip install --no-deps -r requirements.txt + +COPY app ./app +COPY migrations ./migrations + +RUN useradd --system --uid 10001 --no-create-home appuser +USER appuser + +EXPOSE 8080 +HEALTHCHECK --interval=5s --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)"] + +# Метка сборки (последний слой, кэш не ломает): rolling update показывает, что реплики заменены новым образом. +ARG BUILD_ID=dev +LABEL org.opencontainers.image.revision=$BUILD_ID + +# exec-форма: python — PID 1 и сам получает SIGTERM от docker stop (drain -> graceful shutdown). +CMD ["python", "-m", "app"] diff --git a/REPORT.md b/REPORT.md index c2679005..cbf39344 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,166 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Запорожец Михаил, БВТ2304 +- Целевая оценка: **4** (трек 5 не заявлен) +- Commit/PR: TODO после публикации (ветка `solution/bvt2304-zaporozhets`) +- Использованные источники, библиотеки и помощь ИИ: документация HAProxy 3.2 (server-template/resolvers, http-check, retry-on, observe), Docker Compose (deploy.replicas/resources, healthcheck), PostgreSQL (INSERT … ON CONFLICT, deferrable constraints, READ COMMITTED); библиотеки FastAPI 0.115, uvicorn 0.34, asyncpg 0.30, argon2-cffi 23.1, redis-py 5.2. Код, конфигурации и тесты написаны с помощью ИИ-ассистента (Claude); решения разобраны и проверены автором. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Нужно:** Docker Engine/Desktop с Compose v2.20+ (проверено: Docker 29.8.2, Compose 5.6.0, Windows 11 + Docker Desktop, WSL2) и POSIX-shell (Linux/macOS или Git Bash). Для публичных проверок Python/make на хосте **не нужны** — они запускаются в сервисе `tester`. Python 3.9+ на хосте нужен только для серий отказов под нагрузкой (`student-tests/failover_series.py`), потому что rolling update создаёт контейнеры через compose с bind-путями хоста. + +| Роль | Сервис | Образ | Health/readiness | Volume | Сеть / порт | Credentials | +| --- | --- | --- | --- | --- | --- | --- | +| Балансировщик | `lb` | `haproxy:3.2.8-alpine` | wget `/stats`; сам проверяет API по `/health/ready` | — | edge; **единственная** публикация `127.0.0.1:8080` (+ `127.0.0.1:8404` статистика) | не нужны | +| API × N | `api` (`deploy.replicas: ${API_REPLICAS:-2}`) | сборка `Dockerfile` (python:3.12.12-slim-bookworm) | HEALTHCHECK `/health/ready` | нет; root fs read-only, `/tmp` tmpfs | edge + data; порты **не публикуются** | secrets `database_url`, `cache_url` | +| Миграции | `migrate` (one-shot) | тот же образ | exit 0 | — | data | secret `database_url` | +| PostgreSQL | `postgres` | `postgres:17.7-bookworm` | `pg_isready` | `pgdata` | data (internal) | `POSTGRES_PASSWORD_FILE` | +| Кэш сессий | `valkey` | `valkey/valkey:8.1.4` | `valkey-cli ping` | нет (кэш, persistence выключена намеренно) | data (internal) | `requirepass` в secret `valkey_conf` | +| API с TTL=2 с | `api-ttl` (profile `test`) | тот же образ | как у api | — | edge + data, без публикации | как у api | +| Тестовый стенд | `tester` (profile `tools`) | python:3.12.12-alpine3.22 + make + curl + docker-cli | — | bind `.` | edge | docker.sock | + +```sh +git clone && cd +sh scripts/init-secrets.sh # ./secrets/* со случайными паролями и .env из .env.example; значения не печатает +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait +# postgres, valkey -> migrate (однократно применяет миграции) -> api x2 (healthy) -> lb + +# Публичные проверки (Linux-контейнер tester; на Linux-хосте можно просто `make ...`) +docker compose --env-file .env --profile tools run --rm tester make check +docker compose --env-file .env --profile tools run --rm tester make test +docker compose --env-file .env --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh +docker compose --env-file .env --profile tools run --rm tester sh scripts/restore.sh # вернуть реплику +docker compose --env-file .env --profile tools run --rm tester make test-persistence ACTION_SCRIPT=scripts/restart.sh + +# Уровень 4 +sh scripts/test-lab3.sh # собственные тесты lab3 + регрессия уровня 4 из lab2 +python student-tests/failover_series.py --scenario stop --output evidence/failover-stop.json +python student-tests/failover_series.py --scenario kill --output evidence/failover-kill.json +python student-tests/failover_series.py --scenario rolling --duration 70 --action-at 10 --output evidence/rolling-update.json +sh scripts/collect-evidence.sh # все текстовые доказательства evidence/*.txt одной командой +``` + +- **Bootstrap/миграции:** `python -m app.migrate` (сервис `migrate`) применяет `migrations/NNNN_*.sql` по порядку, каждую в своей транзакции, под `pg_advisory_lock`; версия и SHA-256 пишутся в `schema_migrations`. Реплики API миграции **не** выполняют: `api` стартует только после `migrate: service_completed_successfully`, поэтому гонки реплик за схему нет. Повторный запуск печатает `skip` (`evidence/fresh-start.txt`). +- **Масштабирование:** `docker compose --env-file .env up -d --wait --no-recreate --scale api=4 api` — HAProxy сам находит новые реплики через DNS Docker (до 8 слотов `server-template`), конфигурация LB не меняется (`evidence/scale.txt`). +- **Rolling update:** `sh scripts/rolling-update.sh` (см. ниже). +- **Действий оператора**, кроме `init-secrets.sh`, не требуется. Если на 8080 уже работает стенд lab2 — остановить его (`docker compose -p mtusi-lab2 stop`) или задать `LB_PUBLISHED_PORT` в `.env`. +- **Безопасная остановка** (данные сохраняются): `docker compose --env-file .env stop` или `... down`. +- **Намеренное удаление учебных данных:** `docker compose --env-file .env down -v` (удаляет volume `mtusi-lab3_pgdata`); секреты — каталог `secrets/`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +клиент ──HTTP──> lb: HAProxy 3.2 (127.0.0.1:8080) сеть edge + │ roundrobin, без sticky; активная проверка /health/ready раз в 1 с; + │ реплики из DNS Docker (server-template api-1..8 -> имя "api") + ┌───────┴────────┐ + ▼ ▼ + api-1 ... api-N (FastAPI/uvicorn, stateless, X-Instance-Id) + │ asyncpg pool ≤10 │ redis-py, timeout 300 мс сеть data (internal) + ▼ ▼ + PostgreSQL 17 (источник истины) Valkey 8.1 (общий кэш копий сессий с TTL) + users, chats, chat_members, messages, sessions, idempotency_keys, cache_state +``` + +**Что перенесено из lab2:** весь API (пользователи, Argon2id, Basic → Bearer-сессии, чаты, keyset-пагинация, единый формат ошибок), схема `0001_init.sql`, раннер миграций, Valkey как read-through кэш сессий, тесты уровня 4 (как регрессия `student-tests/test_lab2_regression.py`). Объявленные переходы 2 → 3: обязательный `Idempotency-Key` для POST сообщения и `X-Instance-Id` во всех ответах API. + +**Что изменено в lab3:** + +1. **Stateless-реплики.** Сессии — в PostgreSQL (источник истины) + общий Valkey; локальной памяти, от которой зависит корректность, нет. Единственное такое место из lab2 нашёл перенесённый тест `test_revoke_during_cache_partition`: «окно недоверия к кэшу» после ошибки Valkey жило в памяти одного процесса, и **другая** реплика, не видевшая сбоя, отдавала копию отозванной сессии (тест падал: `expected 401, received 200`). Исправлено миграцией `0003_cache_state.sql`: реплика, получившая ошибку Valkey, публикует окно в PostgreSQL, а попадание в кэш принимается только если общий признак проверен не более 0,5 с назад (≤ 2 лёгких SELECT/с на реплику). Root fs контейнеров API read-only — некуда положить локальное состояние даже случайно. +2. **Идемпотентность** (`migrations/0002_idempotency.sql`, `create_message` в `app/main.py`). Таблица `idempotency_keys`, PK `(user_id, chat_id, key)` = область контракта «пользователь + метод + путь + ключ» (метод один). В **одной транзакции**: проверка членства → `INSERT` ключа `ON CONFLICT DO UPDATE … WHERE created_at < now − TTL RETURNING message_id` → `INSERT` сообщения с этим id. Конкурентный `INSERT` того же PK с другой реплики ждёт COMMIT/ROLLBACK первой транзакции (уникальный индекс работает как замок), затем видит строку и возвращает сохранённое сообщение (READ COMMITTED: каждый оператор видит свежий снимок). FK ключа на сообщение `DEFERRABLE INITIALLY DEFERRED` — ключ вставляется раньше сообщения. Сравнение тела — SHA-256 канонического JSON (порядок ключей/пробелы/`\u`-экранирование не важны); другое тело — 409, сохранённый результат не меняется. Транзиентная 5xx откатывает и ключ, и сообщение — повтор с тем же ключом создаёт запись ровно один раз. Повтор заново проверяет сессию и членство (после logout — 401, посторонний — 404). TTL ключа `IDEMPOTENCY_TTL_SECONDS` = 24 ч; просроченный ключ атомарно переиспользуется, фоновая очистка раз в час. +3. **X-Instance-Id** = `-<6 hex случайных>`: стабилен для жизни процесса, новый после рестарта; hostname = короткий ID контейнера, по нему `stop-one.sh` находит контейнер (и проверяет label `com.docker.compose.service=api`). В lab7 заменить на непрозрачный alias. +4. **Graceful shutdown** (`app/__main__.py`). SIGTERM → **drain** `SHUTDOWN_DRAIN_MS=3000`: процесс обслуживает запросы, но `/health/ready` = 503 и ответы с `Connection: close`; LB за это время выводит реплику из ротации. Затем штатный graceful shutdown uvicorn (новые соединения не принимаются, начатые запросы дообрабатываются до 10 с). `stop_grace_period: 20s` > 3 + 10. Код выхода 0. +5. **Балансировщик** (`infra/haproxy/haproxy.cfg`). Почему не только `depends_on/healthcheck`: они управляют порядком старта и статусом контейнера, но не распределяют запросы и не убирают больной backend из маршрута — это делает LB. + - Обнаружение реплик: `resolvers docker` (127.0.0.11), повторное разрешение раз в 1 с; остановленный контейнер исчезает из DNS → слот в MAINT. + - Активная проверка: `GET /health/ready`, `inter 1s`, `fastinter 500ms`, `fall 2`, `rise 2`, `timeout check 1s`. + - Пассивная: `observe layer4 error-limit 2 on-error mark-down` — 2 ошибки соединения на живом трафике сразу дают DOWN. + - Повторы: `retries 2` + `option redispatch 1` (на **другую** реплику). L7-повторы `retry-on conn-failure empty-response response-timeout` разрешены только для GET и POST сообщения (защищён ключом); для POST `/users`, `/chats`, `/auth/sessions` и DELETE — `disable-l7-retry`: повтор только если запрос ещё не был отправлен. Так контракт («не добавляйте прозрачные повторы этих POST») соблюдён. + - Таймауты: connect 1 с, server 15 с (> statement_timeout 5 с), keep-alive к клиенту 10 с < keep-alive uvicorn 30 с. + - Если `/health/ready` не проходит ни у одной реплики (недоступна БД), запросы идут в резервный backend `api_live` (проверка `/health/live`): клиент получает честный 503 контракта от API (с `X-Instance-Id`), а `/health/live` работает. Ответы, созданные самим LB (502/503/504), тоже в формате ошибки контракта с `X-Request-Id`. +6. **Критичные зависимости readiness:** только PostgreSQL. Valkey не критичен (без него API медленнее, но корректен — `test_valkey_down`). +7. **Часы и порядок:** `created_at` и сроки сессий/ключей назначает PostgreSQL (`clock_timestamp()`), а не реплика — расхождение часов реплик не влияет на порядок истории и TTL. + +**Транзакционные границы:** создание чата + участники — одна транзакция; ключ идемпотентности + сообщение — одна транзакция; logout — COMMIT `revoked_at`, затем DEL из кэша (при ошибке — общее окно недоверия). + +**Соответствие `.env.example` конфигурации** + +| Переменная | Где используется | Значение по умолчанию | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT` | uvicorn в контейнере API (`APP_PORT` в compose зафиксирован 8080) | `0.0.0.0`, 8080 | +| `APP_ENV` | метка окружения | `lab` | +| `SESSION_TTL_SECONDS` | срок сессии в PostgreSQL | 3600 | +| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | пути к Compose secrets внутри контейнера | `/run/secrets/...` | +| `SESSION_STORE` | `postgres` или `postgres+valkey` | `postgres+valkey` | +| `API_REPLICAS` | `deploy.replicas` сервиса `api` | 2 | +| `IDEMPOTENCY_TTL_SECONDS` | срок жизни ключа (не меньше 24 ч, проверяется при старте) | 86400 | +| `SESSION_CACHE_TTL_SECONDS` | TTL копии сессии в Valkey и длина окна недоверия | 60 | +| `SHUTDOWN_DRAIN_MS` | drain при SIGTERM | 3000 | +| `DB_POOL_MAX`, `DB_STATEMENT_TIMEOUT_MS`, `DB_ACQUIRE_TIMEOUT_MS`, `CACHE_TIMEOUT_MS` | пул и таймауты на реплику | 10, 5000, 2000, 300 | +| `PASSWORD_HASH_WORKERS` | параллельные Argon2id на реплику (по 64 MiB) | 2 | +| `API_CPUS`, `API_MEMORY`, `PG_CPUS` | лимиты контейнеров | 1.0, 384M, 2.0 | +| `LB_PUBLISHED_PORT`, `LB_STATS_PORT` | порты LB на 127.0.0.1 | 8080, 8404 | + +**Лимиты ресурсов** (`deploy.resources.limits`, проверяет `test_infrastructure_rules`): api 1 CPU / 384 MiB на реплику, postgres 2 CPU / 768 MiB, valkey 0.5 CPU / 96 MiB, lb 1 CPU / 128 MiB, migrate 0.5 CPU / 128 MiB. Нет `container_name`; порты публикует только `lb` и только на 127.0.0.1; сеть `data` — `internal: true`, LB в неё не входит; secret БД получают только api/migrate/postgres, secret Valkey — только valkey и api. ## Доказательства критериев +Все файлы — `evidence/`, дата прогона 2026-11-05, хост: Intel i5-1135G7 (8 потоков), 7.8 GB RAM; Docker Desktop VM: 8 CPU, 3.7 GiB. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make check`, `make validate`, `make test` (в tester, через LB) | 3 × PASS | `public-tests.txt` | +| 3: стенд в compose.yaml, ≥2 API, один вход, общие БД и store сессий | `docker compose up -d --build --wait`; `compose ps` | 2 api + lb + postgres + valkey healthy, порт только у lb | `instances.txt` | +| 3: разные запросы одной сессии — разные реплики | `student-tests/show_instances.py` (1 вход, 10 запросов через LB) | 2 разных `X-Instance-Id` по 5 раз, без повторного входа | `instances.txt` | +| 3: остановка любой одной реплики, ≤10 с | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` × 2 (по очереди api-6 и api-5, restore между ними) | PASS, `failed_attempts: 0`; запись не прерывалась (`first_recovery_seconds` ≈ 4 с = длительность самого hook: drain 3 с + shutdown) | `failover-hook.txt`, `stop-one.log` | +| 3: какой контейнер реально остановлен | `evidence/stop-one.log` пишет hook | `container=mtusi-lab3-api-6 … exited exit=0`, затем `api-5` | `failover-hook.txt` | +| 3: идемпотентность, повтор не создаёт дубль | smoke (replay/409/400); `test_same_key_concurrent_across_replicas` | 24 параллельных POST с одним ключом **напрямую в обе реплики** → 24 × 201, одно тело, 1 строка в `messages` | `student-tests.txt` | +| 3: persistence, прежний токен | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; `StartedAt` lb, api ×2, postgres, valkey изменились, volume сохранён | `persistence.txt` | +| 3: запуск с пустого volume | отдельный проект `-p mtusi-lab3-fresh`, smoke, повтор migrate | `apply 0001..0003`, smoke PASS, повтор — `skip` | `fresh-start.txt` | +| 4: health/readiness, timeouts, SIGTERM согласованы; LB исключает backend | `test_sigterm_drain`; серия `stop` | после SIGTERM ready=503, live=200, запросы ещё обслуживаются с `Connection: close`; через 2 с LB на неё не шлёт; exit 0. LB пометил DOWN через 1,34–1,52 с, последний ответ от цели 1,2–1,3 с | `student-tests.txt`, `failover-stop.json` | +| 4: период проверок и макс. время обнаружения | конфигурация + измерение | см. таблицу «Обнаружение отказа» ниже | `haproxy.cfg`, `failover-*.json` | +| 4: каждая реплика по очереди под нагрузкой: RPS, ошибки, восстановление | `failover_series.py --scenario stop` и `--scenario kill` | 4 прогона, **0 ошибок клиента**, 0 потерь/дублей; таблица ниже | `failover-stop.json`, `failover-kill.json` | +| 4: общая идемпотентность параллельными запросами | `test_same_key_concurrent_*` | один ключ: 24/24 одинаковых 201; два тела под одним ключом: 10 × 201 (одно тело) + 10 × 409, 1 сообщение | `student-tests.txt` | +| 4: retry после транзиентной ошибки | `test_transient_failure_not_recorded` | при остановленной БД POST → 503 от API; после восстановления тот же ключ → 201, повтор → тот же ответ, 1 сообщение | `student-tests.txt` | +| 4: CPU/RAM-лимиты, нет обхода LB, нет container_name, общие только нужные секреты/хранилища | `test_infrastructure_rules` (docker inspect) | PASS: лимиты у всех, у api нет PortBindings, read-only root fs, монтируются только 2 secret | `student-tests.txt` | +| 4: rolling update под нагрузкой; миграции однократно и совместимы | `failover_series.py --scenario rolling` (`scripts/rolling-update.sh` разворачивал исправление кэша + миграцию 0003) | 0 ошибок за 70 с; `apply 0003_cache_state` один раз до замены; новые реплики с label сборки `0ab3a34-1793888112`; RPS до/во время/после 283/243/280 | `rolling-update.json` | +| 4: возможности lab2 сохранены | `test_lab2_regression.py` через LB | 10/10 (TTL, logout, гонка регистрации, откат чата, курсоры, кэш, отказ Valkey/БД, разрыв с Valkey) | `student-tests.txt` | +| 4: масштабирование без правки LB | `--scale api=4`, затем `=2` | 4 слота UP в HAProxy, одна сессия обслужена 4 репликами | `scale.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Профиль серий** (`student-tests/failover_series.py`): closed-loop, 4 писателя (POST сообщения; при неопределённом результате — повтор с тем же ключом и телом) + 2 читателя (GET истории `limit=20`), таймаут клиента 3 с, 25 с на прогон, воздействие на 8-й секунде, клиент — Python на хосте Windows через проброс порта Docker Desktop. Параллельно раз в 200 мс опрашивается `/stats;csv` HAProxy — оттуда время, когда слот цели перестал быть UP. Окна: «до» = [1 с; воздействие), «во время» = [воздействие; конец hook + 5 с), «после» = остаток. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker stop` api-5 (SIGTERM, drain) | LB выводит реплику до закрытия сокета, ошибок нет | 0 ошибок; DOWN в LB через 1,34 с; последний ответ цели 1,22 с; RPS 341 → 303 → 279; p99 63 → 78 мс | ошибок не было; 4766/4766 подтверждённых записей в истории, дублей 0 | +| `docker stop` api-6 | то же | 0 ошибок; DOWN через 1,52 с; RPS 349 → 258 → 259; max 188 мс | 0; 4461/4461, дублей 0 | +| `docker kill` api-5 (SIGKILL, без drain) | краткие ошибки допустимы, повтор с ключом не дублирует | 0 ошибок клиента; DOWN через 0,31 с; HAProxy: 3 retry, 5 redispatch; max задержка 1015 мс (= `timeout connect` 1 с + повтор на другой реплике) | 0; 4225/4225, дублей 0 | +| `docker kill` api-6 | то же | 0 ошибок; DOWN через 0,16 с; 1 retry, 3 redispatch; max 1031 мс | 0; 4240/4240, дублей 0 | +| `rolling-update.sh` (сборка, migrate 0003, surge ×2, поочерёдный stop старых) | 0 ошибок, обе реплики заменены | 0 ошибок за 36 с операции; 4 redispatch; RPS 283 → 243 → 280; p99 78 → 94 → 78 мс | 0; 11433/11433, дублей 0 | +| public `test-failover` × 2 (по очереди обе реплики) | ≥2 реплики до, восстановление ≤10 с | `failed_attempts 0`, 135–136 записей за 15 с | запись не прерывалась | +| `restart.sh` (всё, кроме volume) | данные и токен переживают | PASS | ≈ 20 с до готовности; потерь нет | +| остановка PostgreSQL | честный 503, без 500 и без пропуска | 503 `unavailable` от API через `api_live`, live = 200; после старта — та же сессия | ≈ 5–10 с после старта БД | + +**Обнаружение отказа (конфигурация → верхняя граница → измерено):** + +| Тип отказа | Механизм | Граница | Измерено | +| --- | --- | --- | --- | +| Остановка процесса (SIGTERM) | ready = 503 → активная проверка: ≤ 1 с до проверки + 1 × fastinter 0,5 с (fall 2) | ≈ 1,5 с (+ время ответа проверки); drain 3 с её перекрывает | 1,34–1,52 с, 0 ошибок | +| Внезапная смерть процесса / контейнера | пассивно: 2 ошибки соединения → DOWN; DNS: запись исчезает, разрешение раз в 1 с; активно: ≤ 1 с + 2 × (timeout check 1 с) + 0,5 с | пассивно — сразу; DNS ≤ ~2 с; активно ≤ ~3,5 с | 0,16–0,31 с; запросы в полёте повторены на другой реплике (≤ 1 с задержки) | +| Зависание без закрытия сокета | timeout check 1 с × fall 2; запрос клиента — `timeout server` 15 с, затем L7-повтор для GET/POST сообщения | ≈ 3,5 с для новых запросов | не измерялось (см. ограничения) | + +**Нагрузка на стенд** (`tests/load.py --duration 30 --concurrency 8` из tester, только POST): 460 успешных RPS, 0 ошибок, p50/p95/p99 = 14/43/80 мс (`load.json`). `docker stats` в середине (`load-stats.txt`): api 91–92 % от лимита 1 CPU **каждая**, postgres 55 %, lb 29 %, клиент 77 %; RAM api ≈ 40 MiB из 384. Узкое место этого профиля — CPU API-реплик (Python), а не БД или LB. Сравнение 1/2/4 реплик при фиксированном CPU и поиск saturation point — это трек 5.1, здесь не заявляется. + +**Ограничения измерений.** Closed-loop клиент страдает coordinated omission; на Windows-хосте клиент идёт через проброс портов Docker Desktop, поэтому абсолютные RPS серий (≈ 250–350) ниже, чем из контейнера (460) и не являются оценкой ёмкости. RPS «после» отказа ниже, потому что остаётся одна реплика с 1 CPU. Каждый сценарий прогнан по одному разу на реплику — разброс не оценён. Время обнаружения измерено с дискретностью опроса статистики 200 мс. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Выдерживается:** остановка или внезапная смерть любой одной API-реплики (в том числе поочерёдно каждой), rolling update, перезапуск всего стенда с volume, недоступность Valkey, разрыв API ↔ Valkey при logout. +- **Не выдерживается** (честно): отказ Docker-host (все контейнеры на одном узле), отказ `lb` (единственный HAProxy — SPOF), отказ PostgreSQL (одна БД без реплики: на время простоя — 503, данные сохраняются на volume). Отказ процесса ≠ отказ узла: при потере узла пропали бы и LB, и БД. +- **POST `/users`, `/chats`, `/auth/sessions`** не защищены ключом: если реплика умрёт после получения такого запроса, клиент может получить 502, а самостоятельный повтор может создать второй объект (это разрешено контрактом; L7-повтор LB для них намеренно выключен). +- **Окно согласованности кэша сессий** при частичном разрыве с Valkey — не более 0,5 с (время до проверки общего признака другой репликой), вместо 60 с, которые были бы без общего признака. Полностью строгий вариант — отказаться от кэша. +- **Миграции** — только expand (добавление): версия N−1 работает на схеме N, поэтому `migrate` выполняется один раз перед заменой реплик. Удаляющие изменения (contract) потребовали бы отдельного шага после того, как старые реплики выведены, — в этой работе их нет. +- **X-Instance-Id** содержит hostname контейнера (= его ID) — допустимо для lab3, для lab7 нужен непрозрачный alias. +- **Зависание реплики** (живой сокет, нет ответа) отдельно не моделировалось; ожидаемое поведение — вывод по `timeout check`, первые запросы ждут до `timeout server` 15 с. +- Следующие шаги: трек 5.1 (k6 open-loop, 1/2/4 реплики при фиксированном CPU, пул БД как кандидат в узкое место), реплицированная PostgreSQL и второй LB для заявления устойчивости к потере узла. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..1f057ca2 --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,48 @@ +"""Запуск: python -m app (HTTP-процесс — PID 1 в контейнере). + +SIGTERM (docker stop) обрабатывается в два этапа: +1. drain: SHUTDOWN_DRAIN_MS процесс продолжает обслуживать запросы, но /health/ready отвечает 503 — + балансировщик за это время исключает реплику по активной проверке и перестаёт слать новые запросы; +2. обычный graceful shutdown uvicorn: новые соединения не принимаются, начатые запросы + дообрабатываются до timeout_graceful_shutdown. +""" +import logging +import os +import threading + +import uvicorn + +from . import lifecycle + +log = logging.getLogger('messenger') + + +class DrainingServer(uvicorn.Server): + drain_seconds = 0.0 + + def handle_exit(self, sig, frame): + if lifecycle.draining or self.drain_seconds <= 0: + # Повторный сигнал (или drain выключен) — сразу штатное завершение uvicorn. + return super().handle_exit(sig, frame) + lifecycle.start_draining() + log.info('signal %s: draining for %.1fs before shutdown, instance=%s', + sig, self.drain_seconds, lifecycle.INSTANCE_ID) + timer = threading.Timer(self.drain_seconds, super().handle_exit, (sig, frame)) + timer.daemon = True + timer.start() + + +def main() -> None: + logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(name)s %(message)s') + config = uvicorn.Config('app.main:app', host=os.environ.get('APP_HOST', '0.0.0.0'), + port=int(os.environ.get('APP_PORT', '8080')), proxy_headers=False, + server_header=False, timeout_graceful_shutdown=10, + timeout_keep_alive=30) # дольше, чем держит idle-соединение HAProxy + server = DrainingServer(config) + server.drain_seconds = int(os.environ.get('SHUTDOWN_DRAIN_MS', '3000')) / 1000 + log.info('starting instance %s', lifecycle.INSTANCE_ID) + server.run() + + +if __name__ == '__main__': + main() diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..0cda19ba --- /dev/null +++ b/app/config.py @@ -0,0 +1,63 @@ +"""Настройки из переменных окружения. Секреты читаются только из файлов (*_FILE).""" +import os +from dataclasses import dataclass +from pathlib import Path + + +def _int(name: str, default: int, low: int, high: int) -> int: + value = int(os.environ.get(name, default)) + if not low <= value <= high: + raise ValueError(f'{name} must be in [{low}, {high}]') + return value + + +def _secret(name: str) -> str | None: + """Значение из файла, путь к которому лежит в переменной NAME_FILE.""" + path = os.environ.get(name + '_FILE') + if not path: + return None + return Path(path).read_text(encoding='utf-8').strip() + + +@dataclass(frozen=True) +class Settings: + host: str + port: int + session_ttl: int + session_store: str + session_cache_ttl: int + database_url: str + cache_url: str | None + db_pool_max: int + db_statement_timeout_ms: int + db_acquire_timeout: float + cache_timeout: float + hash_workers: int + idempotency_ttl: int + drain_seconds: float + + +def load() -> Settings: + database_url = _secret('DATABASE_URL') or os.environ.get('DATABASE_URL') + if not database_url: + raise RuntimeError('DATABASE_URL_FILE is not configured') + store = os.environ.get('SESSION_STORE', 'postgres') + if store not in ('postgres', 'postgres+valkey'): + raise ValueError('SESSION_STORE must be postgres or postgres+valkey') + cache_url = _secret('CACHE_URL') if store == 'postgres+valkey' else None + return Settings( + host=os.environ.get('APP_HOST', '0.0.0.0'), + port=_int('APP_PORT', 8080, 1, 65535), + session_ttl=_int('SESSION_TTL_SECONDS', 3600, 1, 30 * 24 * 3600), + session_store=store, + session_cache_ttl=_int('SESSION_CACHE_TTL_SECONDS', 60, 1, 3600), + database_url=database_url, + cache_url=cache_url, + db_pool_max=_int('DB_POOL_MAX', 10, 1, 100), + db_statement_timeout_ms=_int('DB_STATEMENT_TIMEOUT_MS', 5000, 100, 600000), + db_acquire_timeout=_int('DB_ACQUIRE_TIMEOUT_MS', 2000, 100, 60000) / 1000, + cache_timeout=_int('CACHE_TIMEOUT_MS', 300, 10, 10000) / 1000, + hash_workers=_int('PASSWORD_HASH_WORKERS', 4, 1, 32), + idempotency_ttl=_int('IDEMPOTENCY_TTL_SECONDS', 86400, 86400, 30 * 24 * 3600), # контракт: не менее 24 ч + drain_seconds=_int('SHUTDOWN_DRAIN_MS', 3000, 0, 60000) / 1000, + ) diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..dbcb5fa9 --- /dev/null +++ b/app/db.py @@ -0,0 +1,65 @@ +"""Ограниченный пул соединений asyncpg и перевод сбоев БД в 503.""" +import asyncio +from contextlib import asynccontextmanager + +import asyncpg + +from .config import Settings +from .errors import unavailable + +# Ошибки "БД недоступна/перегружена" -> 503, а не 500 и тем более не пропуск запроса. +DB_UNAVAILABLE = ( + OSError, + asyncio.TimeoutError, + asyncpg.PostgresConnectionError, + asyncpg.InterfaceError, + asyncpg.CannotConnectNowError, + asyncpg.TooManyConnectionsError, + asyncpg.QueryCanceledError, # statement_timeout + asyncpg.AdminShutdownError, +) + + +class Database: + def __init__(self, settings: Settings): + self.settings = settings + self.pool: asyncpg.Pool | None = None + + async def start(self) -> None: + s = self.settings + # min_size соединений создаётся лениво (connect при первом acquire), поэтому API стартует + # даже при недоступной БД и честно отвечает 503 в /health/ready. + self.pool = asyncpg.create_pool( + s.database_url, + min_size=0, + max_size=s.db_pool_max, + timeout=3, # таймаут установления соединения + command_timeout=s.db_statement_timeout_ms / 1000 + 1, + max_inactive_connection_lifetime=300, + server_settings={ + 'application_name': 'messenger-api', + 'statement_timeout': str(s.db_statement_timeout_ms), + 'idle_in_transaction_session_timeout': '10000', + 'timezone': 'UTC', + }, + ) + await self.pool + + async def close(self) -> None: + if self.pool is not None: + await self.pool.close() + + @asynccontextmanager + async def connection(self): + try: + async with self.pool.acquire(timeout=self.settings.db_acquire_timeout) as conn: + yield conn + except DB_UNAVAILABLE: + raise unavailable() from None + + async def ping(self) -> bool: + try: + async with self.pool.acquire(timeout=1) as conn: + return await conn.fetchval('SELECT 1', timeout=1) == 1 + except DB_UNAVAILABLE: + return False diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..82a88acc --- /dev/null +++ b/app/errors.py @@ -0,0 +1,48 @@ +"""Единый формат ошибок {"error":{"code","message","request_id"}}.""" +from contextvars import ContextVar + +from fastapi.responses import JSONResponse + +request_id_var: ContextVar[str] = ContextVar('request_id', default='-') + +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: dict | None = None): + super().__init__(message) + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + + +def invalid(message: str = 'Некорректный запрос') -> ApiError: + return ApiError(400, 'invalid_request', message) + + +def not_found() -> ApiError: + # Одинаковый ответ для "нет такого" и "чужое": существование чужого чата не раскрывается. + return ApiError(404, 'not_found', 'Объект не найден') + + +def unauthorized_bearer() -> ApiError: + return ApiError(401, 'unauthorized', 'Требуется действительная сессия', {'WWW-Authenticate': BEARER_CHALLENGE}) + + +def unauthorized_basic() -> ApiError: + return ApiError(401, 'unauthorized', 'Неверные учётные данные', {'WWW-Authenticate': BASIC_CHALLENGE}) + + +def unavailable() -> ApiError: + return ApiError(503, 'unavailable', 'Сервис временно недоступен') + + +def error_response(status: int, code: str, message: str, headers: dict | None = None) -> JSONResponse: + rid = request_id_var.get() + return JSONResponse( + status_code=status, + content={'error': {'code': code, 'message': message, 'request_id': rid}}, + headers=headers, + ) diff --git a/app/lifecycle.py b/app/lifecycle.py new file mode 100644 index 00000000..acb168e4 --- /dev/null +++ b/app/lifecycle.py @@ -0,0 +1,16 @@ +"""Состояние процесса реплики: идентификатор для X-Instance-Id и флаг drain при SIGTERM.""" +import os +import secrets +import socket + +# Стабилен в пределах жизни процесса, новый после перезапуска. Префикс — hostname контейнера +# (= короткий ID контейнера в Docker), по нему scripts/stop-one.sh находит именно эту реплику. +# В lab7 по контракту понадобится непрозрачный alias без hostname. +INSTANCE_ID = os.environ.get('INSTANCE_ID') or f'{socket.gethostname()}-{secrets.token_hex(3)}' + +draining = False + + +def start_draining() -> None: + global draining + draining = True diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..5907a8a3 --- /dev/null +++ b/app/main.py @@ -0,0 +1,414 @@ +"""HTTP API мессенджера lab3 по contracts/openapi.json (stateless-реплика за балансировщиком).""" +import asyncio +import base64 +import binascii +import hashlib +import json +import logging +import re +import uuid +from contextlib import asynccontextmanager +from datetime import datetime, timezone +from uuid import UUID + +import asyncpg +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from starlette.exceptions import HTTPException as StarletteHTTPException + +from . import config, lifecycle, validation as v +from .db import DB_UNAVAILABLE, Database +from .errors import (ApiError, error_response, invalid, not_found, request_id_var, + unauthorized_basic, unauthorized_bearer, unavailable) +from .security import PasswordService, new_token +from .sessions import SessionStore + +log = logging.getLogger('messenger') +settings = config.load() +db = Database(settings) +sessions = SessionStore(settings, db) +passwords = PasswordService(settings.hash_workers) + + +async def purge_loop() -> None: + while True: + await asyncio.sleep(3600) + try: + removed = await sessions.purge_expired() + keys = await purge_idempotency_keys() + log.info('purged %d expired sessions, %d idempotency keys', removed, keys) + except Exception: # очистка — фоновая гигиена, её сбой не должен ронять процесс + log.warning('purge failed', exc_info=True) + + +async def purge_idempotency_keys() -> int: + # Удаление по одному ключу индекса created_at; параллельный запуск на нескольких репликах безопасен. + async with db.connection() as conn: + status = await conn.execute( + 'DELETE FROM idempotency_keys WHERE created_at < clock_timestamp() - make_interval(secs => $1)', + settings.idempotency_ttl) + return int(status.split()[-1]) + + +@asynccontextmanager +async def lifespan(_app: FastAPI): + await db.start() + task = asyncio.create_task(purge_loop()) + yield + task.cancel() + await sessions.cache.close() + await db.close() + passwords.close() + + +app = FastAPI(lifespan=lifespan, openapi_url=None, docs_url=None, redoc_url=None) + +# ---------- request id, ошибки ---------- + +REQUEST_ID_RE = re.compile(r'[A-Za-z0-9._:-]{1,128}') + + +@app.middleware('http') +async def request_id_middleware(request: Request, call_next): + incoming = request.headers.get('x-request-id', '') + rid = incoming if REQUEST_ID_RE.fullmatch(incoming) else uuid.uuid4().hex + request_id_var.set(rid) + try: + response = await call_next(request) + except Exception: + log.exception('unhandled error, request_id=%s', rid) + response = error_response(500, 'internal_error', 'Внутренняя ошибка сервера') + response.headers['X-Request-Id'] = rid + response.headers['X-Instance-Id'] = lifecycle.INSTANCE_ID + if lifecycle.draining: + # Во время drain закрываем keep-alive: следующий запрос LB откроет соединение уже к живой реплике. + response.headers['Connection'] = 'close' + return response + + +@app.exception_handler(ApiError) +async def api_error_handler(_request: Request, exc: ApiError): + return error_response(exc.status, exc.code, exc.message, exc.headers) + + +@app.exception_handler(StarletteHTTPException) +async def http_error_handler(_request: Request, exc: StarletteHTTPException): + if exc.status_code == 404: + return error_response(404, 'not_found', 'Объект не найден') + if exc.status_code == 405: + return error_response(405, 'invalid_request', 'Метод не поддерживается', dict(exc.headers or {})) + return error_response(exc.status_code, 'invalid_request', 'Некорректный запрос') + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(_request: Request, _exc: RequestValidationError): + return error_response(400, 'invalid_request', 'Некорректный запрос') + + +async def db_unavailable_handler(_request: Request, _exc: Exception): + # Страховка: сбой связи с БД вне db.connection() тоже даёт ограниченный 503, а не 500. + return error_response(503, 'unavailable', 'Сервис временно недоступен') + + +for _exc_type in DB_UNAVAILABLE: + app.add_exception_handler(_exc_type, db_unavailable_handler) + +# ---------- представление ---------- + + +def ts(value: datetime) -> str: + # RFC 3339 UTC с микросекундами: точность совпадает с timestamptz и с ключом пагинации. + return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ') + + +def user_json(row) -> dict: + return {'id': str(row['id']), 'username': row['username'], + 'display_name': row['display_name'], 'created_at': ts(row['created_at'])} + + +def chat_json(row) -> dict: + return {'id': str(row['id']), 'title': row['title'], + 'member_ids': [str(m) for m in row['member_ids']], 'created_at': ts(row['created_at'])} + + +def message_json(row) -> dict: + return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']), + 'text': row['text'], 'created_at': ts(row['created_at'])} + + +USER_COLUMNS = 'id, username, display_name, created_at' +CHAT_COLUMNS = ('c.id, c.title, c.created_at, ' + 'ARRAY(SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id) AS member_ids') +MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, created_at' + +# ---------- аутентификация ---------- + +TOKEN_RE = re.compile(r'[A-Za-z0-9_-]{32,128}') + + +def bearer_token(request: Request) -> str: + """Только Authorization: Bearer. X-User-Id и Basic здесь игнорируются/отклоняются.""" + scheme, _, token = request.headers.get('authorization', '').partition(' ') + token = token.strip() + if scheme.lower() != 'bearer' or not TOKEN_RE.fullmatch(token): + raise unauthorized_bearer() + return token + + +async def current_user(request: Request) -> UUID: + session = await sessions.resolve(bearer_token(request)) + if session is None: + raise unauthorized_bearer() + return session.user_id + + +def basic_credentials(request: Request) -> tuple[str, str]: + scheme, _, encoded = request.headers.get('authorization', '').partition(' ') + if scheme.lower() != 'basic': + raise unauthorized_basic() + try: + decoded = base64.b64decode(encoded.strip(), validate=True) + username, sep, password = decoded.partition(b':') # двоеточие допустимо внутри пароля + if not sep: + raise ValueError + return username.decode('ascii'), password.decode('utf-8') + except (ValueError, binascii.Error, UnicodeDecodeError): + raise unauthorized_basic() from None + +# ---------- health ---------- + + +@app.get('/health/live') +async def live(): + return {'status': 'ok'} + + +@app.get('/health/ready') +async def ready(): + # Критична только PostgreSQL (источник истины). Valkey — кэш: без него API работает медленнее, но корректно. + # Во время drain (получен SIGTERM) реплика честно сообщает LB, что новых запросов ей давать не надо. + if lifecycle.draining or not await db.ping(): + raise unavailable() + return {'status': 'ok'} + +# ---------- пользователи и сессии ---------- + + +@app.post('/api/v1/users', status_code=201) +async def create_user(request: Request): + data = await v.read_json(request) + v.fields(data, {'username', 'display_name', 'password'}) + username = v.username(data) + display_name = v.text_field(data, 'display_name', 1, 100) + password = v.text_field(data, 'password', 12, 128) + password_hash = await passwords.hash(password) + try: + async with db.connection() as conn: + row = await conn.fetchrow( + f'INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING {USER_COLUMNS}', + username, display_name, password_hash) + except asyncpg.UniqueViolationError: + # Гонка двух одинаковых регистраций решается UNIQUE-индексом: COMMIT пройдёт только у одной. + raise ApiError(409, 'conflict', 'username уже занят') from None + return JSONResponse(user_json(row), status_code=201) + + +@app.post('/api/v1/auth/sessions', status_code=201) +async def create_session(request: Request): + if await request.body(): + raise invalid('Тело запроса не допускается; используйте Authorization: Basic') + username, password = basic_credentials(request) + row = None + if v.USERNAME_RE.fullmatch(username) and 12 <= len(password) <= 128: + async with db.connection() as conn: + row = await conn.fetchrow( + f'SELECT {USER_COLUMNS}, password_hash FROM users WHERE username = $1', username) + # verify выполняется всегда (и для несуществующего пользователя) — одинаковое время ответа. + if not await passwords.verify(row['password_hash'] if row else None, password): + raise unauthorized_basic() + token = new_token() + session = await sessions.create(row['id'], token) + return JSONResponse({'token': token, 'token_type': 'Bearer', 'expires_at': ts(session.expires_at), + 'user': user_json(row)}, status_code=201, headers={'Cache-Control': 'no-store'}) + + +@app.delete('/api/v1/auth/sessions/current', status_code=204) +async def delete_session(request: Request): + token = bearer_token(request) + if not await sessions.revoke(token): + raise unauthorized_bearer() + return Response(status_code=204) + + +@app.get('/api/v1/users/me') +async def me(request: Request): + user_id = await current_user(request) + async with db.connection() as conn: + row = await conn.fetchrow(f'SELECT {USER_COLUMNS} FROM users WHERE id = $1', user_id) + if row is None: + raise not_found() + return user_json(row) + +# ---------- чаты ---------- + + +@app.post('/api/v1/chats', status_code=201) +async def create_chat(request: Request): + user_id = await current_user(request) + data = await v.read_json(request) + v.fields(data, {'title', 'member_ids'}) + title = v.text_field(data, 'title', 1, 100) + raw_members = data['member_ids'] + if not isinstance(raw_members, list) or not 1 <= len(raw_members) <= 100: + raise invalid('member_ids должен быть массивом из 1..100 UUID') + members = [v.uuid_value(m, 'member_id') for m in raw_members] + if len(set(members)) != len(members): + raise invalid('member_ids содержит дубликаты') + if user_id not in members: + raise invalid('Создатель должен входить в member_ids') + + async with db.connection() as conn: + # Одна транзакция: чат и все участники появляются вместе или не появляются вовсе. + async with conn.transaction(): + chat = await conn.fetchrow( + 'INSERT INTO chats (title, created_by) VALUES ($1, $2) RETURNING id, created_at', title, user_id) + added = await conn.fetch( + 'INSERT INTO chat_members (chat_id, user_id) ' + 'SELECT $1, u.id FROM users u WHERE u.id = ANY($2::uuid[]) RETURNING user_id', + chat['id'], members) + if len(added) != len(members): + # Исключение внутри conn.transaction() -> ROLLBACK, строка chats тоже откатывается. + raise invalid('member_ids содержит неизвестных пользователей') + return JSONResponse({'id': str(chat['id']), 'title': title, + 'member_ids': sorted(str(m) for m in members), + 'created_at': ts(chat['created_at'])}, status_code=201) + + +@app.get('/api/v1/chats') +async def list_chats(request: Request): + user_id = await current_user(request) + limit = v.limit_param(request) + after = v.decode_cursor(request, 'chats') + query = (f'SELECT {CHAT_COLUMNS} FROM chats c ' + 'JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ') + params = [user_id, limit + 1] + if after: + query += 'WHERE (c.created_at, c.id) > ($3, $4) ' + params += after + query += 'ORDER BY c.created_at, c.id LIMIT $2' + async with db.connection() as conn: + rows = await conn.fetch(query, *params) + return page(rows, limit, 'chats', chat_json) + + +def page(rows, limit: int, scope: str, render) -> dict: + # Читаем limit+1 строку: если лишняя есть — следующая страница существует. + items = rows[:limit] + cursor = (v.encode_cursor(scope, items[-1]['created_at'], items[-1]['id']) + if len(rows) > limit else None) + return {'items': [render(r) for r in items], 'next_cursor': cursor} + + +async def chat_for_member(conn, chat_id: UUID, user_id: UUID): + return await conn.fetchrow( + f'SELECT {CHAT_COLUMNS} FROM chats c ' + 'WHERE c.id = $1 AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)', + chat_id, user_id) + + +@app.get('/api/v1/chats/{chat_id}') +async def get_chat(chat_id: str, request: Request): + user_id = await current_user(request) + cid = v.uuid_value(chat_id, 'chat_id') + async with db.connection() as conn: + row = await chat_for_member(conn, cid, user_id) + if row is None: + raise not_found() + return chat_json(row) + +# ---------- сообщения ---------- + + +IDEMPOTENCY_KEY_RE = re.compile(r'[A-Za-z0-9._:-]{1,128}') + + +def idempotency_key(request: Request) -> str: + key = request.headers.get('idempotency-key') + if key is None or not IDEMPOTENCY_KEY_RE.fullmatch(key): + raise invalid('Требуется заголовок Idempotency-Key: [A-Za-z0-9._:-]{1,128}') + return key + + +def request_fingerprint(text: str) -> bytes: + # Хешируем разобранное тело, а не байты: порядок ключей и пробелы JSON не делают запрос "другим". + canonical = json.dumps({'text': text}, ensure_ascii=False, sort_keys=True, separators=(',', ':')) + return hashlib.sha256(canonical.encode('utf-8')).digest() + + +@app.post('/api/v1/chats/{chat_id}/messages', status_code=201) +async def create_message(chat_id: str, request: Request): + # Повтор заново проверяет сессию и членство: сохранённый ответ не выдаётся без текущего доступа. + user_id = await current_user(request) + cid = v.uuid_value(chat_id, 'chat_id') + key = idempotency_key(request) + data = await v.read_json(request) + v.fields(data, {'text'}) # sender_id в запросе не принимается — отправитель берётся из сессии + text = v.text_field(data, 'text', 1, 4000) + fingerprint = request_fingerprint(text) + async with db.connection() as conn: + async with conn.transaction(): + member = await conn.fetchval( + 'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2', cid, user_id) + if member is None: + raise not_found() + # Ключ — "замок": параллельный INSERT того же PK с другой реплики ждёт COMMIT/ROLLBACK этой + # транзакции. Просроченный (старше TTL) ключ атомарно переиспользуется как новый. + message_id = await conn.fetchval( + 'INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, message_id) ' + 'VALUES ($1, $2, $3, $4, gen_random_uuid()) ' + 'ON CONFLICT (user_id, chat_id, key) DO UPDATE ' + 'SET request_hash = EXCLUDED.request_hash, message_id = EXCLUDED.message_id, ' + ' created_at = clock_timestamp() ' + 'WHERE idempotency_keys.created_at < clock_timestamp() - make_interval(secs => $5) ' + 'RETURNING message_id', + user_id, cid, key, fingerprint, settings.idempotency_ttl) + if message_id is not None: + # Ключ и сообщение фиксируются одним COMMIT: при сбое не остаётся ни того, ни другого, + # поэтому транзиентная 5xx не становится "окончательным" результатом ключа. + row = await conn.fetchrow( + f'INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) ' + f'RETURNING {MESSAGE_COLUMNS}', message_id, cid, user_id, text) + else: + row = await conn.fetchrow( + 'SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at ' + 'FROM idempotency_keys k JOIN messages m ON m.id = k.message_id ' + 'WHERE k.user_id = $1 AND k.chat_id = $2 AND k.key = $3', user_id, cid, key) + if row is None: + raise unavailable() # не должно случаться: ключ без сообщения не коммитится + if row['request_hash'] != fingerprint: + raise ApiError(409, 'conflict', 'Idempotency-Key уже использован с другим сообщением') + return JSONResponse(message_json(row), status_code=201) + + +@app.get('/api/v1/chats/{chat_id}/messages') +async def list_messages(chat_id: str, request: Request): + user_id = await current_user(request) + cid = v.uuid_value(chat_id, 'chat_id') + limit = v.limit_param(request) + after = v.decode_cursor(request, 'messages:' + str(cid)) + async with db.connection() as conn: + member = await conn.fetchval( + 'SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2', cid, user_id) + if member is None: + raise not_found() + if after: + # Keyset: продолжаем строго после последнего элемента прошлой страницы (без OFFSET). + rows = await conn.fetch( + f'SELECT {MESSAGE_COLUMNS} FROM messages WHERE chat_id = $1 AND (created_at, id) > ($3, $4) ' + 'ORDER BY created_at, id LIMIT $2', cid, limit + 1, *after) + else: + rows = await conn.fetch( + f'SELECT {MESSAGE_COLUMNS} FROM messages WHERE chat_id = $1 ' + 'ORDER BY created_at, id LIMIT $2', cid, limit + 1) + return page(rows, limit, 'messages:' + str(cid), message_json) diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..9be11b65 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,57 @@ +"""Версионированные миграции: migrations/NNNN_name.sql применяются по порядку, каждая в своей транзакции. + +Повторный запуск безопасен: применённые версии записаны в schema_migrations и пропускаются, +изменённый задним числом файл (другая контрольная сумма) останавливает запуск. +Advisory lock не даёт двум параллельным запускам применить одну миграцию дважды. +""" +import asyncio +import hashlib +from pathlib import Path + +import asyncpg + +from . import config + +MIGRATIONS = Path(__file__).resolve().parent.parent / 'migrations' +LOCK_ID = 2026_0002 + + +async def connect(url: str, attempts: int = 30) -> asyncpg.Connection: + for attempt in range(attempts): + try: + return await asyncpg.connect(url, timeout=3) + except (OSError, asyncpg.CannotConnectNowError, asyncpg.PostgresConnectionError): + if attempt == attempts - 1: + raise + await asyncio.sleep(1) + + +async def migrate() -> None: + settings = config.load() + conn = await connect(settings.database_url) + try: + await conn.execute('SELECT pg_advisory_lock($1)', LOCK_ID) + await conn.execute( + 'CREATE TABLE IF NOT EXISTS schema_migrations (' + ' version text PRIMARY KEY, checksum text NOT NULL,' + ' applied_at timestamptz NOT NULL DEFAULT clock_timestamp())') + applied = {r['version']: r['checksum'] for r in await conn.fetch('SELECT version, checksum FROM schema_migrations')} + for path in sorted(MIGRATIONS.glob('[0-9][0-9][0-9][0-9]_*.sql')): + version = path.stem + sql = path.read_text(encoding='utf-8') + checksum = hashlib.sha256(sql.encode()).hexdigest() + if version in applied: + if applied[version] != checksum: + raise SystemExit(f'migration {version} was modified after being applied') + print(f'skip {version}') + continue + async with conn.transaction(): + await conn.execute(sql) + await conn.execute('INSERT INTO schema_migrations (version, checksum) VALUES ($1, $2)', version, checksum) + print(f'apply {version}') + finally: + await conn.close() + + +if __name__ == '__main__': + asyncio.run(migrate()) diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..327032f3 --- /dev/null +++ b/app/security.py @@ -0,0 +1,47 @@ +"""Пароли (Argon2id) и непрозрачные токены сессий.""" +import asyncio +import hashlib +import secrets +from concurrent.futures import ThreadPoolExecutor + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError + +# Параметры по умолчанию argon2-cffi = профиль RFC 9106 "low memory": Argon2id, m=64 MiB, t=3, p=4. +_hasher = PasswordHasher() +# Хеш для несуществующего пользователя: вход выполняет ту же работу и не выдаёт по времени, +# что такого username нет. +_DUMMY_HASH = _hasher.hash('dummy-password-for-timing') + + +class PasswordService: + """KDF дорогой по CPU и памяти: считаем в отдельном ограниченном пуле потоков, + чтобы не блокировать event loop и не съесть всю память параллельными входами.""" + + def __init__(self, workers: int): + self._pool = ThreadPoolExecutor(max_workers=workers, thread_name_prefix='argon2') + + async def hash(self, password: str) -> str: + return await asyncio.get_running_loop().run_in_executor(self._pool, _hasher.hash, password) + + async def verify(self, password_hash: str | None, password: str) -> bool: + def check() -> bool: + try: + return _hasher.verify(password_hash or _DUMMY_HASH, password) and password_hash is not None + except (VerificationError, InvalidHashError): + return False + return await asyncio.get_running_loop().run_in_executor(self._pool, check) + + def close(self) -> None: + self._pool.shutdown(wait=False) + + +def new_token() -> str: + # 32 случайных байта = 256 бит энтропии из CSPRNG ОС; base64url -> 43 символа. + return secrets.token_urlsafe(32) + + +def token_hash(token: str) -> bytes: + # Для токена с 256 битами энтропии быстрый SHA-256 достаточен: перебор невозможен. + # Для паролей (низкая энтропия) так нельзя — там нужен медленный KDF. + return hashlib.sha256(token.encode('ascii')).digest() diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..205bc2b7 --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,187 @@ +"""Сессии: PostgreSQL — источник истины, Valkey — read-through кэш с TTL. + +Политика: +- создание: INSERT в PostgreSQL (COMMIT), затем SET в кэш с TTL = min(остаток жизни, SESSION_CACHE_TTL_SECONDS); +- проверка: кэш -> при промахе PostgreSQL -> заполнить кэш; +- logout: UPDATE revoked_at в PostgreSQL (COMMIT), затем DEL из кэша; +- любой сбой Valkey: работаем только с PostgreSQL и SESSION_CACHE_TTL_SECONDS не доверяем кэшу + (все записи, сделанные до сбоя, за это время гарантированно истекут — например, не удалённая + при logout копия отозванной сессии). Flush/рестарт Valkey = пустой кэш, сессии не теряются. +- lab3, несколько реплик: окно недоверия ОБЩЕЕ. Реплика, получившая ошибку Valkey, записывает его + в PostgreSQL (cache_state), а попадание в кэш принимается, только если общий признак проверен + не раньше SHARED_STATE_MAX_AGE назад. Иначе реплика, которая сама сбоя не видела, могла бы + отдать копию сессии, отозванной на другой реплике во время разрыва с Valkey. +""" +import asyncio +import json +import logging +import time +from dataclasses import dataclass +from datetime import datetime, timezone +from uuid import UUID + +import redis.asyncio as redis +from redis.exceptions import RedisError + +from .config import Settings +from .db import Database +from .security import token_hash + +log = logging.getLogger('messenger.sessions') + + +@dataclass(frozen=True) +class Session: + user_id: UUID + expires_at: datetime + + +# Насколько устаревшим может быть знание реплики об общем окне недоверия (не чаще 2 запросов/с к БД). +SHARED_STATE_MAX_AGE = 0.5 + + +class SessionCache: + def __init__(self, url: str | None, ttl: int, timeout: float, db: Database): + self.ttl = ttl + self.db = db + self.client = redis.Redis.from_url( + url, socket_timeout=timeout, socket_connect_timeout=timeout, + retry_on_timeout=False, health_check_interval=30, + ) if url else None + self._distrust_until = 0.0 # локально (monotonic): своя ошибка действует сразу + self._shared_trusted = False # результат последней проверки общего признака + self._shared_checked = -1e9 + self._lock = asyncio.Lock() + + @staticmethod + def key(digest: bytes) -> str: + return 'session:' + digest.hex() + + def usable(self) -> bool: + return self.client is not None and time.monotonic() >= self._distrust_until + + async def trusted(self) -> bool: + """Можно ли принять попадание в кэш: нет ни своего, ни общего (с других реплик) окна недоверия.""" + if not self.usable(): + return False + if time.monotonic() - self._shared_checked > SHARED_STATE_MAX_AGE: + async with self._lock: + if time.monotonic() - self._shared_checked > SHARED_STATE_MAX_AGE: + try: + async with self.db.pool.acquire(timeout=1) as conn: + self._shared_trusted = await conn.fetchval( + 'SELECT distrust_until <= clock_timestamp() FROM cache_state WHERE id = 1', + timeout=1) is True + except Exception: # без БД сессию всё равно не проверить; кэшу не доверяем + self._shared_trusted = False + self._shared_checked = time.monotonic() + return self._shared_trusted + + async def _failed(self, op: str) -> None: + # Не знаем, что успело/не успело записаться: перестаём читать кэш на один максимальный TTL — + # сами сразу и все остальные реплики через общий признак в PostgreSQL. + self._distrust_until = time.monotonic() + self.ttl + self._shared_checked = -1e9 + log.warning('valkey %s failed; bypassing cache for %ss on all replicas', op, self.ttl) + try: + async with self.db.pool.acquire(timeout=1) as conn: + await conn.execute( + 'UPDATE cache_state SET distrust_until = greatest(distrust_until, ' + 'clock_timestamp() + make_interval(secs => $1)) WHERE id = 1', self.ttl, timeout=1) + except Exception: # БД недоступна — и кэш, и сессии всё равно проверить нельзя + log.warning('could not publish cache distrust window', exc_info=True) + + async def get(self, digest: bytes) -> Session | None: + if not await self.trusted(): + return None + try: + raw = await self.client.get(self.key(digest)) + except (RedisError, OSError): + await self._failed('get') + return None + if raw is None: + return None + data = json.loads(raw) + return Session(UUID(data['u']), datetime.fromtimestamp(data['e'], timezone.utc)) + + async def put(self, digest: bytes, session: Session) -> None: + if not self.usable(): + return + remaining = int((session.expires_at - datetime.now(timezone.utc)).total_seconds()) + ttl = min(self.ttl, remaining) + if ttl <= 0: + return + value = json.dumps({'u': str(session.user_id), 'e': session.expires_at.timestamp()}) + try: + await self.client.set(self.key(digest), value, ex=ttl) + except (RedisError, OSError): + await self._failed('set') + + async def delete(self, digest: bytes) -> None: + if self.client is None: + return + try: + await self.client.delete(self.key(digest)) + except (RedisError, OSError): + await self._failed('delete') + + async def close(self) -> None: + if self.client is not None: + await self.client.aclose() + + +class SessionStore: + def __init__(self, settings: Settings, db: Database): + self.ttl = settings.session_ttl + self.db = db + self.cache = SessionCache(settings.cache_url, settings.session_cache_ttl, settings.cache_timeout, db) + + async def create(self, user_id: UUID, token: str) -> Session: + digest = token_hash(token) + async with self.db.connection() as conn: + # Время берём из БД, чтобы срок не зависел от часов конкретной реплики API. + expires_at = await conn.fetchval( + 'INSERT INTO sessions (token_hash, user_id, expires_at) ' + 'VALUES ($1, $2, clock_timestamp() + make_interval(secs => $3)) RETURNING expires_at', + digest, user_id, self.ttl, + ) + session = Session(user_id, expires_at) + await self.cache.put(digest, session) + return session + + async def resolve(self, token: str) -> Session | None: + digest = token_hash(token) + now = datetime.now(timezone.utc) + cached = await self.cache.get(digest) + if cached is not None and cached.expires_at > now: + return cached + async with self.db.connection() as conn: + row = await conn.fetchrow( + 'SELECT user_id, expires_at FROM sessions ' + 'WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()', + digest, + ) + if row is None: + return None + session = Session(row['user_id'], row['expires_at']) + await self.cache.put(digest, session) + return session + + async def revoke(self, token: str) -> bool: + digest = token_hash(token) + async with self.db.connection() as conn: + status = await conn.execute( + 'UPDATE sessions SET revoked_at = clock_timestamp() ' + 'WHERE token_hash = $1 AND revoked_at IS NULL AND expires_at > clock_timestamp()', + digest, + ) + # Инвалидация кэша строго после COMMIT в источнике истины. + await self.cache.delete(digest) + return status == 'UPDATE 1' + + async def purge_expired(self) -> int: + async with self.db.connection() as conn: + status = await conn.execute( + "DELETE FROM sessions WHERE expires_at < clock_timestamp() - interval '1 day'") + return int(status.split()[-1]) + diff --git a/app/validation.py b/app/validation.py new file mode 100644 index 00000000..ca68f0de --- /dev/null +++ b/app/validation.py @@ -0,0 +1,108 @@ +"""Строгий разбор JSON и параметров: лишние поля, неверные типы, malformed JSON -> 400.""" +import base64 +import json +import re +from datetime import datetime +from uuid import UUID + +from fastapi import Request + +from .errors import ApiError, invalid + +MAX_BODY_BYTES = 64 * 1024 +USERNAME_RE = re.compile(r'[a-z0-9_]{3,32}') + + +async def read_json(request: Request) -> dict: + media_type = request.headers.get('content-type', '').split(';')[0].strip().lower() + if media_type != 'application/json': + raise ApiError(415, 'unsupported_media_type', 'Ожидается Content-Type: application/json') + body = await request.body() + if len(body) > MAX_BODY_BYTES: + raise ApiError(413, 'payload_too_large', 'Слишком большое тело запроса') + try: + data = json.loads(body.decode('utf-8')) + except (UnicodeDecodeError, ValueError): + raise invalid('Некорректный JSON') from None + if not isinstance(data, dict): + raise invalid('Ожидается JSON-объект') + return data + + +def fields(data: dict, required: set[str], optional: set[str] = frozenset()) -> None: + extra = set(data) - required - optional + if extra: + raise invalid('Неизвестные поля: ' + ', '.join(sorted(extra))) + missing = required - set(data) + if missing: + raise invalid('Отсутствуют поля: ' + ', '.join(sorted(missing))) + + +def text_field(data: dict, name: str, min_len: int, max_len: int, *, allow_blank: bool = False) -> str: + value = data[name] + if not isinstance(value, str): + raise invalid(f'Поле {name} должно быть строкой') + try: + value.encode('utf-8') # отсекает одиночные суррогаты из \uD800-экранирования + except UnicodeEncodeError: + raise invalid(f'Поле {name} содержит некорректный Unicode') from None + if not min_len <= len(value) <= max_len: # len(str) в Python = число code points + raise invalid(f'Длина поля {name} должна быть {min_len}..{max_len} символов') + if not allow_blank and not value.strip(): + raise invalid(f'Поле {name} не может состоять из пробелов') + return value + + +def username(data: dict) -> str: + value = data['username'] + if not isinstance(value, str) or not USERNAME_RE.fullmatch(value): + raise invalid('username должен соответствовать [a-z0-9_]{3,32}') + return value + + +def uuid_value(value, what: str = 'идентификатор') -> UUID: + if not isinstance(value, str): + raise invalid(f'Некорректный {what}') + try: + parsed = UUID(value) + except ValueError: + raise invalid(f'Некорректный {what}') from None + if str(parsed) != value.lower(): # только каноническая форма 8-4-4-4-12 + raise invalid(f'Некорректный {what}') + return parsed + + +def limit_param(request: Request) -> int: + raw = request.query_params.get('limit') + if raw is None: + return 50 + if not re.fullmatch(r'[0-9]{1,3}', raw) or not 1 <= int(raw) <= 100: + raise invalid('limit должен быть целым 1..100') + return int(raw) + + +# Курсор: base64url(JSON {"s": область, "t": created_at, "i": id}). Для клиента это непрозрачная строка. +# Подделка курсора ничего не даёт: доступ к чату проверяется отдельно, а область привязывает +# курсор к конкретному чату/списку — курсор другого чата отклоняется с 400. + +def encode_cursor(scope: str, created_at: datetime, item_id: UUID) -> str: + raw = json.dumps({'s': scope, 't': created_at.isoformat(), 'i': str(item_id)}, separators=(',', ':')) + return base64.urlsafe_b64encode(raw.encode()).decode().rstrip('=') + + +def decode_cursor(request: Request, scope: str) -> tuple[datetime, UUID] | None: + raw = request.query_params.get('cursor') + if raw is None: + return None + try: + if len(raw) > 512: + raise ValueError + data = json.loads(base64.urlsafe_b64decode(raw + '=' * (-len(raw) % 4))) + if not isinstance(data, dict) or set(data) != {'s', 't', 'i'} or data['s'] != scope: + raise ValueError + created_at = datetime.fromisoformat(data['t']) + if created_at.tzinfo is None: + raise ValueError + return created_at, UUID(data['i']) + except (ValueError, TypeError, UnicodeDecodeError): + raise invalid('Некорректный cursor') from None diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..50a50168 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,184 @@ +# Стенд lab3: lb (HAProxy) -> api x N -> postgres + valkey; migrate — одноразовый bootstrap схемы. +# Подготовка: sh scripts/init-secrets.sh +# Запуск: docker compose --env-file .env up -d --build --wait +name: mtusi-lab3 + +x-api-env: &api-env + APP_HOST: ${APP_HOST:-0.0.0.0} + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: ${SESSION_STORE:-postgres+valkey} + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + SHUTDOWN_DRAIN_MS: ${SHUTDOWN_DRAIN_MS:-3000} + DATABASE_URL_FILE: ${DATABASE_URL_FILE:-/run/secrets/database_url} + CACHE_URL_FILE: ${CACHE_URL_FILE:-/run/secrets/cache_url} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + DB_ACQUIRE_TIMEOUT_MS: ${DB_ACQUIRE_TIMEOUT_MS:-2000} + CACHE_TIMEOUT_MS: ${CACHE_TIMEOUT_MS:-300} + PASSWORD_HASH_WORKERS: ${PASSWORD_HASH_WORKERS:-2} + +x-api-depends: &api-depends + postgres: + condition: service_healthy + migrate: + condition: service_completed_successfully + valkey: + # Valkey — кэш, не источник истины: API должен стартовать и без него. + condition: service_started + required: false + +x-api-limits: &api-limits + limits: + cpus: "${API_CPUS:-1.0}" + memory: ${API_MEMORY:-384M} # 2 параллельных Argon2id x 64 MiB + интерпретатор + +services: + lb: + image: haproxy:3.2.8-alpine + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + ports: + # Единственная публичная точка входа API (только loopback хоста) + страница состояния LB. + - "127.0.0.1:${LB_PUBLISHED_PORT:-8080}:8080" + - "127.0.0.1:${LB_STATS_PORT:-8404}:8404" + networks: [edge] + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/stats"] + interval: 5s + timeout: 2s + retries: 5 + depends_on: + api: + condition: service_healthy + deploy: + resources: + limits: {cpus: "1.0", memory: 128M} + restart: unless-stopped + + api: + image: mtusi-lab3-api:local + build: . + # Нет container_name и ports: реплики взаимозаменяемы, доступны только через lb. + deploy: + replicas: ${API_REPLICAS:-2} + resources: *api-limits + environment: *api-env + secrets: [database_url, cache_url] + networks: [edge, data] + read_only: true + tmpfs: [/tmp] + stop_grace_period: 20s # drain 3 с + graceful shutdown uvicorn до 10 с, с запасом + depends_on: *api-depends + restart: unless-stopped + + migrate: + # Один запуск на весь стенд (а не в каждой реплике): pg_advisory_lock + schema_migrations. + build: . + image: mtusi-lab3-api:local + command: ["python", "-m", "app.migrate"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_STORE: postgres + secrets: [database_url] + networks: [data] + depends_on: + postgres: + condition: service_healthy + deploy: + resources: + limits: {cpus: "0.5", memory: 128M} + restart: "no" + + postgres: + image: postgres:17.7-bookworm + environment: + POSTGRES_USER: app + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: + - pgdata:/var/lib/postgresql/data + networks: [data] + healthcheck: + test: ["CMD", "pg_isready", "-U", "app", "-d", "messenger"] + interval: 2s + timeout: 3s + retries: 30 + shm_size: 128m + stop_grace_period: 30s # даём PostgreSQL завершиться с checkpoint, без recovery при старте + deploy: + resources: + limits: {cpus: "${PG_CPUS:-2.0}", memory: 768M} + restart: unless-stopped + + valkey: + image: valkey/valkey:8.1.4 + command: ["valkey-server", "/run/secrets/valkey_conf"] + secrets: [valkey_conf] + networks: [data] + healthcheck: + test: ["CMD-SHELL", "valkey-cli --no-auth-warning -a \"$$(sed -n 's/^requirepass //p' /run/secrets/valkey_conf)\" ping | grep -q PONG"] + interval: 2s + timeout: 3s + retries: 30 + deploy: + resources: + limits: {cpus: "0.5", memory: 96M} + restart: unless-stopped + + # Отдельная реплика с коротким TTL только для автотеста истечения сессии (lab2, уровень 4). + # Порт не публикуется: tester обращается к ней по внутренней сети. + api-ttl: + profiles: [test] + image: mtusi-lab3-api:local + environment: + <<: *api-env + SESSION_TTL_SECONDS: "2" + secrets: [database_url, cache_url] + networks: [edge, data] + read_only: true + tmpfs: [/tmp] + deploy: + resources: *api-limits + depends_on: *api-depends + + # Linux-окружение для make/тестов/hook-скриптов (нужно на Windows без make и WSL). + tester: + profiles: [tools] + build: + context: . + dockerfile: tools/tester.Dockerfile + image: mtusi-lab3-tester:local + working_dir: /work + environment: + BASE_URL: http://lb:8080 + TTL_BASE_URL: http://api-ttl:8080 + LB_STATS_URL: http://lb:8404/stats + PYTHONUTF8: "1" + PYTHONDONTWRITEBYTECODE: "1" + networks: [edge] + volumes: + - .:/work + - /var/run/docker.sock:/var/run/docker.sock + +networks: + # edge: lb <-> api (+ tester). data: api/migrate <-> хранилища; lb в неё не входит. + edge: + data: + internal: true + +volumes: + pgdata: + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + valkey_conf: + file: ./secrets/valkey.conf diff --git a/evidence/failover-hook.txt b/evidence/failover-hook.txt new file mode 100644 index 00000000..71e1b0e8 --- /dev/null +++ b/evidence/failover-hook.txt @@ -0,0 +1,17 @@ +# 2026-11-05T14:25:23Z +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://lb:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 136, "failed_attempts": 0, "first_recovery_seconds": 4.126} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +mtusi-lab3-api-6 Up 5 seconds (healthy) +mtusi-lab3-api-5 Up About a minute (healthy) +python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://lb:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 135, "failed_attempts": 0, "first_recovery_seconds": 4.11} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +mtusi-lab3-api-6 Up 30 seconds (healthy) +mtusi-lab3-api-5 Up 5 seconds (healthy) + +# evidence/stop-one.log (what the hook really stopped): +2026-11-05T14:25:26Z mode=stop instance=82960260fe7e-344e05 container=mtusi-lab3-api-6 state=exited exit=0 finished=2026-11-05T14:25:29.520617248Z +2026-11-05T14:25:50Z mode=stop instance=94d5b20af90c-f97c77 container=mtusi-lab3-api-5 state=exited exit=0 finished=2026-11-05T14:25:54.028076335Z diff --git a/evidence/failover-kill.json b/evidence/failover-kill.json new file mode 100644 index 00000000..89fe3b5e --- /dev/null +++ b/evidence/failover-kill.json @@ -0,0 +1,456 @@ +{ + "scenario": "kill", + "date_utc": "2026-11-05T14:24:59Z", + "profile": { + "duration_s": 25, + "action_at_s": 8, + "writers": 4, + "readers": 2, + "client_timeout_s": 3, + "workload": "closed-loop: POST message (retry same key on failure) + GET history limit=20" + }, + "runs": [ + { + "targets": [ + { + "name": "mtusi-lab3-api-5", + "hostname": "94d5b20af90c", + "revision": "0ab3a34-1793888112" + } + ], + "action_started_s": 8.0, + "action_duration_s": 0.922, + "action_output": [ + "kill mtusi-lab3-api-5: exited exit=137 in 0.92s" + ], + "before": { + "seconds": 7.0, + "ok_rps": 330.0, + "write_rps": 211.3, + "read_rps": 118.7, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 78.0, + "max_ms": 125.0 + }, + "during_action_plus_5s": { + "seconds": 5.92, + "ok_rps": 223.9, + "write_rps": 136.8, + "read_rps": 87.1, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 63.0, + "p99_ms": 94.0, + "max_ms": 1015.0 + }, + "after": { + "seconds": 11.08, + "ok_rps": 259.8, + "write_rps": 164.5, + "read_rps": 95.3, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 79.0, + "max_ms": 125.0 + }, + "errors_total": 0, + "write_attempts_retried_same_key": 0, + "error_window_s": null, + "recovery_s": 0.0, + "target_last_served_after_action_s": 0.109, + "lb_detection": { + "mtusi-lab3-api-5": { + "lb_marked_not_up_after_s": 0.312, + "lb_state": "DOWN" + } + }, + "lb_retries_redispatches": { + "retries": 3, + "redispatches": 5 + }, + "instances_after": [ + "82960260fe7e-730640" + ], + "confirmed_writes": 4225, + "history_messages": 4225, + "duplicates": 0, + "lost_confirmed": 0, + "timeline_per_second": [ + { + "t": 0, + "ok": 173, + "err": 0, + "instances": 2 + }, + { + "t": 1, + "ok": 246, + "err": 0, + "instances": 2 + }, + { + "t": 2, + "ok": 415, + "err": 0, + "instances": 2 + }, + { + "t": 3, + "ok": 401, + "err": 0, + "instances": 2 + }, + { + "t": 4, + "ok": 416, + "err": 0, + "instances": 2 + }, + { + "t": 5, + "ok": 341, + "err": 0, + "instances": 2 + }, + { + "t": 6, + "ok": 265, + "err": 0, + "instances": 2 + }, + { + "t": 7, + "ok": 226, + "err": 0, + "instances": 2 + }, + { + "t": 8, + "ok": 252, + "err": 0, + "instances": 2 + }, + { + "t": 9, + "ok": 230, + "err": 0, + "instances": 1 + }, + { + "t": 10, + "ok": 256, + "err": 0, + "instances": 1 + }, + { + "t": 11, + "ok": 278, + "err": 0, + "instances": 1 + }, + { + "t": 12, + "ok": 218, + "err": 0, + "instances": 1 + }, + { + "t": 13, + "ok": 100, + "err": 0, + "instances": 1 + }, + { + "t": 14, + "ok": 225, + "err": 0, + "instances": 1 + }, + { + "t": 15, + "ok": 266, + "err": 0, + "instances": 1 + }, + { + "t": 16, + "ok": 285, + "err": 0, + "instances": 1 + }, + { + "t": 17, + "ok": 279, + "err": 0, + "instances": 1 + }, + { + "t": 18, + "ok": 266, + "err": 0, + "instances": 1 + }, + { + "t": 19, + "ok": 127, + "err": 0, + "instances": 1 + }, + { + "t": 20, + "ok": 283, + "err": 0, + "instances": 1 + }, + { + "t": 21, + "ok": 294, + "err": 0, + "instances": 1 + }, + { + "t": 22, + "ok": 283, + "err": 0, + "instances": 1 + }, + { + "t": 23, + "ok": 275, + "err": 0, + "instances": 1 + }, + { + "t": 24, + "ok": 287, + "err": 0, + "instances": 1 + } + ] + }, + { + "targets": [ + { + "name": "mtusi-lab3-api-6", + "hostname": "82960260fe7e", + "revision": "0ab3a34-1793888112" + } + ], + "action_started_s": 8.0, + "action_duration_s": 0.922, + "action_output": [ + "kill mtusi-lab3-api-6: exited exit=137 in 0.92s" + ], + "before": { + "seconds": 7.0, + "ok_rps": 332.4, + "write_rps": 213.3, + "read_rps": 119.1, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 63.0, + "max_ms": 94.0 + }, + "during_action_plus_5s": { + "seconds": 5.92, + "ok_rps": 247.2, + "write_rps": 163.0, + "read_rps": 84.3, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 94.0, + "max_ms": 1031.0 + }, + "after": { + "seconds": 11.08, + "ok_rps": 238.5, + "write_rps": 151.4, + "read_rps": 87.1, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 63.0, + "p99_ms": 94.0, + "max_ms": 219.0 + }, + "errors_total": 0, + "write_attempts_retried_same_key": 0, + "error_window_s": null, + "recovery_s": 0.0, + "target_last_served_after_action_s": 0.11, + "lb_detection": { + "mtusi-lab3-api-6": { + "lb_marked_not_up_after_s": 0.156, + "lb_state": "DOWN" + } + }, + "lb_retries_redispatches": { + "retries": 1, + "redispatches": 3 + }, + "instances_after": [ + "94d5b20af90c-f97c77" + ], + "confirmed_writes": 4240, + "history_messages": 4240, + "duplicates": 0, + "lost_confirmed": 0, + "timeline_per_second": [ + { + "t": 0, + "ok": 159, + "err": 0, + "instances": 2 + }, + { + "t": 1, + "ok": 310, + "err": 0, + "instances": 2 + }, + { + "t": 2, + "ok": 322, + "err": 0, + "instances": 2 + }, + { + "t": 3, + "ok": 329, + "err": 0, + "instances": 2 + }, + { + "t": 4, + "ok": 392, + "err": 0, + "instances": 2 + }, + { + "t": 5, + "ok": 407, + "err": 0, + "instances": 2 + }, + { + "t": 6, + "ok": 285, + "err": 0, + "instances": 2 + }, + { + "t": 7, + "ok": 282, + "err": 0, + "instances": 2 + }, + { + "t": 8, + "ok": 180, + "err": 0, + "instances": 2 + }, + { + "t": 9, + "ok": 208, + "err": 0, + "instances": 1 + }, + { + "t": 10, + "ok": 262, + "err": 0, + "instances": 1 + }, + { + "t": 11, + "ok": 277, + "err": 0, + "instances": 1 + }, + { + "t": 12, + "ok": 281, + "err": 0, + "instances": 1 + }, + { + "t": 13, + "ok": 277, + "err": 0, + "instances": 1 + }, + { + "t": 14, + "ok": 170, + "err": 0, + "instances": 1 + }, + { + "t": 15, + "ok": 208, + "err": 0, + "instances": 1 + }, + { + "t": 16, + "ok": 287, + "err": 0, + "instances": 1 + }, + { + "t": 17, + "ok": 265, + "err": 0, + "instances": 1 + }, + { + "t": 18, + "ok": 268, + "err": 0, + "instances": 1 + }, + { + "t": 19, + "ok": 170, + "err": 0, + "instances": 1 + }, + { + "t": 20, + "ok": 194, + "err": 0, + "instances": 1 + }, + { + "t": 21, + "ok": 227, + "err": 0, + "instances": 1 + }, + { + "t": 22, + "ok": 284, + "err": 0, + "instances": 1 + }, + { + "t": 23, + "ok": 273, + "err": 0, + "instances": 1 + }, + { + "t": 24, + "ok": 275, + "err": 0, + "instances": 1 + } + ] + } + ] +} diff --git a/evidence/failover-stop.json b/evidence/failover-stop.json new file mode 100644 index 00000000..3bf9c54c --- /dev/null +++ b/evidence/failover-stop.json @@ -0,0 +1,456 @@ +{ + "scenario": "stop", + "date_utc": "2026-11-05T14:23:47Z", + "profile": { + "duration_s": 25, + "action_at_s": 8, + "writers": 4, + "readers": 2, + "client_timeout_s": 3, + "workload": "closed-loop: POST message (retry same key on failure) + GET history limit=20" + }, + "runs": [ + { + "targets": [ + { + "name": "mtusi-lab3-api-5", + "hostname": "94d5b20af90c", + "revision": "0ab3a34-1793888112" + } + ], + "action_started_s": 8.0, + "action_duration_s": 4.078, + "action_output": [ + "stop mtusi-lab3-api-5: exited exit=0 in 4.08s" + ], + "before": { + "seconds": 7.0, + "ok_rps": 341.0, + "write_rps": 216.1, + "read_rps": 124.9, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 63.0, + "max_ms": 156.0 + }, + "during_action_plus_5s": { + "seconds": 9.08, + "ok_rps": 302.6, + "write_rps": 193.2, + "read_rps": 109.4, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 78.0, + "max_ms": 125.0 + }, + "after": { + "seconds": 7.92, + "ok_rps": 279.3, + "write_rps": 176.5, + "read_rps": 102.9, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 94.0, + "max_ms": 204.0 + }, + "errors_total": 0, + "write_attempts_retried_same_key": 0, + "error_window_s": null, + "recovery_s": 0.0, + "target_last_served_after_action_s": 1.218, + "lb_detection": { + "mtusi-lab3-api-5": { + "lb_marked_not_up_after_s": 1.343, + "lb_state": "DOWN" + } + }, + "lb_retries_redispatches": { + "retries": 0, + "redispatches": 0 + }, + "instances_after": [ + "82960260fe7e-b584ab" + ], + "confirmed_writes": 4766, + "history_messages": 4766, + "duplicates": 0, + "lost_confirmed": 0, + "timeline_per_second": [ + { + "t": 0, + "ok": 154, + "err": 0, + "instances": 2 + }, + { + "t": 1, + "ok": 208, + "err": 0, + "instances": 2 + }, + { + "t": 2, + "ok": 389, + "err": 0, + "instances": 2 + }, + { + "t": 3, + "ok": 383, + "err": 0, + "instances": 2 + }, + { + "t": 4, + "ok": 399, + "err": 0, + "instances": 2 + }, + { + "t": 5, + "ok": 405, + "err": 0, + "instances": 2 + }, + { + "t": 6, + "ok": 364, + "err": 0, + "instances": 2 + }, + { + "t": 7, + "ok": 239, + "err": 0, + "instances": 2 + }, + { + "t": 8, + "ok": 391, + "err": 0, + "instances": 2 + }, + { + "t": 9, + "ok": 325, + "err": 0, + "instances": 2 + }, + { + "t": 10, + "ok": 327, + "err": 0, + "instances": 1 + }, + { + "t": 11, + "ok": 304, + "err": 0, + "instances": 1 + }, + { + "t": 12, + "ok": 183, + "err": 0, + "instances": 1 + }, + { + "t": 13, + "ok": 214, + "err": 0, + "instances": 1 + }, + { + "t": 14, + "ok": 321, + "err": 0, + "instances": 1 + }, + { + "t": 15, + "ok": 326, + "err": 0, + "instances": 1 + }, + { + "t": 16, + "ok": 328, + "err": 0, + "instances": 1 + }, + { + "t": 17, + "ok": 333, + "err": 0, + "instances": 1 + }, + { + "t": 18, + "ok": 225, + "err": 0, + "instances": 1 + }, + { + "t": 19, + "ok": 225, + "err": 0, + "instances": 1 + }, + { + "t": 20, + "ok": 315, + "err": 0, + "instances": 1 + }, + { + "t": 21, + "ok": 327, + "err": 0, + "instances": 1 + }, + { + "t": 22, + "ok": 332, + "err": 0, + "instances": 1 + }, + { + "t": 23, + "ok": 278, + "err": 0, + "instances": 1 + }, + { + "t": 24, + "ok": 206, + "err": 0, + "instances": 1 + } + ] + }, + { + "targets": [ + { + "name": "mtusi-lab3-api-6", + "hostname": "82960260fe7e", + "revision": "0ab3a34-1793888112" + } + ], + "action_started_s": 8.0, + "action_duration_s": 4.359, + "action_output": [ + "stop mtusi-lab3-api-6: exited exit=0 in 4.36s" + ], + "before": { + "seconds": 7.0, + "ok_rps": 349.4, + "write_rps": 223.0, + "read_rps": 126.4, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 32.0, + "p99_ms": 63.0, + "max_ms": 94.0 + }, + "during_action_plus_5s": { + "seconds": 9.36, + "ok_rps": 258.4, + "write_rps": 165.2, + "read_rps": 93.2, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 79.0, + "max_ms": 188.0 + }, + "after": { + "seconds": 7.64, + "ok_rps": 259.4, + "write_rps": 166.5, + "read_rps": 92.9, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 78.0, + "max_ms": 109.0 + }, + "errors_total": 0, + "write_attempts_retried_same_key": 0, + "error_window_s": null, + "recovery_s": 0.0, + "target_last_served_after_action_s": 1.313, + "lb_detection": { + "mtusi-lab3-api-6": { + "lb_marked_not_up_after_s": 1.516, + "lb_state": "DOWN" + } + }, + "lb_retries_redispatches": { + "retries": 0, + "redispatches": 0 + }, + "instances_after": [ + "94d5b20af90c-a546c4" + ], + "confirmed_writes": 4461, + "history_messages": 4461, + "duplicates": 0, + "lost_confirmed": 0, + "timeline_per_second": [ + { + "t": 0, + "ok": 129, + "err": 0, + "instances": 2 + }, + { + "t": 1, + "ok": 405, + "err": 0, + "instances": 2 + }, + { + "t": 2, + "ok": 325, + "err": 0, + "instances": 2 + }, + { + "t": 3, + "ok": 328, + "err": 0, + "instances": 2 + }, + { + "t": 4, + "ok": 416, + "err": 0, + "instances": 2 + }, + { + "t": 5, + "ok": 324, + "err": 0, + "instances": 2 + }, + { + "t": 6, + "ok": 315, + "err": 0, + "instances": 2 + }, + { + "t": 7, + "ok": 333, + "err": 0, + "instances": 2 + }, + { + "t": 8, + "ok": 263, + "err": 0, + "instances": 2 + }, + { + "t": 9, + "ok": 260, + "err": 0, + "instances": 2 + }, + { + "t": 10, + "ok": 275, + "err": 0, + "instances": 1 + }, + { + "t": 11, + "ok": 251, + "err": 0, + "instances": 1 + }, + { + "t": 12, + "ok": 277, + "err": 0, + "instances": 1 + }, + { + "t": 13, + "ok": 288, + "err": 0, + "instances": 1 + }, + { + "t": 14, + "ok": 179, + "err": 0, + "instances": 1 + }, + { + "t": 15, + "ok": 223, + "err": 0, + "instances": 1 + }, + { + "t": 16, + "ok": 302, + "err": 0, + "instances": 1 + }, + { + "t": 17, + "ok": 285, + "err": 0, + "instances": 1 + }, + { + "t": 18, + "ok": 278, + "err": 0, + "instances": 1 + }, + { + "t": 19, + "ok": 266, + "err": 0, + "instances": 1 + }, + { + "t": 20, + "ok": 184, + "err": 0, + "instances": 1 + }, + { + "t": 21, + "ok": 221, + "err": 0, + "instances": 1 + }, + { + "t": 22, + "ok": 287, + "err": 0, + "instances": 1 + }, + { + "t": 23, + "ok": 278, + "err": 0, + "instances": 1 + }, + { + "t": 24, + "ok": 283, + "err": 0, + "instances": 1 + } + ] + } + ] +} diff --git a/evidence/fresh-start.txt b/evidence/fresh-start.txt new file mode 100644 index 00000000..5f513226 --- /dev/null +++ b/evidence/fresh-start.txt @@ -0,0 +1,14 @@ +# 2026-11-05T14:26:32Z fresh project mtusi-lab3-fresh, empty volume, ports 18080/18404 +containers ready: 11 +volume mtusi-lab3-fresh_pgdata created 2026-11-05T14:26:32Z +$ docker compose logs migrate +apply 0001_init +apply 0002_idempotency +apply 0003_cache_state +$ python tests/smoke.py --base-url http://localhost:18080 +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. +$ docker compose run --rm migrate # повторный запуск +skip 0001_init +skip 0002_idempotency +skip 0003_cache_state + Network mtusi-lab3-fresh_edge Removed diff --git a/evidence/instances.txt b/evidence/instances.txt new file mode 100644 index 00000000..5f182b93 --- /dev/null +++ b/evidence/instances.txt @@ -0,0 +1,10 @@ +# 2026-11-05T14:19:23Z, commit 0ab3a34 +NAME IMAGE STATUS PORTS +mtusi-lab3-api-5 mtusi-lab3-api:local Up About a minute (healthy) 8080/tcp +mtusi-lab3-api-6 mtusi-lab3-api:local Up 4 minutes (healthy) 8080/tcp +mtusi-lab3-lb-1 haproxy:3.2.8-alpine Up 14 minutes (healthy) 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp +mtusi-lab3-postgres-1 postgres:17.7-bookworm Up 45 seconds (healthy) 5432/tcp +mtusi-lab3-valkey-1 valkey/valkey:8.1.4 Up 57 seconds (healthy) 6379/tcp + +X-Instance-Id sequence: 94d5b20af90c-190f7e 82960260fe7e-4aef3e 94d5b20af90c-190f7e 82960260fe7e-4aef3e 94d5b20af90c-190f7e 82960260fe7e-4aef3e 94d5b20af90c-190f7e 82960260fe7e-4aef3e 94d5b20af90c-190f7e 82960260fe7e-4aef3e +distinct replicas for one session without re-login: {'94d5b20af90c-190f7e': 5, '82960260fe7e-4aef3e': 5} diff --git a/evidence/load-stats.txt b/evidence/load-stats.txt new file mode 100644 index 00000000..41761918 --- /dev/null +++ b/evidence/load-stats.txt @@ -0,0 +1,8 @@ +# docker stats at ~t=15s of 30s load (load.py --duration 30 --concurrency 8, client in tester container) +NAME CPU % MEM USAGE / LIMIT +mtusi-lab3-tester-run-6f07cac1df68 76.62% 22.37MiB / 3.729GiB +mtusi-lab3-api-6 91.10% 40.19MiB / 384MiB +mtusi-lab3-api-5 92.13% 40.09MiB / 384MiB +mtusi-lab3-lb-1 28.73% 19.98MiB / 128MiB +mtusi-lab3-postgres-1 55.30% 87.5MiB / 768MiB +mtusi-lab3-valkey-1 6.98% 8.508MiB / 96MiB diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..cd41a7f2 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.13, + "concurrency": 8, + "successful_requests": 13874, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 460.468, + "successful_latency_ms": { + "p50": 13.896, + "p95": 43.44, + "p99": 79.871 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..ecd915c2 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,17 @@ +# 2026-11-05T14:21:57Z, commit 0ab3a34 +before: +/mtusi-lab3-api-5 2026-11-05T14:18:04.168634174Z +/mtusi-lab3-api-6 2026-11-05T14:21:50.833912795Z +/mtusi-lab3-lb-1 2026-11-05T14:05:14.167852097Z +/mtusi-lab3-postgres-1 2026-11-05T14:18:38.62141486Z +/mtusi-lab3-valkey-1 2026-11-05T14:18:26.022169137Z +after: +/mtusi-lab3-api-5 2026-11-05T14:22:08.456546656Z +/mtusi-lab3-api-6 2026-11-05T14:22:08.130543996Z +/mtusi-lab3-lb-1 2026-11-05T14:22:14.250336687Z +/mtusi-lab3-postgres-1 2026-11-05T14:22:04.18859787Z +/mtusi-lab3-valkey-1 2026-11-05T14:22:04.316683756Z +ready +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://lb: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. diff --git a/evidence/public-tests.txt b/evidence/public-tests.txt new file mode 100644 index 00000000..2daaa19f --- /dev/null +++ b/evidence/public-tests.txt @@ -0,0 +1,8 @@ +# 2026-11-05T14:19:07Z, commit 0ab3a34 + +python3 scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +python3 scripts/validate_openapi.py +PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested. +python3 tests/smoke.py --base-url "http://lb:8080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/rolling-update.json b/evidence/rolling-update.json new file mode 100644 index 00000000..88eac397 --- /dev/null +++ b/evidence/rolling-update.json @@ -0,0 +1,537 @@ +{ + "scenario": "rolling", + "date_utc": "2026-11-05T14:16:15Z", + "profile": { + "duration_s": 70.0, + "action_at_s": 10.0, + "writers": 4, + "readers": 2, + "client_timeout_s": 3, + "workload": "closed-loop: POST message (retry same key on failure) + GET history limit=20" + }, + "runs": [ + { + "targets": [ + { + "name": "mtusi-lab3-api-3", + "hostname": "c7c7c39accbd", + "revision": "0ab3a34-1793887831" + }, + { + "name": "mtusi-lab3-api-4", + "hostname": "935d3ad4159a", + "revision": "0ab3a34-1793887831" + } + ], + "action_started_s": 10.0, + "action_duration_s": 35.656, + "action_output": [ + "14:15:12 old replicas (2): mtusi-lab3-api-3=0ab3a34-1793887831 mtusi-lab3-api-4=0ab3a34-1793887831 ", + "skip 0001_init", + "skip 0002_idempotency", + "apply 0003_cache_state", + "14:15:31 new replicas healthy: mtusi-lab3-api-6=0ab3a34-1793888112 mtusi-lab3-api-5=0ab3a34-1793888112 ", + "14:15:39 replaced mtusi-lab3-api-3", + "14:15:46 replaced mtusi-lab3-api-4", + "mtusi-lab3-api-6 Up 23 seconds (healthy) 0ab3a34-1793888112", + "mtusi-lab3-api-5 Up 22 seconds (healthy) 0ab3a34-1793888112" + ], + "before": { + "seconds": 9.0, + "ok_rps": 282.6, + "write_rps": 180.7, + "read_rps": 101.9, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 78.0, + "max_ms": 313.0 + }, + "during_action_plus_5s": { + "seconds": 40.66, + "ok_rps": 243.0, + "write_rps": 153.5, + "read_rps": 89.5, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 94.0, + "max_ms": 235.0 + }, + "after": { + "seconds": 19.34, + "ok_rps": 279.7, + "write_rps": 179.9, + "read_rps": 99.8, + "errors": 0, + "p50_ms": 16.0, + "p95_ms": 47.0, + "p99_ms": 78.0, + "max_ms": 219.0 + }, + "errors_total": 0, + "write_attempts_retried_same_key": 0, + "error_window_s": null, + "recovery_s": 0.0, + "target_last_served_after_action_s": 31.75, + "lb_detection": { + "mtusi-lab3-api-3": { + "lb_marked_not_up_after_s": 25.609, + "lb_state": "DOWN" + }, + "mtusi-lab3-api-4": { + "lb_marked_not_up_after_s": 31.75, + "lb_state": "DOWN" + } + }, + "lb_retries_redispatches": { + "retries": 0, + "redispatches": 4 + }, + "instances_after": [ + "82960260fe7e-4aef3e", + "94d5b20af90c-88de6e" + ], + "confirmed_writes": 11433, + "history_messages": 11433, + "duplicates": 0, + "lost_confirmed": 0, + "timeline_per_second": [ + { + "t": 0, + "ok": 127, + "err": 0, + "instances": 2 + }, + { + "t": 1, + "ok": 272, + "err": 0, + "instances": 2 + }, + { + "t": 2, + "ok": 169, + "err": 0, + "instances": 2 + }, + { + "t": 3, + "ok": 319, + "err": 0, + "instances": 2 + }, + { + "t": 4, + "ok": 299, + "err": 0, + "instances": 2 + }, + { + "t": 5, + "ok": 322, + "err": 0, + "instances": 2 + }, + { + "t": 6, + "ok": 330, + "err": 0, + "instances": 2 + }, + { + "t": 7, + "ok": 337, + "err": 0, + "instances": 2 + }, + { + "t": 8, + "ok": 187, + "err": 0, + "instances": 2 + }, + { + "t": 9, + "ok": 308, + "err": 0, + "instances": 2 + }, + { + "t": 10, + "ok": 226, + "err": 0, + "instances": 2 + }, + { + "t": 11, + "ok": 136, + "err": 0, + "instances": 2 + }, + { + "t": 12, + "ok": 219, + "err": 0, + "instances": 2 + }, + { + "t": 13, + "ok": 185, + "err": 0, + "instances": 2 + }, + { + "t": 14, + "ok": 142, + "err": 0, + "instances": 2 + }, + { + "t": 15, + "ok": 160, + "err": 0, + "instances": 2 + }, + { + "t": 16, + "ok": 261, + "err": 0, + "instances": 2 + }, + { + "t": 17, + "ok": 282, + "err": 0, + "instances": 2 + }, + { + "t": 18, + "ok": 278, + "err": 0, + "instances": 2 + }, + { + "t": 19, + "ok": 329, + "err": 0, + "instances": 2 + }, + { + "t": 20, + "ok": 253, + "err": 0, + "instances": 2 + }, + { + "t": 21, + "ok": 116, + "err": 0, + "instances": 2 + }, + { + "t": 22, + "ok": 209, + "err": 0, + "instances": 2 + }, + { + "t": 23, + "ok": 233, + "err": 0, + "instances": 2 + }, + { + "t": 24, + "ok": 276, + "err": 0, + "instances": 2 + }, + { + "t": 25, + "ok": 287, + "err": 0, + "instances": 2 + }, + { + "t": 26, + "ok": 303, + "err": 0, + "instances": 4 + }, + { + "t": 27, + "ok": 282, + "err": 0, + "instances": 4 + }, + { + "t": 28, + "ok": 255, + "err": 0, + "instances": 4 + }, + { + "t": 29, + "ok": 289, + "err": 0, + "instances": 4 + }, + { + "t": 30, + "ok": 293, + "err": 0, + "instances": 4 + }, + { + "t": 31, + "ok": 285, + "err": 0, + "instances": 4 + }, + { + "t": 32, + "ok": 242, + "err": 0, + "instances": 4 + }, + { + "t": 33, + "ok": 197, + "err": 0, + "instances": 4 + }, + { + "t": 34, + "ok": 208, + "err": 0, + "instances": 4 + }, + { + "t": 35, + "ok": 248, + "err": 0, + "instances": 4 + }, + { + "t": 36, + "ok": 309, + "err": 0, + "instances": 3 + }, + { + "t": 37, + "ok": 308, + "err": 0, + "instances": 3 + }, + { + "t": 38, + "ok": 243, + "err": 0, + "instances": 3 + }, + { + "t": 39, + "ok": 112, + "err": 0, + "instances": 3 + }, + { + "t": 40, + "ok": 103, + "err": 0, + "instances": 3 + }, + { + "t": 41, + "ok": 193, + "err": 0, + "instances": 3 + }, + { + "t": 42, + "ok": 250, + "err": 0, + "instances": 2 + }, + { + "t": 43, + "ok": 310, + "err": 0, + "instances": 2 + }, + { + "t": 44, + "ok": 299, + "err": 0, + "instances": 2 + }, + { + "t": 45, + "ok": 268, + "err": 0, + "instances": 2 + }, + { + "t": 46, + "ok": 208, + "err": 0, + "instances": 2 + }, + { + "t": 47, + "ok": 252, + "err": 0, + "instances": 2 + }, + { + "t": 48, + "ok": 313, + "err": 0, + "instances": 2 + }, + { + "t": 49, + "ok": 317, + "err": 0, + "instances": 2 + }, + { + "t": 50, + "ok": 306, + "err": 0, + "instances": 2 + }, + { + "t": 51, + "ok": 297, + "err": 0, + "instances": 2 + }, + { + "t": 52, + "ok": 264, + "err": 0, + "instances": 2 + }, + { + "t": 53, + "ok": 258, + "err": 0, + "instances": 2 + }, + { + "t": 54, + "ok": 334, + "err": 0, + "instances": 2 + }, + { + "t": 55, + "ok": 319, + "err": 0, + "instances": 2 + }, + { + "t": 56, + "ok": 321, + "err": 0, + "instances": 2 + }, + { + "t": 57, + "ok": 352, + "err": 0, + "instances": 2 + }, + { + "t": 58, + "ok": 239, + "err": 0, + "instances": 2 + }, + { + "t": 59, + "ok": 211, + "err": 0, + "instances": 2 + }, + { + "t": 60, + "ok": 333, + "err": 0, + "instances": 2 + }, + { + "t": 61, + "ok": 326, + "err": 0, + "instances": 2 + }, + { + "t": 62, + "ok": 248, + "err": 0, + "instances": 2 + }, + { + "t": 63, + "ok": 240, + "err": 0, + "instances": 2 + }, + { + "t": 64, + "ok": 208, + "err": 0, + "instances": 2 + }, + { + "t": 65, + "ok": 137, + "err": 0, + "instances": 2 + }, + { + "t": 66, + "ok": 252, + "err": 0, + "instances": 2 + }, + { + "t": 67, + "ok": 290, + "err": 0, + "instances": 2 + }, + { + "t": 68, + "ok": 338, + "err": 0, + "instances": 2 + }, + { + "t": 69, + "ok": 339, + "err": 0, + "instances": 2 + } + ], + "replicas_after": [ + { + "name": "mtusi-lab3-api-5", + "hostname": "94d5b20af90c", + "revision": "0ab3a34-1793888112", + "ip": "172.19.0.3" + }, + { + "name": "mtusi-lab3-api-6", + "hostname": "82960260fe7e", + "revision": "0ab3a34-1793888112", + "ip": "172.19.0.2" + } + ] + } + ] +} diff --git a/evidence/scale.txt b/evidence/scale.txt new file mode 100644 index 00000000..3e7c290c --- /dev/null +++ b/evidence/scale.txt @@ -0,0 +1,23 @@ +# 2026-11-05T14:27:09Z scale api 2 -> 4 -> 2, haproxy.cfg не меняется +$ docker compose up -d --wait --scale api=4 api +healthy: 8 +mtusi-lab3-api-5 Up About a minute (healthy) +mtusi-lab3-api-6 Up About a minute (healthy) +mtusi-lab3-api-7 Up 9 seconds (healthy) +mtusi-lab3-api-8 Up 9 seconds (healthy) +$ LB stats: backend api +api-1 UP 172.19.0.3:8080 +api-2 UP 172.19.0.2:8080 +api-3 UP 172.19.0.5:8080 +api-4 UP 172.19.0.6:8080 +api-5 MAINT (resolution) +api-6 MAINT (resolution) +api-7 MAINT (resolution) +api-8 MAINT (resolution) +BACKEND UP +X-Instance-Id sequence: 8060819e8622-2573c9 27dfa4d0a786-99ebbc 94d5b20af90c-c34d8c 82960260fe7e-833cd4 8060819e8622-2573c9 27dfa4d0a786-99ebbc 94d5b20af90c-c34d8c 82960260fe7e-833cd4 8060819e8622-2573c9 27dfa4d0a786-99ebbc +distinct replicas for one session without re-login: {'8060819e8622-2573c9': 3, '27dfa4d0a786-99ebbc': 3, '94d5b20af90c-c34d8c': 2, '82960260fe7e-833cd4': 2} +$ docker compose up -d --wait --scale api=2 api +stopped: 2 +mtusi-lab3-api-5 Up About a minute (healthy) +mtusi-lab3-api-6 Up About a minute (healthy) diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..465238ab --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,20 @@ +PASS test_session_across_replicas (0.6s) +PASS test_same_key_concurrent_across_replicas (2.3s) +PASS test_same_key_concurrent_different_bodies (1.6s) +PASS test_key_scope_and_format (1.8s) +PASS test_replay_rechecks_session (1.6s) +PASS test_transient_failure_not_recorded (4.9s) +PASS test_sigterm_drain (10.0s) +PASS test_infrastructure_rules (0.4s) +8/8 passed +PASS test_wrong_password (0.8s) +PASS test_logout (0.7s) +PASS test_short_ttl (3.5s) +PASS test_username_race (3.7s) +PASS test_chat_rollback (0.9s) +PASS test_cursor_rules (1.2s) +PASS test_valkey_cache_role (1.0s) +PASS test_revoke_during_cache_partition (1.7s) +PASS test_valkey_down (4.2s) +PASS test_postgres_down (10.9s) +10/10 passed diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..3ab74694 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,89 @@ +# HAProxy — единственная публичная точка входа lab3. +# Реплики API обнаруживаются через DNS Docker (имя сервиса "api" -> все IP его контейнеров), +# поэтому масштабирование `--scale api=N` (N <= 8) не требует правки конфигурации. +# Sticky session нет намеренно: любая реплика обслуживает любой запрос, состояние — в PostgreSQL/Valkey. + +global + log stdout format raw local0 info + maxconn 4096 + hard-stop-after 30s + +# Встроенный DNS Docker. Интервал повторного разрешения 1 с: остановленный контейнер исчезает +# из ответа DNS, и его слот server-template уходит в MAINT ("No IP for server") за 1–2 с. +resolvers docker + nameserver dns 127.0.0.11:53 + accepted_payload_size 8192 + resolve_retries 2 + timeout resolve 1s + timeout retry 500ms + hold valid 1s + hold obsolete 1s + hold nx 1s + hold other 1s + hold refused 1s + hold timeout 1s + +defaults + mode http + log global + option httplog + option dontlognull + timeout connect 1s # до живой реплики в той же сети — миллисекунды; 1 с = признак отказа + timeout client 30s + timeout server 15s # дольше statement_timeout БД (5 с) и Argon2id под нагрузкой + timeout http-request 10s + timeout http-keep-alive 10s # меньше keep-alive uvicorn (30 с): idle-соединение закрывает HAProxy первым + timeout queue 5s + timeout check 1s + # Повтор на ДРУГОЙ реплике (redispatch) при неудачном соединении; L7-повторы ограничены ниже. + retries 2 + option redispatch 1 + # Ответы, созданные самим LB, — в формате ошибок контракта (без X-Instance-Id: их создал не API). + http-error status 502 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Bad gateway\",\"request_id\":\"%[req.hdr(x-request-id)]\"}}" hdr X-Request-Id "%[req.hdr(x-request-id)]" + http-error status 503 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"No API replica available\",\"request_id\":\"%[req.hdr(x-request-id)]\"}}" hdr X-Request-Id "%[req.hdr(x-request-id)]" + http-error status 504 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Gateway timeout\",\"request_id\":\"%[req.hdr(x-request-id)]\"}}" hdr X-Request-Id "%[req.hdr(x-request-id)]" + +frontend public + bind :8080 + # Сквозной request id: API принимает корректный входящий X-Request-Id, LB подставляет свой, если его нет. + unique-id-format %[uuid()] + http-request set-header X-Request-Id %[unique-id] unless { req.hdr(x-request-id) -m reg ^[A-Za-z0-9._:-]{1,128}$ } + # Если /health/ready не проходит НИ У ОДНОЙ реплики (например, недоступна БД), не отвечаем + # безликим 503 от LB, а отдаём запрос живым процессам: они вернут честный 503 контракта, + # а /health/live продолжит работать. + use_backend api_live if { nbsrv(api) eq 0 } + default_backend api + +backend api + balance roundrobin + option httpchk + http-check send meth GET uri /health/ready + http-check expect status 200 + # Активная проверка раз в 1 с, вывод из ротации после 2 неудач подряд, возврат после 2 успехов. + # Пассивно: 2 ошибки соединения подряд на реальном трафике — сразу DOWN, не дожидаясь проверки. + default-server check inter 1s fastinter 500ms downinter 1s fall 2 rise 2 observe layer4 error-limit 2 on-error mark-down + # L7-повтор на другой реплике безопасен только для GET и POST сообщения (защищён Idempotency-Key). + # Для POST /users, /chats, /auth/sessions и DELETE остаются лишь повторы до отправки запроса (conn-failure). + retry-on conn-failure empty-response response-timeout + acl safe_method method GET HEAD + acl is_post method POST + acl messages_path path_reg ^/api/v1/chats/[^/]+/messages$ + http-request disable-l7-retry unless safe_method || is_post messages_path + server-template api- 8 api:8080 resolvers docker init-addr none resolve-prefer ipv4 + +backend api_live + balance roundrobin + option httpchk + http-check send meth GET uri /health/live + http-check expect status 200 + default-server check inter 1s fall 2 rise 2 + server-template live- 8 api:8080 resolvers docker init-addr none resolve-prefer ipv4 + +# Наблюдаемость LB: состояние backend-ов и метрики. Публикуется только на 127.0.0.1 хоста. +frontend stats + bind :8404 + http-request use-service prometheus-exporter if { path /metrics } + stats enable + stats uri /stats + stats refresh 2s + stats show-legends diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..34533405 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,59 @@ +-- 0001: базовая схема мессенджера lab2. +-- Применяется раннером app/migrate.py внутри одной транзакции; версия пишется в schema_migrations. + +CREATE TABLE users ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, -- строка Argon2id ($argon2id$v=19$m=...,t=...,p=...$salt$hash) + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_username_key UNIQUE (username), -- защита от гонки регистраций: решает БД, а не приложение + CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100) +); + +-- Серверные сессии. Источник истины; Valkey хранит только копию с TTL. +-- В БД лежит SHA-256 от токена, а не сам токен: утечка дампа не даёт войти. +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32), + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + expires_at timestamptz NOT NULL, + revoked_at timestamptz, + CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at) +); +CREATE INDEX sessions_user_id_idx ON sessions (user_id); +CREATE INDEX sessions_expires_at_idx ON sessions (expires_at); -- для периодической очистки истёкших + +CREATE TABLE chats ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100), + created_by uuid NOT NULL REFERENCES users (id), + created_at timestamptz NOT NULL DEFAULT clock_timestamp() +); +-- Список чатов сортируется по (created_at, id). +CREATE INDEX chats_created_at_id_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), + joined_at timestamptz NOT NULL DEFAULT clock_timestamp(), + PRIMARY KEY (chat_id, user_id) -- один пользователь входит в чат один раз +); +-- "Чаты пользователя": поиск по user_id (PK начинается с chat_id и тут не помогает). +CREATE INDEX chat_members_user_id_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id uuid NOT NULL, + sender_id uuid NOT NULL, + text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000), + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + -- Отправитель обязан быть участником этого чата: гарантирует сама БД. + CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id) + REFERENCES chat_members (chat_id, user_id) +); +-- Индекс под keyset-пагинацию истории: +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT n +-- Равенство по chat_id + диапазон по (created_at, id) читаются одним проходом индекса без сортировки. +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); diff --git a/migrations/0002_idempotency.sql b/migrations/0002_idempotency.sql new file mode 100644 index 00000000..d96c5bf1 --- /dev/null +++ b/migrations/0002_idempotency.sql @@ -0,0 +1,21 @@ +-- 0002: общая идемпотентность POST /chats/{chat_id}/messages (lab3). +-- Только добавляет таблицу (expand): версия lab2 продолжает работать на этой схеме, пока идёт замена реплик. + +-- Область уникальности контракта: пользователь + метод + путь чата + ключ. +-- Метод один (POST), путь однозначно задаётся chat_id, поэтому PK = (user_id, chat_id, key). +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL, + chat_id uuid NOT NULL, + key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'), + request_hash bytea NOT NULL CHECK (octet_length(request_hash) = 32), -- SHA-256 канонического JSON тела + message_id uuid NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + PRIMARY KEY (user_id, chat_id, key), + CONSTRAINT idempotency_sender_is_member FOREIGN KEY (chat_id, user_id) + REFERENCES chat_members (chat_id, user_id), + -- Ключ вставляется ДО сообщения (он и есть "замок" против гонки), поэтому FK проверяется при COMMIT. + CONSTRAINT idempotency_message_fk FOREIGN KEY (message_id) + REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED +); +-- Периодическая очистка ключей старше IDEMPOTENCY_TTL_SECONDS. +CREATE INDEX idempotency_keys_created_at_idx ON idempotency_keys (created_at); diff --git a/migrations/0003_cache_state.sql b/migrations/0003_cache_state.sql new file mode 100644 index 00000000..1d2a8821 --- /dev/null +++ b/migrations/0003_cache_state.sql @@ -0,0 +1,10 @@ +-- 0003: общий для всех реплик признак "кэшу сессий не доверять до ...". +-- В lab2 окно недоверия после сбоя Valkey жило в памяти единственного процесса. С несколькими репликами +-- это локальное состояние, от которого зависит корректность: реплика, не видевшая сбоя, отдала бы +-- копию отозванной сессии. Теперь реплика, получившая ошибку Valkey, публикует окно здесь. +-- Только добавление (expand): версии без этой таблицы её просто не используют. +CREATE TABLE cache_state ( + id smallint PRIMARY KEY CHECK (id = 1), -- одна строка на весь стенд + distrust_until timestamptz NOT NULL +); +INSERT INTO cache_state (id, distrust_until) VALUES (1, '-infinity'); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..3c92a107 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,20 @@ +# Полный lock (pip freeze в python:3.12.12-slim-bookworm); устанавливается с --no-deps. +# Прямые зависимости: fastapi, uvicorn, asyncpg, argon2-cffi, redis (клиент совместим с Valkey). +annotated-types==0.8.0 +anyio==4.15.1 +argon2-cffi==23.1.0 +argon2-cffi-bindings==26.1.0 +asyncpg==0.30.0 +cffi==2.1.1 +click==8.5.0 +fastapi==0.115.12 +h11==0.16.0 +idna==3.20 +pycparser==3.12 +pydantic==2.14.1 +pydantic_core==2.50.1 +redis==5.2.1 +starlette==0.46.2 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +uvicorn==0.34.2 diff --git a/scripts/collect-evidence.sh b/scripts/collect-evidence.sh new file mode 100755 index 00000000..9dc7c6ba --- /dev/null +++ b/scripts/collect-evidence.sh @@ -0,0 +1,47 @@ +#!/bin/sh +# Повторяемый сбор доказательств уровней 3–4 в evidence/ (запуск на хосте из корня, стенд уже поднят). +# Токены/пароли в вывод не попадают: публичные тесты их не печатают, hook-вывод подавлен тестом. +set -eu +cd "$(dirname "$0")/.." +export MSYS_NO_PATHCONV=1 PYTHONUTF8=1 +compose() { docker compose --env-file .env "$@"; } +tester() { compose --profile tools run --rm tester sh -c "$1" 2>&1 | grep -v '^ Container'; } +stamp() { echo "# $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git rev-parse --short HEAD 2>/dev/null || echo uncommitted)"; } +mkdir -p evidence +: > evidence/stop-one.log + +echo '== public checks' +{ stamp + tester 'pip install -q --disable-pip-version-check --root-user-action=ignore -r requirements-dev.txt && make check && make validate PYTHON=python3 && make test' +} | tee evidence/public-tests.txt + +echo '== instances behind LB (one session, 10 requests)' +{ stamp + compose ps --format 'table {{.Name}}\t{{.Image}}\t{{.Status}}\t{{.Ports}}' + echo + tester 'python student-tests/show_instances.py' +} | tee evidence/instances.txt + +echo '== failover: stop-one for each replica (restore between runs)' +{ stamp + for i in 1 2 3 4; do + tester 'make test-failover ACTION_SCRIPT=scripts/stop-one.sh' + # Тест останавливает реплику, обслужившую его первое сообщение; round-robin детерминирован, + # поэтому лишний запрос через LB сдвигает фазу и следующей целью становится другая реплика. + tester 'sh scripts/restore.sh && curl -s -o /dev/null http://lb:8080/health/live' + [ "$(cut -d' ' -f4 evidence/stop-one.log | sort -u | wc -l)" -ge 2 ] && break + done + echo; echo '# evidence/stop-one.log (what the hook really stopped):'; cat evidence/stop-one.log +} | tee evidence/failover-hook.txt + +echo '== persistence: restart of lb, api, postgres, valkey with volumes' +{ stamp + sh scripts/restart.sh + tester 'until curl -fs http://lb:8080/health/ready >/dev/null; do sleep 0.5; done; echo ready' + tester 'make test-persistence ACTION_SCRIPT=scripts/restart.sh' +} | tee evidence/persistence.txt + +echo '== failover series under load' +python student-tests/failover_series.py --scenario stop --output evidence/failover-stop.json | tail -n +1 > /dev/null +python student-tests/failover_series.py --scenario kill --output evidence/failover-kill.json > /dev/null +echo 'saved evidence/failover-{stop,kill}.json' diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100755 index 00000000..cfc3a8d5 --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,36 @@ +#!/bin/sh +# Создаёт локальные секреты в ./secrets (каталог в .gitignore). Повторный запуск ничего не перезаписывает. +set -eu +cd "$(dirname "$0")/.." +# Каталог закрыт для других пользователей хоста; сами файлы 0644, т.к. compose монтирует их +# в контейнеры с правами хоста, а процессы там работают под непривилегированными uid. +umask 022 +mkdir -p secrets +chmod 700 secrets + +random_hex() { od -An -tx1 -N24 /dev/urandom | tr -d ' \n'; } + +if [ ! -f secrets/postgres_password ]; then + pg=$(random_hex) + printf '%s' "$pg" > secrets/postgres_password + printf 'postgresql://app:%s@postgres:5432/messenger' "$pg" > secrets/database_url + echo 'created secrets/postgres_password, secrets/database_url' +fi +if [ ! -f secrets/valkey.conf ]; then + vk=$(random_hex) + # Valkey — только кэш сессий: persistence выключена намеренно, источник истины — PostgreSQL. + cat > secrets/valkey.conf < secrets/cache_url + echo 'created secrets/valkey.conf, secrets/cache_url' +fi +if [ ! -f .env ]; then + cp .env.example .env + echo 'created .env from .env.example' +fi +echo 'secrets ready (values are not printed)' diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..f09a8add --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,14 @@ +#!/bin/sh +# Перезапуск ВСЕГО стенда: lb, все API-реплики, PostgreSQL, Valkey — с сохранением volumes. +# Не выполняет down -v, FLUSHALL и повторный seed. Готовность API ожидает сам тест. +set -eu +cd "$(dirname "$0")/.." +compose() { docker compose --env-file .env "$@"; } + +started_at() { docker inspect -f '{{.Name}} {{.State.StartedAt}}' $(compose ps -q lb api postgres valkey); } + +echo 'before:'; started_at +compose stop lb api # сначала входная точка и клиенты хранилищ +compose restart postgres valkey # обычный restart контейнеров: volume pgdata остаётся +compose start api lb +echo 'after:'; started_at diff --git a/scripts/restore.sh b/scripts/restore.sh new file mode 100755 index 00000000..8e4df338 --- /dev/null +++ b/scripts/restore.sh @@ -0,0 +1,13 @@ +#!/bin/sh +# Возвращает остановленные API-реплики (после stop-one.sh) и ждёт их healthcheck. +set -eu +project=${COMPOSE_PROJECT_NAME:-mtusi-lab3} +filter="--filter label=com.docker.compose.project=$project --filter label=com.docker.compose.service=api" +stopped=$(docker ps -aq $filter --filter status=exited) +[ -n "$stopped" ] && docker start $stopped >/dev/null +for _ in $(seq 1 60); do + unhealthy=$(docker ps -q $filter | xargs docker inspect -f '{{.State.Health.Status}}' | grep -vc healthy || true) + [ "$unhealthy" = 0 ] && break + sleep 1 +done +docker ps $filter --format '{{.Names}} {{.Status}}' diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..2fb2655e --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,36 @@ +#!/bin/sh +# Поочерёдная замена API-реплик без остановки сервиса (Compose не умеет rolling update сам). +# 1. собрать новый образ (BUILD_ID попадает в label образа); +# 2. применить миграции ОДИН раз (только expand-миграции: старая версия работает на новой схеме); +# 3. поднять столько же новых реплик рядом со старыми (surge x2) и дождаться их healthcheck; +# 4. по одной останавливать старые: docker stop -> SIGTERM -> drain -> graceful shutdown, затем удалить. +# HAProxy сам находит новые реплики через DNS и исключает старые по /health/ready. +# Запускать на хосте из корня репозитория (нужны bind-пути compose.yaml). NO_BUILD=1 — без пересборки. +set -eu +cd "$(dirname "$0")/.." +compose() { docker compose --env-file .env "$@"; } +project=mtusi-lab3 +filter="--filter label=com.docker.compose.project=$project --filter label=com.docker.compose.service=api" + +old=$(docker ps -q $filter) +n=$(echo "$old" | wc -w) +[ "$n" -ge 1 ] || { echo 'no running api replicas' >&2; exit 2; } +build_id=${BUILD_ID:-$(git rev-parse --short HEAD 2>/dev/null || echo dev)-$(date +%s)} + +echo "$(date -u +%H:%M:%S) old replicas ($n): $(docker inspect -f '{{.Name}}={{index .Config.Labels "org.opencontainers.image.revision"}}' $old | tr -d / | tr '\n' ' ')" +if [ "${NO_BUILD:-0}" != 1 ]; then + compose build -q --build-arg BUILD_ID="$build_id" api +fi +compose run --rm -T migrate # однократно, под advisory lock +compose up -d --wait --no-deps --no-recreate --scale api=$((n * 2)) api 2>&1 | grep -v '^ Container' || true +new=$(docker ps -q $filter | grep -vxF "$old" || true) +[ "$(echo "$new" | wc -w)" -eq "$n" ] || { echo 'new replicas did not start' >&2; exit 3; } +echo "$(date -u +%H:%M:%S) new replicas healthy: $(docker inspect -f '{{.Name}}={{index .Config.Labels "org.opencontainers.image.revision"}}' $new | tr -d / | tr '\n' ' ')" +sleep "${SETTLE_SECONDS:-3}" # LB: rise 2 x inter 1 s + DNS 1 с +for c in $old; do + name=$(docker inspect -f '{{.Name}}' "$c" | tr -d /) + docker stop -t 20 "$c" >/dev/null + docker rm "$c" >/dev/null + echo "$(date -u +%H:%M:%S) replaced $name" +done +docker ps $filter --format '{{.Names}} {{.Status}} {{.Label "org.opencontainers.image.revision"}}' diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..d22fdd1c --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,29 @@ +#!/bin/sh +# Останавливает ОДНУ API-реплику — ту, что обслужила тест, — и оставляет её остановленной. +# TARGET_INSTANCE_ID = "-<случайный суффикс>", hostname = короткий ID контейнера. +# STOP_MODE=stop (по умолчанию): docker stop -> SIGTERM -> drain -> graceful shutdown. +# STOP_MODE=kill: SIGKILL, внезапная смерть процесса без drain. +# БД, LB и volumes не трогает. Восстановление — отдельно: sh scripts/restore.sh +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +cd "$(dirname "$0")/.." +project=${COMPOSE_PROJECT_NAME:-mtusi-lab3} +cid=${TARGET_INSTANCE_ID%-*} +case "$cid" in ''|*[!0-9a-f]*) echo 'TARGET_INSTANCE_ID has unexpected format' >&2; exit 2 ;; esac + +# Защита от остановки чужого контейнера: только сервис api этого проекта. +owner=$(docker inspect -f '{{index .Config.Labels "com.docker.compose.project"}}/{{index .Config.Labels "com.docker.compose.service"}}' "$cid") +[ "$owner" = "$project/api" ] || { echo "container $cid is not $project/api" >&2; exit 3; } +name=$(docker inspect -f '{{.Name}}' "$cid" | tr -d /) + +started=$(date -u +%Y-%m-%dT%H:%M:%SZ) +if [ "${STOP_MODE:-stop}" = kill ]; then + docker kill "$cid" >/dev/null +else + docker stop -t 20 "$cid" >/dev/null +fi +state=$(docker inspect -f '{{.State.Status}} exit={{.State.ExitCode}} finished={{.State.FinishedAt}}' "$cid") +mkdir -p evidence +printf '%s mode=%s instance=%s container=%s state=%s\n' \ + "$started" "${STOP_MODE:-stop}" "$TARGET_INSTANCE_ID" "$name" "$state" >> evidence/stop-one.log +echo "stopped $name: $state" diff --git a/scripts/test-lab3.sh b/scripts/test-lab3.sh new file mode 100755 index 00000000..3a574904 --- /dev/null +++ b/scripts/test-lab3.sh @@ -0,0 +1,12 @@ +#!/bin/sh +# Собственные проверки lab3 + регрессия уровня 4 lab2. Запускать на хосте (Linux/macOS/Git Bash) из корня. +# Поднимает api-ttl (SESSION_TTL_SECONDS=2), запускает student-tests в контейнере tester, гасит api-ttl. +set -eu +cd "$(dirname "$0")/.." +compose() { docker compose --env-file .env "$@"; } +compose --profile test up -d --wait api-ttl +status=0 +MSYS_NO_PATHCONV=1 compose --profile tools run --rm tester sh -c \ + 'python student-tests/test_lab3.py; a=$?; python student-tests/test_lab2_regression.py; b=$?; exit $((a | b))' || status=$? +compose --profile test stop api-ttl +exit $status diff --git a/student-tests/failover_series.py b/student-tests/failover_series.py new file mode 100644 index 00000000..3d76bb62 --- /dev/null +++ b/student-tests/failover_series.py @@ -0,0 +1,312 @@ +#!/usr/bin/env python3 +"""Серии отказов под нагрузкой (уровень 4): RPS, ошибки, время обнаружения и восстановления. + +Запускается на ХОСТЕ из корня репозитория (нужны docker CLI и, для rolling, compose с bind-путями): + python student-tests/failover_series.py --scenario stop # graceful stop каждой реплики по очереди + python student-tests/failover_series.py --scenario kill # SIGKILL каждой реплики по очереди + python student-tests/failover_series.py --scenario rolling # scripts/rolling-update.sh под нагрузкой + +Нагрузка closed-loop: W писателей (POST сообщения; неопределённый результат повторяется с ТЕМ ЖЕ ключом, +как в tests/resilience.py) и R читателей (GET истории). Параллельно раз в 200 мс опрашивается +CSV-статистика HAProxy: когда слот целевой реплики перестал быть UP — это время обнаружения отказа LB. +После серии проверяется, что все подтверждённые сообщения на месте и нет дублей. +Токены остаются в памяти процесса; в отчёт попадают только агрегаты. +""" +import argparse +import csv +import io +import json +import math +import os +import subprocess +import sys +import threading +import time +import urllib.parse +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) +from client import Client, Failure, check # noqa: E402 + +PROJECT = 'mtusi-lab3' +EDGE_NETWORK = PROJECT + '_edge' +API_FILTER = ['--filter', f'label=com.docker.compose.project={PROJECT}', + '--filter', 'label=com.docker.compose.service=api'] + + +def docker(*args: str) -> str: + return subprocess.run(['docker', *args], check=True, text=True, capture_output=True).stdout.strip() + + +def api_containers() -> list[str]: + names = docker('ps', *API_FILTER, '--format', '{{.Names}}').split() + return sorted(names) + + +def container_info(name: str) -> dict: + fmt = ('{{.Config.Hostname}}|{{index .Config.Labels "org.opencontainers.image.revision"}}|' + '{{(index .NetworkSettings.Networks "%s").IPAddress}}') % EDGE_NETWORK + hostname, revision, ip = docker('inspect', '-f', fmt, name).split('|') + return {'name': name, 'hostname': hostname, 'revision': revision, 'ip': ip} + + +def percentile(values: list[float], p: float): + values = sorted(values) + return round(1000 * values[max(0, math.ceil(p * len(values)) - 1)], 1) if values else None + + +class LbWatcher(threading.Thread): + """Опрос /stats;csv: состояние слотов backend `api` и счётчики retry/redispatch.""" + + def __init__(self, stats_url: str, t0: float): + super().__init__(daemon=True) + self.url = stats_url.rstrip('/') + ';csv' + self.t0 = t0 + self.stop_flag = threading.Event() + self.samples = [] # (t, {addr: status}) + self.first = self.last = None + + def snapshot(self): + with urllib.request.urlopen(self.url, timeout=1) as r: + rows = list(csv.DictReader(io.StringIO(r.read().decode().lstrip('# ')))) + servers = {row['addr']: row['status'] for row in rows + if row['pxname'] == 'api' and row['svname'] not in ('FRONTEND', 'BACKEND') and row.get('addr')} + backend = next(row for row in rows if row['pxname'] == 'api' and row['svname'] == 'BACKEND') + return servers, {'retries': int(backend['wretr'] or 0), 'redispatches': int(backend['wredis'] or 0)} + + def run(self): + while not self.stop_flag.is_set(): + try: + servers, counters = self.snapshot() + self.samples.append((time.monotonic() - self.t0, servers)) + self.first = self.first or counters + self.last = counters + except Exception: # LB-статистика — вспомогательная, не влияет на результат серии + pass + time.sleep(0.2) + + def first_not_up(self, ip: str, after: float): + """Первый момент после `after`, когда слот с этим IP не UP (DOWN/MAINT/исчез из DNS).""" + addr = ip + ':8080' + for t, servers in self.samples: + if t >= after and not servers.get(addr, 'MISSING').startswith('UP'): + return round(t - after, 3), servers.get(addr, 'removed from DNS') + return None, None + + +def run_probe(base_url: str, stats_url: str, action, targets: list[dict], duration: float, + action_at: float, writers: int, readers: int) -> dict: + c = Client(base_url) + alice, bob, _eve, chat = c.bootstrap() + events = [] # (t, kind, ok, instance, latency) + confirmed = [] # подтверждённые сообщения + lock = threading.Lock() + retries_with_same_key = [0] + t0 = time.monotonic() + deadline = t0 + duration + watcher = LbWatcher(stats_url, t0) + watcher.start() + + def record(kind, ok, instance, latency): + with lock: + events.append((time.monotonic() - t0, kind, ok, instance, latency)) + + def writer(i): + local = Client(base_url, timeout=3) + key, n = uuid.uuid4().hex, 0 + text = f'probe-{i}-{n}' + while time.monotonic() < deadline: + start = time.monotonic() + try: + r = local.message(alice, chat, text, key=key) + record('write', True, r['headers'].get('X-Instance-Id', ''), time.monotonic() - start) + with lock: + confirmed.append(r['json']) + n += 1 + key, text = uuid.uuid4().hex, f'probe-{i}-{n}' + except Failure: + record('write', False, '', time.monotonic() - start) + with lock: + retries_with_same_key[0] += 1 + time.sleep(0.05) # тот же key и тот же body при следующей попытке + + def reader(_i): + local = Client(base_url, timeout=3) + path = f"/api/v1/chats/{chat['id']}/messages?limit=20" + while time.monotonic() < deadline: + start = time.monotonic() + try: + r = local.call('GET', path, actor=bob, schema='MessagePage') + record('read', True, r['headers'].get('X-Instance-Id', ''), time.monotonic() - start) + except Failure: + record('read', False, '', time.monotonic() - start) + time.sleep(0.05) + + threads = [threading.Thread(target=writer, args=(i,)) for i in range(writers)] + threads += [threading.Thread(target=reader, args=(i,)) for i in range(readers)] + for t in threads: + t.start() + time.sleep(max(0.0, t0 + action_at - time.monotonic())) + a_start = time.monotonic() - t0 + action_output = action() + a_end = time.monotonic() - t0 + for t in threads: + t.join() + watcher.stop_flag.set() + watcher.join() + + # Сохранность: тот же токен, полная история через LB, без дублей. + history, cursor = [], None + while True: + path = f"/api/v1/chats/{chat['id']}/messages?limit=100" + (f'&cursor={urllib.parse.quote(cursor, safe="")}' if cursor else '') + page = c.call('GET', path, actor=bob, schema='MessagePage')['json'] + history += page['items'] + cursor = page['next_cursor'] + if cursor is None: + break + ids = {m['id'] for m in history} + texts = [m['text'] for m in history] + lost = sum(1 for m in confirmed if m['id'] not in ids) + check(len(ids) == len(history), 'duplicated message id in history') + check(len(texts) == len(set(texts)), 'retry with same key produced a duplicate message') + check(lost == 0, f'{lost} confirmed messages lost') + + def window(lo, hi): + sel = [e for e in events if lo <= e[0] < hi] + ok = [e for e in sel if e[2]] + span = max(hi - lo, 1e-9) + return {'seconds': round(span, 2), 'ok_rps': round(len(ok) / span, 1), + 'write_rps': round(sum(1 for e in ok if e[1] == 'write') / span, 1), + 'read_rps': round(sum(1 for e in ok if e[1] == 'read') / span, 1), + 'errors': len(sel) - len(ok), + 'p50_ms': percentile([e[4] for e in ok], .50), 'p95_ms': percentile([e[4] for e in ok], .95), + 'p99_ms': percentile([e[4] for e in ok], .99), 'max_ms': percentile([e[4] for e in ok], 1.0)} + + errors = [e for e in events if not e[2]] + target_prefixes = tuple(t['hostname'] + '-' for t in targets) + served_by_target = [e[0] for e in events if e[2] and e[3].startswith(target_prefixes)] + per_second = [] + for s in range(int(duration)): + sel = [e for e in events if s <= e[0] < s + 1] + per_second.append({'t': s, 'ok': sum(1 for e in sel if e[2]), 'err': sum(1 for e in sel if not e[2]), + 'instances': len({e[3] for e in sel if e[2]})}) + detection = {} + for t in targets: + seconds, state = watcher.first_not_up(t['ip'], a_start) + detection[t['name']] = {'lb_marked_not_up_after_s': seconds, 'lb_state': state} + lb_counters = None + if watcher.first and watcher.last: + lb_counters = {k: watcher.last[k] - watcher.first[k] for k in watcher.last} + return { + 'targets': [{k: t[k] for k in ('name', 'hostname', 'revision')} for t in targets], + 'action_started_s': round(a_start, 3), 'action_duration_s': round(a_end - a_start, 3), + 'action_output': action_output, + 'before': window(1, a_start), 'during_action_plus_5s': window(a_start, a_end + 5), + 'after': window(a_end + 5, duration), + 'errors_total': len(errors), + 'write_attempts_retried_same_key': retries_with_same_key[0], + 'error_window_s': ([round(errors[0][0] - a_start, 3), round(errors[-1][0] - a_start, 3)] if errors else None), + 'recovery_s': round(errors[-1][0] - a_start, 3) if errors else 0.0, + 'target_last_served_after_action_s': (round(max(served_by_target) - a_start, 3) + if served_by_target and max(served_by_target) >= a_start else None), + 'lb_detection': detection, + 'lb_retries_redispatches': lb_counters, + 'instances_after': sorted({e[3] for e in events if e[2] and e[0] > a_end + 5}), + 'confirmed_writes': len(confirmed), 'history_messages': len(history), + 'duplicates': 0, 'lost_confirmed': lost, + 'timeline_per_second': per_second, + } + + +def wait_lb_up(stats_url: str, ip: str, seconds: float = 60) -> None: + deadline = time.monotonic() + seconds + url = stats_url.rstrip('/') + ';csv' + while time.monotonic() < deadline: + try: + with urllib.request.urlopen(url, timeout=1) as r: + rows = csv.DictReader(io.StringIO(r.read().decode().lstrip('# '))) + if any(row['pxname'] == 'api' and row.get('addr') == ip + ':8080' and row['status'].startswith('UP') + for row in rows): + return + except OSError: + pass + time.sleep(0.5) + raise Failure('replica did not return to LB rotation') + + +def restore(stats_url: str) -> None: + subprocess.run(['sh', str(ROOT / 'scripts/restore.sh')], check=True, capture_output=True) + for name in api_containers(): + wait_lb_up(stats_url, container_info(name)['ip']) + + +def main() -> int: + p = argparse.ArgumentParser(description=__doc__.split('\n')[0]) + p.add_argument('--scenario', choices=['stop', 'kill', 'rolling'], required=True) + p.add_argument('--base-url', default=os.environ.get('BASE_URL', 'http://localhost:8080')) + p.add_argument('--stats-url', default=os.environ.get('LB_STATS_URL', 'http://localhost:8404/stats')) + p.add_argument('--duration', type=float, default=None) + p.add_argument('--action-at', type=float, default=8) + p.add_argument('--writers', type=int, default=4) + p.add_argument('--readers', type=int, default=2) + p.add_argument('--output', default=None) + args = p.parse_args() + duration = args.duration or (45 if args.scenario == 'rolling' else 25) + + runs = [] + if args.scenario == 'rolling': + targets = [container_info(n) for n in api_containers()] + + def action(): + r = subprocess.run(['sh', str(ROOT / 'scripts/rolling-update.sh')], text=True, capture_output=True) + check(r.returncode == 0, 'rolling-update.sh failed: ' + r.stderr[-500:]) + return r.stdout.strip().splitlines() + result = run_probe(args.base_url, args.stats_url, action, targets, duration, args.action_at, + args.writers, args.readers) + result['replicas_after'] = [container_info(n) for n in api_containers()] + runs.append(result) + else: + for name in api_containers(): # по очереди каждую реплику, восстанавливая предыдущую + restore(args.stats_url) + target = container_info(name) + + def action(name=name): + started = time.monotonic() + if args.scenario == 'kill': + docker('kill', name) + else: + docker('stop', '-t', '20', name) + state = docker('inspect', '-f', '{{.State.Status}} exit={{.State.ExitCode}}', name) + return [f'{args.scenario} {name}: {state} in {time.monotonic() - started:.2f}s'] + result = run_probe(args.base_url, args.stats_url, action, [target], duration, args.action_at, + args.writers, args.readers) + runs.append(result) + print(f"{args.scenario} {name}: errors={result['errors_total']} recovery={result['recovery_s']}s " + f"lb_detection={result['lb_detection'][name]['lb_marked_not_up_after_s']}s " + f"rps before/after={result['before']['ok_rps']}/{result['after']['ok_rps']}", flush=True) + restore(args.stats_url) + + report = { + 'scenario': args.scenario, 'date_utc': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()), + 'profile': {'duration_s': duration, 'action_at_s': args.action_at, 'writers': args.writers, + 'readers': args.readers, 'client_timeout_s': 3, + 'workload': 'closed-loop: POST message (retry same key on failure) + GET history limit=20'}, + 'runs': runs, + } + text = json.dumps(report, ensure_ascii=False, indent=2) + if args.output: + Path(args.output).parent.mkdir(parents=True, exist_ok=True) + Path(args.output).write_text(text + '\n', encoding='utf-8') + summary = [{k: r[k] for k in ('targets', 'errors_total', 'recovery_s', 'lb_detection', 'action_duration_s', + 'target_last_served_after_action_s', 'lb_retries_redispatches')} + | {'rps_before': r['before']['ok_rps'], 'rps_after': r['after']['ok_rps'], + 'p99_during_ms': r['during_action_plus_5s']['p99_ms']} for r in runs] + print(json.dumps(summary, ensure_ascii=False, indent=1)) + return 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/student-tests/show_instances.py b/student-tests/show_instances.py new file mode 100644 index 00000000..4216252d --- /dev/null +++ b/student-tests/show_instances.py @@ -0,0 +1,15 @@ +#!/usr/bin/env python3 +"""Один вход (одна сессия) -> 10 запросов через LB: какие реплики обслужили. Токен не печатается.""" +import os +import sys +from collections import Counter +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client # noqa: E402 + +c = Client(os.environ.get('BASE_URL', 'http://lb:8080')) +alice = c.user('instances') +served = [c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['headers']['X-Instance-Id'] for _ in range(10)] +print('X-Instance-Id sequence:', ' '.join(served)) +print('distinct replicas for one session without re-login:', dict(Counter(served))) diff --git a/student-tests/test_lab2_regression.py b/student-tests/test_lab2_regression.py new file mode 100644 index 00000000..fa74f083 --- /dev/null +++ b/student-tests/test_lab2_regression.py @@ -0,0 +1,256 @@ +#!/usr/bin/env python3 +"""Регрессия: собственные проверки уровня 4 из lab2, перенесённые на стенд lab3 (через LB). +Запуск: sh scripts/test-lab3.sh (внутри сервиса tester). + +Требуют запущенный стенд и доступ к docker (останавливают/ставят на паузу valkey и postgres, +затем возвращают их). Используют только синтетические данные. +""" +import base64 +import hashlib +import os +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) +from client import Client, Failure, check # noqa: E402 + +BASE_URL = os.environ.get('BASE_URL', 'http://lb:8080') +TTL_BASE_URL = os.environ.get('TTL_BASE_URL', 'http://api-ttl:8080') +VALKEY_CLI = 'valkey-cli --no-auth-warning -a "$(sed -n "s/^requirepass //p" /run/secrets/valkey_conf)" ' + + +def compose(*args: str, capture: bool = False) -> str: + result = subprocess.run(['docker', 'compose', '--env-file', str(ROOT / '.env'), *args], + cwd=ROOT, check=True, text=True, + stdout=subprocess.PIPE if capture else subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + return (result.stdout or '').strip() + + +def sql(query: str) -> str: + return compose('exec', '-T', 'postgres', 'psql', '-U', 'app', '-d', 'messenger', '-tAc', query, capture=True) + + +def valkey(command: str) -> str: + return compose('exec', '-T', 'valkey', 'sh', '-c', VALKEY_CLI + command, capture=True) + + +def basic(username: str, password: str) -> dict: + return {'Authorization': 'Basic ' + base64.b64encode(f'{username}:{password}'.encode()).decode()} + + +def wait_ready(c: Client, seconds: float = 60) -> None: + deadline = time.monotonic() + seconds + while True: + try: + c.call('GET', '/health/ready', schema='Health') + return + except Failure: + check(time.monotonic() < deadline, 'API did not become ready') + time.sleep(0.5) + + +def wait_healthy(service: str, seconds: float = 60) -> None: + deadline = time.monotonic() + seconds + container = compose('ps', '-q', service, capture=True) + while subprocess.run(['docker', 'inspect', '-f', '{{.State.Health.Status}}', container], + text=True, capture_output=True).stdout.strip() != 'healthy': + check(time.monotonic() < deadline, service + ' did not become healthy') + time.sleep(0.5) + + +def cache_key(actor: dict) -> str: + return 'session:' + hashlib.sha256(actor['token'].encode()).hexdigest() + + +def wait_cache_used(c: Client, actor: dict, seconds: float = 75) -> None: + """После недавнего сбоя Valkey API законно не доверяет кэшу SESSION_CACHE_TTL_SECONDS — ждём конца окна.""" + deadline = time.monotonic() + seconds + while True: + c.call('GET', '/api/v1/users/me', actor=actor, schema='User') + if valkey('EXISTS ' + cache_key(actor)) == '1': + return + check(time.monotonic() < deadline, 'session was never cached in Valkey') + time.sleep(2) + + +def bearer(token: str) -> dict: + return {'Authorization': 'Bearer ' + token} + +# ---------------------------------------------------------------- тесты + + +def test_wrong_password(c: Client): + alice = c.user('wrongpw') + username = alice['registration']['username'] + wrong = c.call('POST', '/api/v1/auth/sessions', 401, headers=basic(username, 'definitely-wrong-password')) + unknown = c.call('POST', '/api/v1/auth/sessions', 401, headers=basic('no_such_' + uuid.uuid4().hex[:8], 'whatever-password-123')) + # Одинаковый ответ: по нему нельзя узнать, существует ли username. + check(wrong['json']['error']['message'] == unknown['json']['error']['message'], 'different 401 for unknown user') + check(wrong['headers']['WWW-Authenticate'] == 'Basic realm="messenger", charset="UTF-8"', 'wrong Basic challenge') + c.call('POST', '/api/v1/auth/sessions', 401, headers={'Authorization': 'Basic !!!not-base64'}) + c.call('POST', '/api/v1/auth/sessions', 401, headers=bearer(alice['token'])) # Bearer на входе не принимается + + +def test_logout(c: Client): + alice = c.user('logout') + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') + c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice) + r = c.call('GET', '/api/v1/users/me', 401, actor=alice) + check(r['headers']['WWW-Authenticate'] == 'Bearer realm="messenger"', 'wrong Bearer challenge') + c.call('DELETE', '/api/v1/auth/sessions/current', 401, actor=alice) + revoked = sql("SELECT count(*) FROM sessions s JOIN users u ON u.id = s.user_id " + f"WHERE u.username = '{alice['registration']['username']}' AND s.revoked_at IS NOT NULL") + check(revoked == '1', 'revocation not recorded in PostgreSQL') + + +def test_short_ttl(_c: Client): + # Отдельная реплика api-ttl с SESSION_TTL_SECONDS=2, общая БД и кэш. + c = Client(TTL_BASE_URL) + wait_ready(c) + alice = c.user('ttl') + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') + time.sleep(3) + c.call('GET', '/api/v1/users/me', 401, actor=alice) + + +def test_username_race(c: Client): + username = 'race_' + uuid.uuid4().hex[:12] + body = {'username': username, 'display_name': 'Гонка', 'password': 'Race-password-' + uuid.uuid4().hex} + statuses, barrier = [], threading.Barrier(16) + + def register(): + barrier.wait() + statuses.append(Client(BASE_URL, timeout=30).call('POST', '/api/v1/users', [201, 409], body=body)['status']) + + threads = [threading.Thread(target=register) for _ in range(16)] + for t in threads: + t.start() + for t in threads: + t.join() + check(sorted(statuses) == [201] + [409] * 15, f'race result {sorted(statuses)}') + check(sql(f"SELECT count(*) FROM users WHERE username = '{username}'") == '1', 'duplicate username row') + + +def test_chat_rollback(c: Client): + alice = c.user('rollback') + before = sql('SELECT (SELECT count(*) FROM chats) || \' \' || (SELECT count(*) FROM chat_members)') + # Второй участник не существует: INSERT chats уже выполнен, INSERT chat_members вставит 1 из 2 -> ROLLBACK. + c.call('POST', '/api/v1/chats', 400, actor=alice, + body={'title': 'Откат', 'member_ids': [alice['id'], str(uuid.uuid4())]}) + after = sql('SELECT (SELECT count(*) FROM chats) || \' \' || (SELECT count(*) FROM chat_members)') + check(before == after, f'partial chat left after failure: {before} -> {after}') + listed = c.call('GET', '/api/v1/chats', actor=alice, schema='ChatPage')['json'] + check(listed['items'] == [], 'failed chat is visible') + + +def test_cursor_rules(c: Client): + alice, bob, _eve, chat = c.bootstrap() + other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой', 'member_ids': [alice['id']]}, + schema='Chat')['json'] + for i in range(3): + c.message(alice, chat, f'm{i}') + c.message(alice, other, f'o{i}') + page = c.call('GET', f'/api/v1/chats/{chat["id"]}/messages?limit=1', actor=alice, schema='MessagePage')['json'] + from urllib.parse import quote + cursor = quote(page['next_cursor'], safe='') + c.call('GET', f'/api/v1/chats/{other["id"]}/messages?cursor={cursor}', 400, actor=alice) # курсор чужого чата + c.call('GET', f'/api/v1/chats/{chat["id"]}/messages?cursor=garbage', 400, actor=alice) + c.call('GET', f'/api/v1/chats/{chat["id"]}/messages?limit=101', 400, actor=alice) + c.call('POST', '/api/v1/chats', 400, actor=alice, body={'title': 'x', 'member_ids': [alice['id']], 'extra': 1}) + c.call('POST', f'/api/v1/chats/{chat["id"]}/messages', 400, actor=bob, body={'text': 'x', 'sender_id': alice['id']}) + + +def test_valkey_cache_role(c: Client): + alice = c.user('cache') + wait_cache_used(c, alice) + ttl = int(valkey('TTL ' + cache_key(alice))) + check(0 < ttl <= 60, f'unexpected cache TTL {ttl}') + valkey('FLUSHALL') # потеря всего кэша + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') # источник истины — PostgreSQL + check(valkey('EXISTS ' + cache_key(alice)) == '1', 'cache was not refilled on miss') + + +def test_valkey_down(c: Client): + alice = c.user('vkdown') + try: + compose('stop', 'valkey') + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') # обход кэша через PostgreSQL + c.call('GET', '/api/v1/users/me', 401, headers=bearer('A' * 43)) # неизвестный токен — не доверяем + c.call('GET', '/api/v1/users/me', 401) # аноним — 401 + bob = c.user('vkdown_login') # вход работает без кэша + c.call('GET', '/health/ready', schema='Health') # Valkey не критичен + c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=bob) + c.call('GET', '/api/v1/users/me', 401, actor=bob) + finally: + compose('start', 'valkey') + wait_healthy('valkey') + + +def test_revoke_during_cache_partition(c: Client): + # Худший случай инвалидации: logout во время разрыва API <-> Valkey, DEL потерян, а копия отозванной + # сессии в Valkey пережила разрыв. Окно недоверия к кэшу (SESSION_CACHE_TTL_SECONDS после ошибки) + # не даёт её использовать. TCP может доставить DEL повторной передачей после восстановления сети, + # поэтому потерю DEL моделируем явно: возвращаем сохранённую до разрыва копию записи. + alice = c.user('partition') + wait_cache_used(c, alice) + key = cache_key(alice) + stale_value = valkey('GET ' + key) + container = compose('ps', '-q', 'valkey', capture=True) + network = 'mtusi-lab3_data' # Valkey в lab3 только во внутренней сети data + subprocess.run(['docker', 'network', 'disconnect', network, container], check=True) + try: + c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice) # COMMIT в PostgreSQL прошёл + finally: + subprocess.run(['docker', 'network', 'connect', '--alias', 'valkey', network, container], check=True) + valkey(f"SET {key} '{stale_value}' EX 60") + c.call('GET', '/api/v1/users/me', 401, actor=alice) + + +def test_postgres_down(c: Client): + alice = c.user('pgdown') + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') + try: + compose('stop', 'postgres') + c.call('GET', '/health/live', schema='Health') + c.call('GET', '/health/ready', 503) + r = c.call('GET', '/api/v1/users/me', 503, actor=alice) # ограниченная ошибка, не 500/200 + check(r['json']['error']['code'] == 'unavailable', 'expected unavailable') + c.call('GET', '/api/v1/users/me', 503, headers=bearer('B' * 43)) # неизвестный токен не проходит + c.call('GET', '/api/v1/chats', 401) # аноним не пропускается + c.call('POST', '/api/v1/users', 503, body={'username': 'pg_' + uuid.uuid4().hex[:8], + 'display_name': 'x', 'password': 'Password-123456'}) + finally: + compose('start', 'postgres') + wait_ready(c) + c.call('GET', '/api/v1/users/me', actor=alice, schema='User') # та же сессия жива после рестарта БД + + +TESTS = [test_wrong_password, test_logout, test_short_ttl, test_username_race, test_chat_rollback, + test_cursor_rules, test_valkey_cache_role, test_revoke_during_cache_partition, test_valkey_down, + test_postgres_down] + + +def main() -> int: + c = Client(BASE_URL) + wait_ready(c) + failed = 0 + for test in TESTS: + started = time.monotonic() + try: + test(c) + print(f'PASS {test.__name__} ({time.monotonic() - started:.1f}s)') + except (Failure, subprocess.CalledProcessError, OSError) as exc: + failed += 1 + print(f'FAIL {test.__name__}: {exc}') + print(f'{len(TESTS) - failed}/{len(TESTS)} passed') + return 1 if failed else 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/student-tests/test_lab3.py b/student-tests/test_lab3.py new file mode 100644 index 00000000..e71dea01 --- /dev/null +++ b/student-tests/test_lab3.py @@ -0,0 +1,279 @@ +#!/usr/bin/env python3 +"""Собственные проверки lab3 (уровни 3–4). Запуск: sh scripts/test-lab3.sh (внутри сервиса tester). + +Обращаются к репликам и НАПРЯМУЮ (по IP из DNS Docker внутри сети edge), чтобы гарантировать, что +конкурентные повторы действительно приходят в разные процессы, а не полагаться на round-robin LB. +Требуют доступ к docker (останавливают postgres, шлют SIGTERM реплике и возвращают всё обратно). +""" +import json +import os +import socket +import subprocess +import sys +import threading +import time +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / 'tests')) +from client import Client, Failure, check # noqa: E402 + +BASE_URL = os.environ.get('BASE_URL', 'http://lb:8080') +PROJECT = 'mtusi-lab3' +API_FILTER = ['--filter', f'label=com.docker.compose.project={PROJECT}', + '--filter', 'label=com.docker.compose.service=api'] + + +def compose(*args: str, capture: bool = False) -> str: + result = subprocess.run(['docker', 'compose', '--env-file', str(ROOT / '.env'), *args], + cwd=ROOT, check=True, text=True, + stdout=subprocess.PIPE if capture else subprocess.DEVNULL, + stderr=subprocess.DEVNULL) + return (result.stdout or '').strip() + + +def docker(*args: str) -> str: + return subprocess.run(['docker', *args], check=True, text=True, capture_output=True).stdout.strip() + + +def sql(query: str) -> str: + return compose('exec', '-T', 'postgres', 'psql', '-U', 'app', '-d', 'messenger', '-tAc', query, capture=True) + + +def replica_urls() -> list[str]: + """Все IP сервиса api из DNS Docker -> прямые адреса реплик (порты наружу не опубликованы).""" + ips = sorted({info[4][0] for info in socket.getaddrinfo('api', 8080, socket.AF_INET, socket.SOCK_STREAM)}) + check(len(ips) >= 2, f'expected >= 2 api replicas in DNS, got {len(ips)}') + return [f'http://{ip}:8080' for ip in ips] + + +def wait_ready(c: Client, seconds: float = 60) -> None: + deadline = time.monotonic() + seconds + while True: + try: + c.call('GET', '/health/ready', schema='Health') + return + except Failure: + check(time.monotonic() < deadline, 'API did not become ready') + time.sleep(0.5) + + +def raw_post(base: str, path: str, actor: dict, raw: bytes, key: str | None): + """POST с заданными байтами тела (для проверки семантического равенства JSON).""" + headers = {'Content-Type': 'application/json', 'Authorization': 'Bearer ' + actor['token']} + if key is not None: + headers['Idempotency-Key'] = key + return Client(base).call('POST', path, [201, 400, 409], raw=raw, headers=headers, schema='Message') + + +def concurrent(calls: list) -> list: + """Запускает функции одновременно (barrier) и возвращает результаты в исходном порядке.""" + results = [None] * len(calls) + barrier = threading.Barrier(len(calls)) + + def run(i): + barrier.wait() + try: + results[i] = calls[i]() + except Exception as exc: # результат проверяет вызывающий тест + results[i] = exc + + threads = [threading.Thread(target=run, args=(i,)) for i in range(len(calls))] + for t in threads: + t.start() + for t in threads: + t.join() + return results + + +def count_messages(chat: dict) -> int: + return int(sql(f"SELECT count(*) FROM messages WHERE chat_id = '{chat['id']}'")) + +# ---------------------------------------------------------------- тесты + + +def test_session_across_replicas(c: Client): + alice = c.user('xrepl') # вход через LB (обслужила какая-то одна реплика) + seen = {c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['headers']['X-Instance-Id'] + for _ in range(20)} + check(len(seen) >= 2, f'one session must be served by >= 2 replicas, saw {seen}') + urls = replica_urls() + for url in urls: # каждая реплика напрямую принимает тот же токен + me = Client(url).call('GET', '/api/v1/users/me', actor=alice, schema='User')['json'] + check(me['id'] == alice['id'], 'replica resolved another user') + Client(urls[0]).call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice) + for url in urls: # logout на одной реплике виден всем (общий store) + Client(url).call('GET', '/api/v1/users/me', 401, actor=alice) + + +def test_same_key_concurrent_across_replicas(c: Client): + alice, _bob, _eve, chat = c.bootstrap() + urls, key = replica_urls(), uuid.uuid4().hex + calls = [lambda u=urls[i % len(urls)]: Client(u, timeout=15).message(alice, chat, 'один раз', key=key) + for i in range(24)] + results = concurrent(calls) + failures = [r for r in results if isinstance(r, Exception)] + check(not failures, f'concurrent retry failed: {failures[:1]}') + bodies = {json.dumps(r['json'], sort_keys=True) for r in results} + instances = {r['headers']['X-Instance-Id'] for r in results} + check(len(bodies) == 1, f'{len(bodies)} different messages returned for one key') + check(len(instances) >= 2, 'retries did not hit different replicas') + check(count_messages(chat) == 1, f'{count_messages(chat)} messages stored for one key') + via_lb = c.message(alice, chat, 'один раз', key=key)['json'] # и позже через LB — тот же ответ + check(json.dumps(via_lb, sort_keys=True) in bodies, 'later replay differs') + + +def test_same_key_concurrent_different_bodies(c: Client): + alice, _bob, _eve, chat = c.bootstrap() + urls, key = replica_urls(), uuid.uuid4().hex + path = f"/api/v1/chats/{chat['id']}/messages" + + def send(url, text): + return Client(url, timeout=15).call('POST', path, [201, 409], actor=alice, body={'text': text}, + headers={'Idempotency-Key': key}, schema='Message') + calls = [lambda u=urls[i % len(urls)], t=('A' if i % 2 else 'B'): send(u, t) for i in range(20)] + results = concurrent(calls) + check(not any(isinstance(r, Exception) for r in results), 'unexpected status in conflicting retries') + winners = {r['json']['text'] for r in results if r['status'] == 201} + check(len(winners) == 1, f'both bodies accepted for one key: {winners}') + loser_statuses = {r['status'] for r in results if r['status'] != 201} + check(loser_statuses <= {409}, 'different body must be 409') + check(sum(r['status'] == 409 for r in results) == 10, 'every other-body request must get 409') + check(count_messages(chat) == 1, 'conflicting retries stored more than one message') + + +def test_key_scope_and_format(c: Client): + alice, bob, _eve, chat = c.bootstrap() + other = c.call('POST', '/api/v1/chats', 201, actor=alice, body={'title': 'Другой', 'member_ids': [alice['id']]}, + schema='Chat')['json'] + path = f"/api/v1/chats/{chat['id']}/messages" + key = 'scope.' + uuid.uuid4().hex + ':1-x_y' # все допустимые символы + first = c.message(alice, chat, 'область', key=key)['json'] + check(c.message(bob, chat, 'область', key=key)['json']['id'] != first['id'], 'key shared between users') + check(c.message(alice, other, 'область', key=key)['json']['id'] != first['id'], 'key shared between chats') + # Семантически тот же JSON другими байтами (пробелы, \u-экранирование) — тот же ответ. + same = raw_post(BASE_URL, path, alice, b'{ "text" : "\\u043e\\u0431\\u043b\\u0430\\u0441\\u0442\\u044c" }', key) + check(same['status'] == 201 and same['json'] == first, 'semantically equal JSON was not a replay') + conflict = raw_post(BASE_URL, path, alice, json.dumps({'text': 'иначе'}).encode(), key) + check(conflict['status'] == 409 and conflict['json']['error']['code'] == 'conflict', 'expected 409 conflict') + check(c.message(alice, chat, 'область', key=key)['json'] == first, '409 must not replace stored result') + for bad in (None, '', 'has space', 'café', 'x' * 129, 'a/b'): + r = raw_post(BASE_URL, path, alice, b'{"text":"bad key"}', bad) + check(r['status'] == 400, f'invalid key {bad!r} accepted') + check(len(c.message(alice, chat, 'max', key='k' * 128)['json']['id']) == 36, '128-char key rejected') + check(count_messages(chat) == 3, 'unexpected number of messages in scope test') # alice x2, bob x1 + + +def test_replay_rechecks_session(c: Client): + alice, _bob, eve, chat = c.bootstrap() + key = uuid.uuid4().hex + c.message(alice, chat, 'до выхода', key=key) + path = f"/api/v1/chats/{chat['id']}/messages" + # Посторонний с тем же ключом не получает чужой результат. + c.call('POST', path, 404, actor=eve, body={'text': 'до выхода'}, headers={'Idempotency-Key': key}) + c.call('DELETE', '/api/v1/auth/sessions/current', 204, actor=alice) + c.call('POST', path, 401, actor=alice, body={'text': 'до выхода'}, headers={'Idempotency-Key': key}) + + +def test_transient_failure_not_recorded(c: Client): + alice, _bob, _eve, chat = c.bootstrap() + key = uuid.uuid4().hex + try: + compose('stop', 'postgres') + r = c.call('POST', f"/api/v1/chats/{chat['id']}/messages", 503, actor=alice, + body={'text': 'после сбоя'}, headers={'Idempotency-Key': key}) + check(r['json']['error']['code'] == 'unavailable', 'expected unavailable') + check(bool(r['headers'].get('X-Instance-Id')), '503 must come from API (fallback backend), not LB') + c.call('GET', '/health/live', schema='Health') + finally: + compose('start', 'postgres') + wait_ready(c) + first = c.message(alice, chat, 'после сбоя', key=key)['json'] # повтор с тем же ключом создаёт запись + check(c.message(alice, chat, 'после сбоя', key=key)['json'] == first, 'replay after recovery differs') + check(count_messages(chat) == 1, 'transient failure produced extra message') + + +def test_sigterm_drain(c: Client): + """SIGTERM: реплика сначала отвечает ready=503, но ещё обслуживает запросы, затем завершается с кодом 0.""" + alice = c.user('drain') + names = docker('ps', *API_FILTER, '--format', '{{.Names}}').split() + name = sorted(names)[0] + ip = docker('inspect', '-f', '{{(index .NetworkSettings.Networks "%s_edge").IPAddress}}' % PROJECT, name) + direct = Client(f'http://{ip}:8080', timeout=2) + docker('kill', '-s', 'TERM', name) + signalled = time.monotonic() + try: + time.sleep(0.3) + direct.call('GET', '/health/ready', 503) + direct.call('GET', '/health/live', schema='Health') + r = direct.call('GET', '/api/v1/users/me', actor=alice, schema='User') + check(r['headers'].get('Connection', '').lower() == 'close', 'draining replica must close keep-alive') + time.sleep(max(0.0, signalled + 2.0 - time.monotonic())) # окно обнаружения LB: fall 2 x 0.5-1 с + served = {c.call('GET', '/api/v1/users/me', actor=alice, schema='User')['headers']['X-Instance-Id'] + for _ in range(10)} # LB уже не отправляет на неё запросы + deadline = time.monotonic() + 20 + while docker('inspect', '-f', '{{.State.Status}}', name) != 'exited': + check(time.monotonic() < deadline, 'replica did not exit after drain') + time.sleep(0.2) + code = docker('inspect', '-f', '{{.State.ExitCode}}', name) + check(code in ('0', '143'), f'unclean exit code {code}') + hostname = docker('inspect', '-f', '{{.Config.Hostname}}', name) + check(not any(i.startswith(hostname) for i in served), 'LB still routes to the draining replica') + finally: + subprocess.run(['sh', str(ROOT / 'scripts/restore.sh')], check=True, capture_output=True) + deadline = time.monotonic() + 30 + while len({c.call('GET', '/health/live', schema='Health')['headers']['X-Instance-Id'] for _ in range(10)}) < 2: + check(time.monotonic() < deadline, 'restored replica did not return to LB') + time.sleep(0.5) + + +def test_infrastructure_rules(_c: Client): + containers = docker('ps', '--filter', f'label=com.docker.compose.project={PROJECT}', '--format', '{{.Names}}').split() + for name in containers: + cfg = json.loads(docker('inspect', name))[0] + service = cfg['Config']['Labels']['com.docker.compose.service'] + if service == 'tester': + continue + host = cfg['HostConfig'] + check(host['NanoCpus'] > 0 and host['Memory'] > 0, f'{name}: no CPU/RAM limit') + check(name.startswith(f'{PROJECT}-{service}-'), f'{name}: fixed container_name prevents scaling') + bindings = host.get('PortBindings') or {} + if service == 'lb': + check(all(b['HostIp'] == '127.0.0.1' for v in bindings.values() for b in v), 'LB published beyond loopback') + else: + check(not bindings, f'{name} publishes ports in bypass of LB') + if service == 'api': + check(cfg['HostConfig']['ReadonlyRootfs'], 'api root fs must be read-only (no local state)') + mounts = {m['Destination'] for m in cfg['Mounts']} + check(mounts <= {'/run/secrets/database_url', '/run/secrets/cache_url'}, f'api has unexpected mounts {mounts}') + check(sql('SELECT count(*) FROM schema_migrations') == '3', 'unexpected migration count') + with urllib.request.urlopen(os.environ.get('LB_STATS_URL', 'http://lb:8404/stats') + ';csv', timeout=2) as r: + text = r.read().decode() + check(',UP,' in text or ',UP ' in text, 'LB stats show no UP backend') + + +TESTS = [test_session_across_replicas, test_same_key_concurrent_across_replicas, + test_same_key_concurrent_different_bodies, test_key_scope_and_format, test_replay_rechecks_session, + test_transient_failure_not_recorded, test_sigterm_drain, test_infrastructure_rules] + + +def main() -> int: + c = Client(BASE_URL) + wait_ready(c) + failed = 0 + for test in TESTS: + started = time.monotonic() + try: + test(c) + print(f'PASS {test.__name__} ({time.monotonic() - started:.1f}s)', flush=True) + except (Failure, subprocess.CalledProcessError, OSError) as exc: + failed += 1 + print(f'FAIL {test.__name__}: {exc}', flush=True) + print(f'{len(TESTS) - failed}/{len(TESTS)} passed') + return 1 if failed else 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/tools/tester.Dockerfile b/tools/tester.Dockerfile new file mode 100644 index 00000000..7e4a2278 --- /dev/null +++ b/tools/tester.Dockerfile @@ -0,0 +1,4 @@ +# Служебный образ для запуска make check / make test / hook-скриптов из Linux на любой ОС хоста. +FROM python:3.12.12-alpine3.22 +RUN apk add --no-cache make curl docker-cli docker-cli-compose +WORKDIR /work -- 2.54.0 From 54be66fd7bac1c01c133253fda701c6ea5acfaec Mon Sep 17 00:00:00 2001 From: ZapcMihail Date: Thu, 5 Nov 2026 17:42:55 +0300 Subject: [PATCH 2/3] =?UTF-8?q?REPORT:=20=D1=81=D1=81=D1=8B=D0=BB=D0=BA?= =?UTF-8?q?=D0=B0=20=D0=BD=D0=B0=20PR?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 5.5 --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index cbf39344..39d7f10e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -2,7 +2,7 @@ - Автор, группа: Запорожец Михаил, БВТ2304 - Целевая оценка: **4** (трек 5 не заявлен) -- Commit/PR: TODO после публикации (ветка `solution/bvt2304-zaporozhets`) +- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/99 (ветка `solution/bvt2304-zaporozhets`, коммит 9555684) - Использованные источники, библиотеки и помощь ИИ: документация HAProxy 3.2 (server-template/resolvers, http-check, retry-on, observe), Docker Compose (deploy.replicas/resources, healthcheck), PostgreSQL (INSERT … ON CONFLICT, deferrable constraints, READ COMMITTED); библиотеки FastAPI 0.115, uvicorn 0.34, asyncpg 0.30, argon2-cffi 23.1, redis-py 5.2. Код, конфигурации и тесты написаны с помощью ИИ-ассистента (Claude); решения разобраны и проверены автором. ## Запуск из чистого clone -- 2.54.0 From 30b61609bee1679a35fcb9e5e3c1de5a5c202b42 Mon Sep 17 00:00:00 2001 From: ZapcMihail Date: Tue, 17 Nov 2026 12:33:28 +0300 Subject: [PATCH 3/3] =?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=20PR=20#99:=20=D1=82=D0=B5?= =?UTF-8?q?=D0=BA=D1=81=D1=82=20=D1=81=20U+0000=20=D0=B2=D0=BC=D0=B5=D1=81?= =?UTF-8?q?=D1=82=D0=BE=20500?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit PostgreSQL text не хранит 0x00. Expand-миграция 0004 добавляет *_raw bytea для messages.text, users.display_name, chats.title: точные UTF-8 байты пишутся туда, если строка содержит U+0000, API возвращает исходную строку. Тест test_nul_in_text_roundtrip: ответ, история, идемпотентный повтор, 409 на другой текст. Co-Authored-By: Claude Opus 5.5 --- REPORT.md | 6 ++++++ app/main.py | 28 +++++++++++++----------- app/pgtext.py | 22 +++++++++++++++++++ evidence/student-tests.txt | 36 ++++++++++++++++--------------- migrations/0004_nul_safe_text.sql | 7 ++++++ student-tests/test_lab3.py | 31 ++++++++++++++++++++++++-- 6 files changed, 98 insertions(+), 32 deletions(-) create mode 100644 app/pgtext.py create mode 100644 migrations/0004_nul_safe_text.sql diff --git a/REPORT.md b/REPORT.md index 39d7f10e..84933da0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -5,6 +5,12 @@ - Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/99 (ветка `solution/bvt2304-zaporozhets`, коммит 9555684) - Использованные источники, библиотеки и помощь ИИ: документация HAProxy 3.2 (server-template/resolvers, http-check, retry-on, observe), Docker Compose (deploy.replicas/resources, healthcheck), PostgreSQL (INSERT … ON CONFLICT, deferrable constraints, READ COMMITTED); библиотеки FastAPI 0.115, uvicorn 0.34, asyncpg 0.30, argon2-cffi 23.1, redis-py 5.2. Код, конфигурации и тесты написаны с помощью ИИ-ассистента (Claude); решения разобраны и проверены автором. +## Исправления по замечаниям преподавателя + +| Замечание | Причина | Исправление | Проверка | +| --- | --- | --- | --- | +| PR lab3 #99, `app/main.py:380`: `{"text":"abc\u0000def"}` с действующей сессией и новым ключом возвращает 500 вместо 201 | Тип `text` в PostgreSQL не может хранить байт 0x00, INSERT падал с ошибкой кодировки. Та же ошибка была у `display_name` и `title` чата | Миграция `migrations/0004_nul_safe_text.sql` (только expand) добавляет nullable `display_name_raw`, `title_raw`, `text_raw bytea`. Если строка содержит U+0000, в `*_raw` пишутся её точные UTF-8 байты, а в основной столбец — та же строка с U+FFFD вместо U+0000: длина не меняется, CHECK и предыдущая версия при rolling update продолжают работать. При чтении API отдаёт точную строку из `*_raw` (`app/pgtext.py`). Fingerprint идемпотентности считается по исходной строке | `test_nul_in_text_roundtrip`: 201, точный текст в ответе, в истории и в идемпотентном повторе; другой текст с тем же ключом → 409; `display_name` и `title` с NUL сохраняются точно (`evidence/student-tests.txt`) | + ## Запуск из чистого clone **Нужно:** Docker Engine/Desktop с Compose v2.20+ (проверено: Docker 29.8.2, Compose 5.6.0, Windows 11 + Docker Desktop, WSL2) и POSIX-shell (Linux/macOS или Git Bash). Для публичных проверок Python/make на хосте **не нужны** — они запускаются в сервисе `tester`. Python 3.9+ на хосте нужен только для серий отказов под нагрузкой (`student-tests/failover_series.py`), потому что rolling update создаёт контейнеры через compose с bind-путями хоста. diff --git a/app/main.py b/app/main.py index 5907a8a3..befc02a8 100644 --- a/app/main.py +++ b/app/main.py @@ -17,7 +17,7 @@ from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse, Response from starlette.exceptions import HTTPException as StarletteHTTPException -from . import config, lifecycle, validation as v +from . import config, pgtext, lifecycle, validation as v from .db import DB_UNAVAILABLE, Database from .errors import (ApiError, error_response, invalid, not_found, request_id_var, unauthorized_basic, unauthorized_bearer, unavailable) @@ -124,23 +124,23 @@ def ts(value: datetime) -> str: def user_json(row) -> dict: return {'id': str(row['id']), 'username': row['username'], - 'display_name': row['display_name'], 'created_at': ts(row['created_at'])} + 'display_name': pgtext.join(row['display_name'], row['display_name_raw']), 'created_at': ts(row['created_at'])} def chat_json(row) -> dict: - return {'id': str(row['id']), 'title': row['title'], + return {'id': str(row['id']), 'title': pgtext.join(row['title'], row['title_raw']), 'member_ids': [str(m) for m in row['member_ids']], 'created_at': ts(row['created_at'])} def message_json(row) -> dict: return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']), - 'text': row['text'], 'created_at': ts(row['created_at'])} + 'text': pgtext.join(row['text'], row['text_raw']), 'created_at': ts(row['created_at'])} -USER_COLUMNS = 'id, username, display_name, created_at' -CHAT_COLUMNS = ('c.id, c.title, c.created_at, ' +USER_COLUMNS = 'id, username, display_name, display_name_raw, created_at' +CHAT_COLUMNS = ('c.id, c.title, c.title_raw, c.created_at, ' 'ARRAY(SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id) AS member_ids') -MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, created_at' +MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, text_raw, created_at' # ---------- аутентификация ---------- @@ -206,8 +206,9 @@ async def create_user(request: Request): try: async with db.connection() as conn: row = await conn.fetchrow( - f'INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) RETURNING {USER_COLUMNS}', - username, display_name, password_hash) + 'INSERT INTO users (username, display_name, display_name_raw, password_hash) ' + f'VALUES ($1, $2, $3, $4) RETURNING {USER_COLUMNS}', + username, *pgtext.split(display_name), password_hash) except asyncpg.UniqueViolationError: # Гонка двух одинаковых регистраций решается UNIQUE-индексом: COMMIT пройдёт только у одной. raise ApiError(409, 'conflict', 'username уже занят') from None @@ -272,7 +273,8 @@ async def create_chat(request: Request): # Одна транзакция: чат и все участники появляются вместе или не появляются вовсе. async with conn.transaction(): chat = await conn.fetchrow( - 'INSERT INTO chats (title, created_by) VALUES ($1, $2) RETURNING id, created_at', title, user_id) + 'INSERT INTO chats (title, title_raw, created_by) VALUES ($1, $2, $3) RETURNING id, created_at', + *pgtext.split(title), user_id) added = await conn.fetch( 'INSERT INTO chat_members (chat_id, user_id) ' 'SELECT $1, u.id FROM users u WHERE u.id = ANY($2::uuid[]) RETURNING user_id', @@ -377,11 +379,11 @@ async def create_message(chat_id: str, request: Request): # Ключ и сообщение фиксируются одним COMMIT: при сбое не остаётся ни того, ни другого, # поэтому транзиентная 5xx не становится "окончательным" результатом ключа. row = await conn.fetchrow( - f'INSERT INTO messages (id, chat_id, sender_id, text) VALUES ($1, $2, $3, $4) ' - f'RETURNING {MESSAGE_COLUMNS}', message_id, cid, user_id, text) + f'INSERT INTO messages (id, chat_id, sender_id, text, text_raw) VALUES ($1, $2, $3, $4, $5) ' + f'RETURNING {MESSAGE_COLUMNS}', message_id, cid, user_id, *pgtext.split(text)) else: row = await conn.fetchrow( - 'SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at ' + 'SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.text_raw, m.created_at ' 'FROM idempotency_keys k JOIN messages m ON m.id = k.message_id ' 'WHERE k.user_id = $1 AND k.chat_id = $2 AND k.key = $3', user_id, cid, key) if row is None: diff --git a/app/pgtext.py b/app/pgtext.py new file mode 100644 index 00000000..fdc8baea --- /dev/null +++ b/app/pgtext.py @@ -0,0 +1,22 @@ +"""Точное хранение строк с U+0000 в PostgreSQL. + +Тип text в PostgreSQL не может содержать байт 0x00, а JSON-контракт допускает "\\u0000" в тексте +сообщения, display_name и title. Раньше такой INSERT падал с 500 (замечание к lab3, PR #99). + +Схема (только expand, совместима с предыдущей версией при rolling update): +- столбец text/display_name/title получает ту же строку, где U+0000 заменён на U+FFFD: длина в code points + не меняется, поэтому CHECK char_length и прежние реплики продолжают работать; +- столбец *_raw bytea получает точные UTF-8 байты исходной строки, но ТОЛЬКО если в ней был U+0000 + (иначе NULL, лишнего места не занимает); +- при чтении API возвращает декодированный *_raw, если он есть, иначе обычный столбец. +""" + + +def split(value: str) -> tuple[str, bytes | None]: + if '\x00' in value: + return value.replace('\x00', '\ufffd'), value.encode('utf-8') + return value, None + + +def join(text: str, raw: bytes | None) -> str: + return bytes(raw).decode('utf-8') if raw is not None else text diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt index 465238ab..3dc707e9 100644 --- a/evidence/student-tests.txt +++ b/evidence/student-tests.txt @@ -1,20 +1,22 @@ +# 2026-11-17T09:31:58Z, sh scripts/test-lab3.sh (после исправления замечания PR #99) PASS test_session_across_replicas (0.6s) -PASS test_same_key_concurrent_across_replicas (2.3s) -PASS test_same_key_concurrent_different_bodies (1.6s) -PASS test_key_scope_and_format (1.8s) -PASS test_replay_rechecks_session (1.6s) -PASS test_transient_failure_not_recorded (4.9s) -PASS test_sigterm_drain (10.0s) -PASS test_infrastructure_rules (0.4s) -8/8 passed -PASS test_wrong_password (0.8s) -PASS test_logout (0.7s) +PASS test_same_key_concurrent_across_replicas (3.1s) +PASS test_same_key_concurrent_different_bodies (2.5s) +PASS test_key_scope_and_format (2.3s) +PASS test_replay_rechecks_session (1.3s) +PASS test_transient_failure_not_recorded (6.6s) +PASS test_sigterm_drain (10.8s) +PASS test_infrastructure_rules (0.7s) +PASS test_nul_in_text_roundtrip (1.7s) +9/9 passed +PASS test_wrong_password (1.2s) +PASS test_logout (1.0s) PASS test_short_ttl (3.5s) -PASS test_username_race (3.7s) -PASS test_chat_rollback (0.9s) -PASS test_cursor_rules (1.2s) -PASS test_valkey_cache_role (1.0s) -PASS test_revoke_during_cache_partition (1.7s) -PASS test_valkey_down (4.2s) -PASS test_postgres_down (10.9s) +PASS test_username_race (4.8s) +PASS test_chat_rollback (1.0s) +PASS test_cursor_rules (1.4s) +PASS test_valkey_cache_role (1.6s) +PASS test_revoke_during_cache_partition (2.3s) +PASS test_valkey_down (4.6s) +PASS test_postgres_down (10.4s) 10/10 passed diff --git a/migrations/0004_nul_safe_text.sql b/migrations/0004_nul_safe_text.sql new file mode 100644 index 00000000..71e547e3 --- /dev/null +++ b/migrations/0004_nul_safe_text.sql @@ -0,0 +1,7 @@ +-- 0004_nul_safe_text: точное хранение строк с U+0000 (замечание к lab3, PR #99: "abc\u0000def" давал 500). +-- PostgreSQL text не хранит 0x00. Если строка содержит U+0000, её точные UTF-8 байты пишутся в *_raw, +-- а в основной столбец — та же строка с U+FFFD вместо U+0000 (см. app/pgtext.py). +-- Только expand: столбцы nullable, версия без них продолжает работать на этой схеме. +ALTER TABLE users ADD COLUMN display_name_raw bytea CHECK (octet_length(display_name_raw) <= 400); +ALTER TABLE chats ADD COLUMN title_raw bytea CHECK (octet_length(title_raw) <= 400); +ALTER TABLE messages ADD COLUMN text_raw bytea CHECK (octet_length(text_raw) <= 16000); diff --git a/student-tests/test_lab3.py b/student-tests/test_lab3.py index e71dea01..de37f455 100644 --- a/student-tests/test_lab3.py +++ b/student-tests/test_lab3.py @@ -248,15 +248,42 @@ def test_infrastructure_rules(_c: Client): check(cfg['HostConfig']['ReadonlyRootfs'], 'api root fs must be read-only (no local state)') mounts = {m['Destination'] for m in cfg['Mounts']} check(mounts <= {'/run/secrets/database_url', '/run/secrets/cache_url'}, f'api has unexpected mounts {mounts}') - check(sql('SELECT count(*) FROM schema_migrations') == '3', 'unexpected migration count') + check(sql('SELECT count(*) FROM schema_migrations') == '4', 'unexpected migration count') with urllib.request.urlopen(os.environ.get('LB_STATS_URL', 'http://lb:8404/stats') + ';csv', timeout=2) as r: text = r.read().decode() check(',UP,' in text or ',UP ' in text, 'LB stats show no UP backend') +def test_nul_in_text_roundtrip(c: Client): + """Замечание к PR #99: {"text":"abc\\u0000def"} давал 500. Строка с U+0000 сохраняется точно.""" + alice, bob, _eve, _chat = c.bootstrap() + text = 'abc\u0000def' + chat = c.call('POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'чат\u0000NUL', 'member_ids': [alice['id'], bob['id']]}, schema='Chat')['json'] + check(chat['title'] == 'чат\u0000NUL', 'title with NUL changed in response') + got = c.call('GET', '/api/v1/chats/' + chat['id'], actor=bob, schema='Chat')['json'] + check(got['title'] == 'чат\u0000NUL', 'title with NUL changed on read') + key = uuid.uuid4().hex + first = c.message(alice, chat, text, key=key)['json'] + check(first['text'] == text, 'response text differs') + replay = c.message(alice, chat, text, key=key)['json'] + check(replay == first, 'idempotent replay differs') + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, + body={'text': 'abc\ufffddef'}, headers={'Idempotency-Key': key}) # U+FFFD — другой текст + c.message(alice, chat, '\u0000') # только NUL — не пробел, допустим + history = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages', actor=bob, + schema='MessagePage')['json']['items'] + check([m['text'] for m in history] == [text, '\u0000'], 'history lost NUL') + name = 'Имя\u0000Фамилия' + user = c.call('POST', '/api/v1/users', 201, body={'username': 'nul_' + uuid.uuid4().hex[:12], + 'display_name': name, 'password': 'T3st-' + uuid.uuid4().hex}, schema='User')['json'] + check(user['display_name'] == name, 'display_name with NUL changed') + + TESTS = [test_session_across_replicas, test_same_key_concurrent_across_replicas, test_same_key_concurrent_different_bodies, test_key_scope_and_format, test_replay_rechecks_session, - test_transient_failure_not_recorded, test_sigterm_drain, test_infrastructure_rules] + test_transient_failure_not_recorded, test_sigterm_drain, test_infrastructure_rules, + test_nul_in_text_roundtrip] def main() -> int: -- 2.54.0