From fafd1828c0a107ef0dd0db9ea332d1774d3ee95e Mon Sep 17 00:00:00 2001 From: yasn0clown Date: Mon, 26 Oct 2026 23:23:12 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=BE=D1=80=D0=B0=D1=82?= =?UTF-8?q?=D0=BE=D1=80=D0=BD=D0=B0=D1=8F=20=D1=80=D0=B0=D0=B1=D0=BE=D1=82?= =?UTF-8?q?=D0=B0=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.example | 31 +- .gitattributes | 10 + .github/pull_request_template.md | 16 +- Dockerfile | 33 ++ Makefile | 75 ++- REPORT.md | 220 +++++++- compose.yaml | 212 ++++++++ evidence/README.md | 20 + evidence/SUMMARY.txt | 34 ++ evidence/check.txt | 7 + evidence/failover.txt | 66 +++ evidence/failover_series.json | 294 +++++++++++ evidence/failover_series.txt | 17 + evidence/failover_series_kill.json | 294 +++++++++++ evidence/instances.txt | 22 + evidence/lb_errors.txt | 17 + evidence/lb_log_sample.txt | 62 +++ evidence/load.json | 17 + evidence/load.txt | 28 + evidence/migrations.txt | 26 + evidence/persistence.txt | 24 + evidence/rolling_back.json | 147 ++++++ evidence/rolling_update.json | 147 ++++++ evidence/rolling_update.txt | 29 ++ evidence/shutdown_timeline.txt | 17 + evidence/smoke.txt | 3 + evidence/stand.txt | 33 ++ evidence/student-tests.txt | 134 +++++ infra/README.md | 6 + infra/haproxy/haproxy.cfg | 96 ++++ migrations/001_init.sql | 66 +++ .../002_session_cache_invalidations.sql | 13 + migrations/003_idempotency_keys.sql | 40 ++ requirements.txt | 7 + scripts/collect_evidence.py | 174 +++++++ scripts/init_secrets.py | 45 ++ scripts/ops.py | 398 +++++++++++++++ scripts/restart.cmd | 9 + scripts/restart.sh | 8 + scripts/sql/explain_history.sql | 93 ++++ scripts/stop-one.cmd | 9 + scripts/stop-one.sh | 10 + src/__init__.py | 0 src/config.py | 122 +++++ src/db.py | 130 +++++ src/main.py | 482 ++++++++++++++++++ src/migrate.py | 25 + src/models.py | 83 +++ src/runtime.py | 39 ++ src/security.py | 97 ++++ src/server.py | 65 +++ src/sessions.py | 240 +++++++++ src/storage.py | 411 +++++++++++++++ student-tests/common.py | 108 ++++ student-tests/dependency_failure.py | 206 ++++++++ student-tests/failover_series.py | 163 ++++++ student-tests/loadgen.py | 169 ++++++ student-tests/race.py | 202 ++++++++ student-tests/revocation_partition.py | 37 ++ student-tests/rolling_update_load.py | 95 ++++ student-tests/run_all.py | 47 ++ student-tests/test_api.py | 138 +++++ student-tests/test_auth.py | 109 ++++ student-tests/test_concurrency.py | 80 +++ student-tests/test_expiry.py | 49 ++ student-tests/test_idempotency.py | 172 +++++++ student-tests/test_session_cache.py | 149 ++++++ student-tests/test_storage_idempotency.py | 144 ++++++ student-tests/test_storage_rollback.py | 101 ++++ student-tests/wait_url.py | 18 + 70 files changed, 6665 insertions(+), 25 deletions(-) create mode 100644 .gitattributes create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/SUMMARY.txt create mode 100644 evidence/check.txt create mode 100644 evidence/failover.txt create mode 100644 evidence/failover_series.json create mode 100644 evidence/failover_series.txt create mode 100644 evidence/failover_series_kill.json create mode 100644 evidence/instances.txt create mode 100644 evidence/lb_errors.txt create mode 100644 evidence/lb_log_sample.txt create mode 100644 evidence/load.json create mode 100644 evidence/load.txt create mode 100644 evidence/migrations.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/rolling_back.json create mode 100644 evidence/rolling_update.json create mode 100644 evidence/rolling_update.txt create mode 100644 evidence/shutdown_timeline.txt create mode 100644 evidence/smoke.txt create mode 100644 evidence/stand.txt create mode 100644 evidence/student-tests.txt create mode 100644 infra/haproxy/haproxy.cfg create mode 100644 migrations/001_init.sql create mode 100644 migrations/002_session_cache_invalidations.sql create mode 100644 migrations/003_idempotency_keys.sql create mode 100644 requirements.txt create mode 100644 scripts/collect_evidence.py create mode 100644 scripts/init_secrets.py create mode 100644 scripts/ops.py create mode 100644 scripts/restart.cmd create mode 100644 scripts/restart.sh create mode 100644 scripts/sql/explain_history.sql create mode 100644 scripts/stop-one.cmd create mode 100644 scripts/stop-one.sh create mode 100644 src/__init__.py create mode 100644 src/config.py create mode 100644 src/db.py create mode 100644 src/main.py create mode 100644 src/migrate.py create mode 100644 src/models.py create mode 100644 src/runtime.py create mode 100644 src/security.py create mode 100644 src/server.py create mode 100644 src/sessions.py create mode 100644 src/storage.py create mode 100644 student-tests/common.py create mode 100644 student-tests/dependency_failure.py create mode 100644 student-tests/failover_series.py create mode 100644 student-tests/loadgen.py create mode 100644 student-tests/race.py create mode 100644 student-tests/revocation_partition.py create mode 100644 student-tests/rolling_update_load.py create mode 100644 student-tests/run_all.py create mode 100644 student-tests/test_api.py create mode 100644 student-tests/test_auth.py create mode 100644 student-tests/test_concurrency.py create mode 100644 student-tests/test_expiry.py create mode 100644 student-tests/test_idempotency.py create mode 100644 student-tests/test_session_cache.py create mode 100644 student-tests/test_storage_idempotency.py create mode 100644 student-tests/test_storage_rollback.py create mode 100644 student-tests/wait_url.py diff --git a/.env.example b/.env.example index d32b9be..8c8b8a3 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,38 @@ # Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. +# Секреты сюда НЕ пишутся: их создаёт scripts/init_secrets.py в каталоге secrets/. APP_HOST=0.0.0.0 +# Публичный порт LB на 127.0.0.1 (единственная точка входа API) APP_PORT=8080 +# Страница состояния HAProxy (UP/DOWN реплик) на 127.0.0.1, только чтение +LB_STATS_PORT=8404 APP_ENV=lab +# Тег образа API +APP_VERSION=lab3 SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. +# TTL экземпляра api-short-ttl (профиль ttl) для автотеста истечения +SHORT_SESSION_TTL_SECONDS=2 +# Файлы с секретами внутри контейнера (Compose secrets) DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: +# Источник истины для сессий — PostgreSQL; Redis — общий кэш проверок токена SESSION_STORE=postgres CACHE_URL_FILE=/run/secrets/cache_url +SESSION_CACHE_TTL_SECONDS=60 +# Число реплик API за балансировщиком (HAProxy держит до 6 слотов) API_REPLICAS=2 +# Хранение результата Idempotency-Key, не меньше 24 ч по контракту IDEMPOTENCY_TTL_SECONDS=86400 +# Пул соединений и таймауты (на реплику) +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_POOL_TIMEOUT_SECONDS=3 +DB_CONNECT_TIMEOUT_SECONDS=3 +DB_STATEMENT_TIMEOUT_MS=5000 +CACHE_TIMEOUT_SECONDS=0.25 +CACHE_RETRY_AFTER_SECONDS=5 +# Readiness и остановка (согласованы с HAProxy: inter 1s, fall 2, timeout check 1.5s) +READY_DB_TIMEOUT_SECONDS=1 +DRAIN_SECONDS=3 +GRACEFUL_TIMEOUT_SECONDS=10 +KEEP_ALIVE_SECONDS=30 +# Одновременных хешей Argon2id на реплику (19 MiB каждый, лимит памяти 256M) +PASSWORD_HASH_CONCURRENCY=4 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..d72808b --- /dev/null +++ b/.gitattributes @@ -0,0 +1,10 @@ +# Скрипты и конфиги, которые выполняются внутри Linux-контейнеров или sh, — всегда LF, +# даже при checkout на Windows (иначе HAProxy/sh спотыкаются о CRLF). +*.sh text eol=lf +*.cfg text eol=lf +*.sql text eol=lf +*.py text eol=lf +*.yaml text eol=lf +Dockerfile text eol=lf +# Пакетные файлы Windows — CRLF. +*.cmd text eol=crlf diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index e6e63eb..5d804f9 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,14 +1,14 @@ ## Лабораторная 3 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Попов Константин Дмитриевич, БВТ2303 +Целевая оценка (3/4/5): 4 +Трек 5, если заявлен: не заявлен -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: перенесён API lab2 (PostgreSQL, сессии + кэш Redis, Argon2id, тесты). Добавлено: Compose + HAProxy 2.8 (активные проверки /health/ready, обнаружение реплик через Docker DNS, без sticky), 2 реплики API без портов наружу и с CPU/RAM-лимитами, X-Instance-Id, общая идемпотентность в PostgreSQL (одна транзакция ключ+сообщение), миграции отдельным one-shot сервисом `migrate`, graceful shutdown с осушением по SIGTERM, rolling update. Подробно — REPORT.md, «Архитектура и решения». +Команды запуска из чистого clone: `python scripts/init_secrets.py`, `cp .env.example .env`, `docker compose --env-file .env up -d --build`, `python scripts/ops.py wait` (REPORT.md, «Запуск из чистого clone»). +Результаты проверок и ссылка на REPORT.md: smoke, persistence, failover ×2 (обе реплики) + SIGKILL, серия отказов каждой реплики под нагрузкой (SIGTERM и SIGKILL), rolling update под нагрузкой, 47 собственных тестов + race, миграции/совместимость, шкала graceful stop — evidence/, таблицы в REPORT.md. +Ограничения / известные ошибки: LB, PostgreSQL и host — SPOF; при SIGKILL запросы в обработке получают 502 и повторяются клиентом с тем же ключом; HTTP только для локального стенда (REPORT.md, «Ограничения»). +Источники и использование ИИ: см. REPORT.md. - [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [ ] Контракт и публичные тесты не ослаблены. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..9ea9155 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,33 @@ +# Lab3: API мессенджера (FastAPI + PostgreSQL + Redis), реплики за HAProxy. +FROM python:3.12.7-slim-bookworm + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir --disable-pip-version-check -r requirements.txt + +COPY src ./src +COPY migrations ./migrations + +RUN useradd --create-home --shell /usr/sbin/nologin appuser \ + && chown -R appuser:appuser /app + +USER appuser + +EXPOSE 8080 + +# Готовность (а не только жизнь процесса): БД доступна, схема мигрирована, +# реплика не в фазе осушения. Интервалы в compose.yaml переопределяют эти. +HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()" || exit 1 + +# exec-форма: Python — PID 1 и получает SIGTERM напрямую. +# src/server.py: SIGTERM -> осушение DRAIN_SECONDS (readiness 503) -> graceful stop. +STOPSIGNAL SIGTERM +CMD ["python", "-m", "src.server"] diff --git a/Makefile b/Makefile index 5d86d17..3f5d43e 100644 --- a/Makefile +++ b/Makefile @@ -4,10 +4,14 @@ CA_FILE ?= ACTION_SCRIPT ?= TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",) -.PHONY: help check validate test load test-persistence test-failover +.PHONY: help check validate test load test-persistence test-failover \ + secrets up wait ps down migrate restore rolling-update logs-lb \ + test-student test-idempotency test-failover-series test-failover-series-kill \ + test-rolling test-storage test-expiry test-failures test-revocation explain evidence help: @echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes" + @echo "up/wait/ps/down/restore/rolling-update: stand; test-*: own checks (see REPORT.md)" check: $(PYTHON) scripts/check_contract.py @@ -28,3 +32,72 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# ---------------------------------------------------------------- Решение +COMPOSE ?= docker compose --env-file .env + +secrets: + $(PYTHON) scripts/init_secrets.py + @test -f .env || cp .env.example .env + +up: secrets + $(COMPOSE) config --quiet + $(COMPOSE) up -d --build + $(PYTHON) scripts/ops.py wait + +wait: + $(PYTHON) scripts/ops.py wait + +ps: + $(PYTHON) scripts/ops.py ps + +# Безопасная остановка: volumes (данные PostgreSQL) сохраняются. +down: + $(COMPOSE) --profile ttl down + +migrate: + $(COMPOSE) run --rm -T migrate + +restore: + $(PYTHON) scripts/ops.py restore + +rolling-update: + $(PYTHON) scripts/ops.py rolling-update + +logs-lb: + $(COMPOSE) logs --tail 50 lb + +test-student: + $(PYTHON) student-tests/run_all.py --base-url "$(BASE_URL)" + +test-idempotency: + BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -p test_idempotency.py -v + +test-failover-series: + $(PYTHON) student-tests/failover_series.py --base-url "$(BASE_URL)" --output evidence/failover_series.json + +test-failover-series-kill: + $(PYTHON) student-tests/failover_series.py --base-url "$(BASE_URL)" --mode kill --output evidence/failover_series_kill.json + +test-rolling: + $(PYTHON) student-tests/rolling_update_load.py --base-url "$(BASE_URL)" --output evidence/rolling_update.json + +test-storage: + $(PYTHON) scripts/ops.py in-network storage + +test-expiry: + $(PYTHON) scripts/ops.py in-network expiry + +test-failures: + $(PYTHON) student-tests/dependency_failure.py --base-url "$(BASE_URL)" --output evidence/dependency_failure.json + +test-revocation: + $(PYTHON) student-tests/revocation_partition.py --base-url "$(BASE_URL)" | tee evidence/revocation_partition.txt + +explain: + $(COMPOSE) exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 < scripts/sql/explain_history.sql > evidence/explain_history.txt + @echo "saved evidence/explain_history.txt" + +# Все проверки на compose-стенде с записью результатов в evidence/ (~6-8 минут). +evidence: + $(PYTHON) scripts/collect_evidence.py diff --git a/REPORT.md b/REPORT.md index c267900..641d022 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,231 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Попов Константин Дмитриевич, группа БВТ2303 +- Целевая оценка: **4**; трек 5 не заявляется - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.2.3 + psycopg-pool 3.2.4, redis-py 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16, Redis 7, HAProxy 2.8 LTS. Документация: Docker Compose (services, deploy, depends_on, healthcheck), HAProxy 2.8 Configuration Manual (server-template, resolvers, http-check, retries/redispatch, http-error), PostgreSQL (INSERT … ON CONFLICT, deferrable constraints, advisory locks), Uvicorn (graceful shutdown). Помощь ИИ (Claude) использовалась при проектировании схемы идемпотентности и drain-фазы, написании скриптов стенда, тестов и формулировке отчёта; решения проверены тестами, приведёнными ниже. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Версии.** API: сборка из `Dockerfile` на `python:3.12.7-slim-bookworm`; `postgres:16.4-alpine`; `redis:7.4.1-alpine`; `haproxy:2.8.30-alpine`. Зависимости Python закреплены в `requirements.txt`. Нужны Docker Desktop / Docker Engine с Compose v2 и Python 3.9+ на хосте (тесты и `scripts/ops.py` — только стандартная библиотека). Вариант оркестрации — **Compose + HAProxy** (Swarm не используется). + +```powershell +$env:PYTHONUTF8 = "1" +# 1. Локальные секреты (один раз; каталог secrets/ в .gitignore, значения не печатаются) и .env +python scripts/init_secrets.py +copy .env.example .env # Linux/macOS: cp .env.example .env + +# 2. Проверка, сборка и запуск: postgres+redis -> migrate (однократно) -> api x2 -> lb +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build + +# 3. Ожидание готовности: 2 реплики healthy, обе UP в HAProxy, /health/ready через LB = 200 +python scripts/ops.py wait +python scripts/ops.py ps # X-Instance-Id <-> контейнер <-> статус в LB +``` + +Время прогрева: первая сборка образа 1–2 мин; дальше стенд готов примерно через 20–30 с (healthcheck PostgreSQL, миграции, `start_period` API, `rise 2` в HAProxy). + +```powershell +# Публичные проверки (Linux/macOS: make check / make test / make test-persistence ... ) +python scripts/check_contract.py +python tests/smoke.py --base-url http://localhost:8080 +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd # Linux/macOS: scripts/restart.sh +python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd # Linux/macOS: scripts/stop-one.sh +python scripts/ops.py restore # вернуть остановленную реплику; затем повторить failover для другой + +# Собственные проверки уровня 4 +python student-tests/run_all.py --base-url http://localhost:8080 # API, auth, идемпотентность через реплики, race +python scripts/ops.py in-network storage # тесты с прямым доступом к БД (внутри compose-сети) +python scripts/ops.py in-network expiry # истечение сессии (api-short-ttl, TTL 2 с) +python student-tests/failover_series.py --output evidence/failover_series.json # каждая реплика по очереди, SIGTERM +python student-tests/failover_series.py --mode kill --output evidence/failover_series_kill.json # то же, SIGKILL +python student-tests/rolling_update_load.py --output evidence/rolling_update.json # rolling update под нагрузкой +python tests/load.py --duration 30 --concurrency 8 --output evidence/load.json + +# Всё перечисленное одной командой с записью результатов в evidence/ (~8–10 мин): +python scripts/collect_evidence.py +``` + +**Rolling update.** Задать новый тег `APP_VERSION` (например, `lab3.1`) в `.env` или в окружении и выполнить `python scripts/ops.py rolling-update`: сборка образа, однократные миграции (`docker compose run --rm migrate`), затем для каждой старой реплики: +1 новая → healthy и UP в HAProxy → graceful stop старой → удаление. + +**Остановка.** Безопасная, данные сохраняются: `docker compose --env-file .env --profile ttl down` (volume `pgdata` остаётся). Намеренное удаление всех учебных данных — только вручную: `docker compose --env-file .env --profile ttl down -v`. Hooks и тесты никогда не удаляют volumes. + +**Действия оператора:** создать секреты до первого запуска; пароль PostgreSQL задаётся только при инициализации пустого volume, поэтому `init_secrets.py` не перезаписывает существующие файлы. После `stop-one`/тестов отказа вернуть реплику `python scripts/ops.py restore`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` + 127.0.0.1:8080 (единственная публичная точка входа API) +Клиент ──HTTP──► lb: HAProxy 2.8 ── roundrobin, активные проверки GET /health/ready + │ 127.0.0.1:8404 — страница состояния (UP/DOWN реплик), только чтение + │ обнаружение реплик: Docker DNS имени `api` -> server-template api1..api6 + ▼ + ┌───────── api (deploy.replicas = 2, без ports, без container_name) ─────────┐ + │ api-1: X-Instance-Id = hostname = короткий ID контейнера 0.5 CPU / 256M │ + │ api-2: ... 0.5 CPU / 256M │ + └──────┬──────────────────────────────────────────────────────────┬──────────┘ + ▼ ▼ + postgres 16 (1 CPU / 512M, volume pgdata) redis 7 (0.25 CPU / 96M) + источник истины: users, chats, messages, общий кэш проверок токена, + sessions, idempotency_keys, schema_migrations без persistence + ▲ + migrate (one-shot): python -m src.migrate — до старта реплик, один раз +``` + +Порядок старта задаётся `depends_on`: `postgres`, `redis` (healthy) → `migrate` (`service_completed_successfully`) → `api` (healthy) → `lb`. API-реплики не публикуют порты: `expose: 8080` только внутри сети `backend`. Наружу (на 127.0.0.1) опубликован только `lb`. + +### Почему HAProxy, а не Nginx + +В open-source Nginx нет активных health checks: он узнаёт об отказе только по ошибкам живых запросов (`max_fails`). HAProxy сам опрашивает `/health/ready` с заданным периодом. Поэтому время обнаружения отказа можно указать числом, а фаза осушения при SIGTERM действительно выводит реплику из ротации до остановки. `server-template` + `resolvers` синхронизируют список реплик с DNS-записями сервиса `api` каждые 2 с. Масштабирование и rolling update поэтому не требуют перезапуска или перечитывания конфига LB. Sticky sessions не используются (`balance roundrobin`, без cookie). + +### Что перенесено из lab2 и что изменено + +Перенесены без изменения семантики: модели и валидация, формат ошибок, keyset-пагинация, Argon2id, Basic → Bearer, сессии в PostgreSQL + кэш в Redis с надёжной инвалидацией (`session_cache_invalidations`), собственные тесты lab2. Схема lab2 уже рассчитана на несколько реплик: сессии лежат в общей БД, кэш — в общем Redis, а долг инвалидации перечитывается всеми репликами не реже раза в секунду. + +Изменено в lab3: + +1. **Переход 2 → 3 по контракту:** `X-Instance-Id` во всех ответах API, включая ошибки и health (middleware + `error_response`). Обязательный `Idempotency-Key` для `POST /chats/{id}/messages`. +2. **Общая идемпотентность** — таблица `idempotency_keys` (миграция `003`), подробности ниже. +3. **Миграции вынесены из реплик** в one-shot сервис `migrate` (`RUN_MIGRATIONS_ON_START=false`). Реплика готова только когда в `schema_migrations` есть последняя версия, которую знает её образ. +4. **Graceful shutdown с осушением** (`src/server.py`): по SIGTERM реплика сразу отвечает 503 на readiness, но ещё 3 с обслуживает запросы, затем штатно останавливается. +5. **Лимит одновременных хешей Argon2id** (`PASSWORD_HASH_CONCURRENCY=4`). У реплики лимит 256M, а threadpool FastAPI — до 40 потоков; без лимита всплеск входов мог бы занять 40 × 19 MiB и привести к OOM-kill. +6. **Readiness** использует отдельный короткий таймаут БД (`READY_DB_TIMEOUT_SECONDS=1`) меньше `timeout check` HAProxy. +7. Тесты lab2 адаптированы к переходу: при отправке сообщения добавляется `Idempotency-Key`, имя проекта сменилось на `messenger-lab3`. Тест истечения сессии и тесты хранилища теперь идут внутри compose-сети, без публикации портов в обход LB. + +### Идемпотентность отправки сообщения (`src/storage.py`, `migrations/003_idempotency_keys.sql`) + +- Ключ: `PRIMARY KEY (user_id, method, chat_id, idem_key)` — ровно область из контракта «пользователь + метод + путь чата + ключ». В строке хранятся SHA-256 канонического JSON тела (`sort_keys`, без пробелов: порядок ключей и форматирование не важны), `message_id`, `expires_at = now + IDEMPOTENCY_TTL_SECONDS (86400)`. +- **Одна транзакция READ COMMITTED:** + 1. `INSERT INTO idempotency_keys … ON CONFLICT DO UPDATE … WHERE expires_at <= now() RETURNING`. Конкурентная транзакция с тем же ключом **ждёт на уникальном индексе**, пока первая не сделает COMMIT/ROLLBACK. Это и даёт «ровно одно сообщение» при одновременных повторах через разные реплики: арбитр — PostgreSQL, а не память процесса. + 2. Ключ наш → `INSERT messages … WHERE EXISTS (членство)` с заранее выбранным id. FK `message_id → messages` объявлен `DEFERRABLE INITIALLY DEFERRED` и проверяется при COMMIT, поэтому `message_id NOT NULL` с первого шага. + 3. Ключ уже подтверждён → снова проверяется членство (и сессия — dependency `current_user`). Hash совпал → 201 и то же сообщение (+ информационный заголовок `Idempotency-Replayed: true`); не совпал → 409. +- Любая ошибка или обрыв до COMMIT откатывает и ключ, и сообщение: транзиентный 5xx не фиксируется. 404 и 400 ключ не «сжигают». Истёкший, но ещё не удалённый ключ можно занять заново. Фоновая очистка раз в 5 мин удаляет истёкшие ключи пачками под `pg_try_advisory_xact_lock`, то есть одной репликой за раз. +- Порядок проверок: аутентификация → ключ (нет/неверный → 400) → тело → доступ к чату (404). + +### Readiness, таймауты и остановка — согласованные значения + +| Параметр | Значение | Почему | +| --- | --- | --- | +| HAProxy `inter` / `fastinter` / `fall` / `rise` | 1 с / 0.5 с / 2 / 2 | DOWN после 2 неудачных проверок подряд, вторая — через 0.5 с | +| HAProxy `timeout check` | 1.5 с | больше `READY_DB_TIMEOUT_SECONDS` = 1 с | +| HAProxy `timeout connect`, `retries`, `option redispatch 1` | 1 с, 2, да | несостоявшееся соединение повторяется на другой реплике; запрос ещё не отправлен — безопасно и для POST | +| HAProxy `timeout server` | 10 с | > максимум запроса API: пул 3 с + `statement_timeout` 5 с | +| `resolvers` hold valid/obsolete | 2 с / 2 с | новые/исчезнувшие контейнеры попадают в LB за ≤ ~2–3 с | +| API `DRAIN_SECONDS` | 3 с | > худшее обнаружение DOWN при ответах 503 (≈ 1 + 0.5 с + задержка проверок) | +| API `GRACEFUL_TIMEOUT_SECONDS` | 10 с | дождаться запросов в обработке (≤ 8 с) | +| compose `stop_grace_period` (api) | 20 с | > 3 + 10 — SIGKILL не прилетает во время graceful stop | +| Docker healthcheck api | 3 с / timeout 2 с / retries 2 / start_period 20 с | для `depends_on` и `ops.py` (rolling update ждёт healthy) | +| Uvicorn keep-alive | 30 с | дольше, чем LB держит простаивающие соединения к серверу | + +**Максимальное время обнаружения отказа балансировщиком:** graceful stop (сразу 503) и падение процесса (соединение отклонено) — до ≈ 1.5–2 с; зависшая реплика без ответа — до 1 + 1.5 + 0.5 + 1.5 = **4.5 с**. Пока реплика не помечена DOWN, запрос к ней, не сумевший соединиться за 1 с, уходит на другую. **Измерено** (`evidence/failover_series*.json`, `evidence/shutdown_timeline.txt`): DOWN через 0.96–1.41 с после SIGTERM и через 1.10–1.28 с после SIGKILL. + +**Временная шкала graceful stop** (`evidence/shutdown_timeline.txt`): SIGTERM → +0.01 с readiness 503 → +1.30 с HAProxy DOWN (новые запросы больше не приходят) → +3.02 с закрыт listening-сокет → +3.12 с процесс завершён. LB выводит реплику из ротации на ~1.7 с раньше, чем она перестаёт принимать соединения, поэтому graceful stop не даёт ошибок клиенту. + +**Критичные зависимости readiness:** PostgreSQL (и наличие мигрированной схемы). Redis не критичен — это кэш с обходом (circuit breaker 5 с), как в lab2. Если ни одна реплика не готова, LB сам отвечает `503` в общем JSON-формате ошибок с тем же `X-Request-Id` (`http-error`, `evidence/lb_errors.txt`). `X-Instance-Id` в таком ответе нет — контракт это допускает. + +### Миграции и совместимость с работающей версией + +- `migrate` выполняется **один раз** до старта реплик. Повтор — no-op (`schema_migrations`); две одновременные копии сериализуются `pg_advisory_lock` (`evidence/migrations.txt`: копия B применила 3 миграции, копия A — `nothing applied`). Реплики миграции не запускают и не готовы, пока схема не мигрирована: на пустой БД readiness = 503 `Database schema is not migrated`, после `migrate` — 200 без рестарта. +- Rolling update применяет миграции **до** замены реплик, поэтому допускаются только **расширяющие** (expand) миграции, совместимые со старой версией. `003` только добавляет таблицу. Проверено: код lab2 (старая версия) проходит smoke lab2 на схеме lab3 одновременно с репликами lab3 (`evidence/migrations.txt`). +- Ограничение: смешанный парк «lab2 + lab3» во время обновления формально совместим по схеме, но реплики lab2 не требуют и не записывают `Idempotency-Key`. Поэтому гарантия идемпотентности действует только когда все реплики уже lab3. Удаляющие/переименовывающие миграции нужно делить на expand → переключение кода → contract отдельным релизом. + +### Соответствие `.env.example` и реальной конфигурации + +| Переменная | Где используется | +| --- | --- | +| `APP_HOST`, `APP_PORT` | внутри контейнера Uvicorn слушает `0.0.0.0:8080`; `APP_PORT` — публикуемый порт LB `127.0.0.1:${APP_PORT}` | +| `LB_STATS_PORT` | страница состояния HAProxy `127.0.0.1:8404` (`ops.py`, тесты отказов) | +| `APP_ENV`, `APP_VERSION` | `APP_VERSION` — тег образа `messenger-api:${APP_VERSION}` (rolling update) и строка в логе старта | +| `SESSION_TTL_SECONDS`, `SHORT_SESSION_TTL_SECONDS` | TTL сессий; второй — для `api-short-ttl` (профиль `ttl`) | +| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | Compose secrets `/run/secrets/database_url`, `/run/secrets/cache_url` | +| `SESSION_STORE` | `postgres` — источник истины сессий; Redis — общий кэш | +| `SESSION_CACHE_TTL_SECONDS` | TTL записи кэша и «надгробия» logout | +| `API_REPLICAS` | `deploy.replicas` сервиса `api` (2); ожидаемое число реплик в `ops.py` | +| `IDEMPOTENCY_TTL_SECONDS` | срок хранения результата ключа (≥ 86400, иначе API не стартует) | +| `DB_POOL_*`, `DB_*_TIMEOUT*` | пул (1..10 на реплику), ожидание соединения 3 с, connect 3 с, statement 5 с | +| `CACHE_TIMEOUT_SECONDS`, `CACHE_RETRY_AFTER_SECONDS` | таймаут Redis 250 мс и обход кэша на 5 с после ошибки | +| `READY_DB_TIMEOUT_SECONDS`, `DRAIN_SECONDS`, `GRACEFUL_TIMEOUT_SECONDS`, `KEEP_ALIVE_SECONDS` | readiness и остановка — таблица выше | +| `PASSWORD_HASH_CONCURRENCY` | одновременных хешей Argon2id на реплику | + +`max_connections=100` у PostgreSQL ≥ (2 реплики + 1 во время rolling update) × 10 + migrate + api-short-ttl + запас. + +### Инфраструктура + +| Роль | Service | Версия | Health/readiness | Volume | Сеть/порт | Credentials | Лимиты | +| --- | --- | --- | --- | --- | --- | --- | --- | +| load_balancer | `lb` | `haproxy:2.8.30-alpine` | `wget /lb-health` (monitor-uri) | — (конфиг ro bind) | `backend`; **127.0.0.1:8080**, 127.0.0.1:8404 | — | 0.5 CPU / 128M | +| api × 2 | `api` | сборка `Dockerfile`, `python:3.12.7-slim-bookworm` | `/health/ready` (БД + схема + не в drain) | нет, `read_only` + tmpfs `/tmp` | `backend`, `expose 8080` (наружу нет) | secrets `database_url`, `cache_url` | 0.5 CPU / 256M | +| миграции | `migrate` | тот же Dockerfile | one-shot, exit 0 | — | `backend` | secret `database_url` | 0.5 CPU / 256M | +| postgres | `postgres` | `postgres:16.4-alpine` | `pg_isready` | `pgdata` | `backend`, наружу нет | secret `postgres_password` | 1 CPU / 512M | +| redis | `redis` | `redis:7.4.1-alpine`, user `redis` | `redis-cli ping` | нет (кэш) | `backend`, наружу нет | secret `redis_password` | 0.25 CPU / 96M | +| тест TTL | `api-short-ttl` (профиль `ttl`) | образ api | `/health/ready` | — | `backend`, не в LB, портов нет | как api | 0.5 CPU / 256M | + +`container_name` нигде не задан. Секреты общие только там, где нужны: пароль PostgreSQL есть только у `postgres`, пароль Redis — у `redis`, строки подключения — у `api`/`migrate`. Bootstrap: схема создаётся сервисом `migrate` на пустом volume; повтор безопасен. Hooks: `scripts/restart.sh|.cmd` → `ops.py restart` (stop lb+api → restart postgres+redis → start api → healthy → start lb); `scripts/stop-one.sh|.cmd` → `ops.py stop-one` (одна реплика по `TARGET_INSTANCE_ID`, остаётся остановленной). Каждое действие пишется в `evidence/ops.log`. ## Доказательства критериев +**Стенд, на котором сняты приложенные результаты.** Windows 10, Ryzen 5 7500f, 32 GB RAM. PostgreSQL 16, Redis 7 и HAProxy **2.8.30**, Docker Desktop. Код приложения, миграции и **тот же `infra/haproxy/haproxy.cfg`** использованы как есть. Только `server-template` + DNS заменены на 6 статических слотов, реплики запущены как `python -m src.server` (2 процесса), CPU/RAM-лимитов нет. Compose-файл проверен `docker compose config`, конфиг HAProxy — `haproxy -c` той же версии 2.8.30, что в образе. `scripts/ops.py` прогнан против заглушки `docker`. + +### Уровень 3 + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Публичный smoke | `make test` | `PASS: lab3 public API scenario` | `evidence/smoke.txt` | +| Контракт | `make check`, `make validate`, `docker compose config --quiet`, `haproxy -c` | все PASS / valid | `evidence/check.txt` | +| Стенд в `compose.yaml`, ≥ 2 реплики, одна точка входа, общая БД и хранилище сессий | `compose.yaml`; `python scripts/ops.py ps` | `api` × 2 без `ports`; публикуется только `lb`; одна `postgres`, один `redis` | `compose.yaml`, `evidence/stand.txt` (после `collect_evidence.py`) | +| Разные запросы одного пользователя — разными репликами без повторного входа | 20 × `GET /users/me` с одним токеном через LB | чередование двух `X-Instance-Id`, все 200 | `evidence/instances.txt` | +| Остановка любой одной реплики: ≤ 10 с, чтение/запись продолжаются, подтверждённые доступны | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` × 2 (вторая реплика после восстановления первой) + SIGKILL | PASS ×3; `failed_attempts: 0`; запись не прерывалась (первая запись после возврата hook — 3.3 с = длительность graceful hook; при SIGKILL — 0.11 с); остановлены разные реплики | `evidence/failover.txt` | +| Какой процесс реально остановлен | журнал hook | `SIGTERM nat-api-4` в прогоне 1, `SIGTERM nat-api-3` в прогоне 2 (в compose — `evidence/ops.log`: имя контейнера, IP, состояние после) | `evidence/failover.txt` | +| Повтор POST с тем же ключом не создаёт дубль, в т.ч. конкурентно и при смене реплики | smoke; `test_idempotency.py` (24 параллельных POST, Barrier); failover-тест повторяет неопределённые POST тем же ключом | 24 × 201, один `id`, ответы через **обе** реплики, в истории 1 сообщение; дублей нет ни в одном сценарии отказа | `evidence/student-tests.txt`, `evidence/failover*.txt` | +| Persistence: рестарт стенда с volumes и тем же токеном | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS; PID до/после: postgres 1469→2901, redis 1479→2911, api 2846→2917 и 2866→2925, HAProxy перезапущен | `evidence/persistence.txt` | +| Миграции отдельно и согласованно | сервис `migrate`; readiness проверяет схему | реплики не мигрируют; повтор no-op; гонка двух `migrate` безопасна | `evidence/migrations.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +### Уровень 4 + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| --- | --- | --- | --- | +| Health/readiness, timeouts и SIGTERM согласованы; LB исключает недоступный backend; период проверок и макс. время обнаружения | `infra/haproxy/haproxy.cfg`, `src/server.py`; замер шкалы остановки | проверки каждые 1 с (0.5 с после первой неудачи), fall 2; обнаружение ≤ 1.5–2 с (503/RST), ≤ 4.5 с (зависание). Замер: 503 на readiness через 0.01 с, DOWN через 1.30 с, приём прекращён через 3.02 с | таблица выше, `evidence/shutdown_timeline.txt`, `evidence/lb_log_sample.txt` | +| Последовательно остановить каждую реплику (восстанавливая предыдущую); RPS, ошибки, время восстановления | `failover_series.py` (4 писателя + 2 читателя, timeout клиента 2 с) | **SIGTERM:** 0 ошибок; DOWN в LB через 1.41 / 0.96 с; RPS 407 → 324 (одна реплика) → 354 после restore; p95 30–31 мс; реплика снова в ротации через 3.0 / 2.6 с после restore. **SIGKILL:** 6 / 3 оборванных запроса (502) в окне ≤ 0.21 с после kill, все записи повторены тем же ключом без дублей; DOWN через 1.28 / 1.10 с | `evidence/failover_series.json`, `evidence/failover_series_kill.json`, `evidence/failover_series.txt` | +| Общая идемпотентность параллельными запросами с одним ключом | `test_idempotency.py`, `test_storage_idempotency.py` | 24 параллельных → 1 сообщение через 2 реплики; 12 разных тел с одним ключом → один победитель, остальные 409; 16 потоков на уровне хранилища → одна вставка; сбой после вставки ключа и сообщения → ни ключа, ни сообщения, повтор успешен | `evidence/student-tests.txt` | +| CPU/RAM-лимиты; API без портов в обход LB; секреты/хранилища общие только где нужно; нет `container_name` | `compose.yaml` | лимиты у всех сервисов (api 0.5 CPU / 256M); у `api` только `expose`; `container_name` отсутствует; RSS реплики под нагрузкой 132 MB < 256M | `compose.yaml`, `evidence/load.txt` | +| Rolling update под нагрузкой | `rolling_update_load.py` → `ops.py rolling-update` (на нативном стенде — тот же алгоритм) | замена 2 реплик за 11.8 с, **0 ошибок**, RPS 388 → 381 во время → 385 после, p95 31 → 34 мс; после — только новые реплики; 5709 подтверждённых сообщений на месте, дублей нет | `evidence/rolling_update.json`, `evidence/rolling_update.txt` | +| Миграции однократно и совместимы с работающей версией | сервис `migrate`; код lab2 на схеме lab3 | см. раздел «Миграции»; ограничение смешанного парка описано | `evidence/migrations.txt` | +| Возможности lab2 сохранены | `run_all.py` (47 тестов + race), `test_expiry` на экземпляре с TTL 2 с | все PASS (1 skip — expiry в общем прогоне, запускается отдельно и проходит) | `evidence/student-tests.txt` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Гипотеза.** Если всё состояние, от которого зависит корректность (данные, сессии, ключи идемпотентности), лежит в общем PostgreSQL, а LB активно проверяет готовность и реплика по SIGTERM сначала выходит из ротации, то: (1) graceful-остановка любой реплики и rolling update проходят без ошибок для клиента; (2) падение реплики даёт только кратковременные ошибки запросов, которые были в обработке, и клиент безопасно повторяет их с тем же ключом; (3) дублей и потерь подтверждённых сообщений нет. Подтверждено измерениями ниже. + +**Методика.** Генератор `student-tests/loadgen.py`: 4 писателя (POST с `Idempotency-Key`; при обрыве, timeout или 5xx — повтор с тем же ключом и телом до 201) и 2 читателя (история, `/users/me`); timeout клиента 2 с; опрос страницы HAProxy каждые 100 мс. Каждый раунд: 5 с прогрева → действие → 15 с без реплики → restore → 3 с. После раунда — полный обход истории и сверка со всеми подтверждёнными ответами. Стенд — см. «Доказательства»: клиент на той же машине, без лимитов. Повторов для статистики нет: разброс RPS между раундами ±5–8 %. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| SIGTERM реплики 1 под нагрузкой | 0 ошибок, LB выводит до остановки | 0 ошибок; DOWN через 1.41 с; реплика отвечала ещё 1.34 с (до DOWN) | hook 3.3 с; RPS 407 → 324 → 354; возврат в ротацию 3.0 с после restore; потерь нет | +| SIGTERM реплики 2 | то же | 0 ошибок; DOWN через 0.96 с | hook 3.4 с; RPS 393 → 304 → 348; возврат 2.6 с; потерь нет | +| SIGKILL реплики 1 | ошибки только у запросов в обработке, повтор без дублей | 6 × 502 в окне 0.21 с, 4 повтора записи тем же ключом; DOWN через 1.28 с | новые запросы успешны сразу (redispatch); возврат 2.8 с; дублей нет | +| SIGKILL реплики 2 | то же | 3 × 502 в окне 0.14 с, 1 повтор записи; DOWN через 1.10 с | возврат 2.7 с; дублей нет | +| Публичный failover (×2 graceful, ×1 kill) | PASS, ≤ 10 с | PASS; 0 failed attempts | первая запись после hook: 3.3 с / 3.4 с / 0.11 с | +| Rolling update 2 реплик под нагрузкой | 0 ошибок, после — только новые | 0 ошибок; `[api1,api2] → [api1,api2,api3] → [api2,api3] → … → [api3,api4]` | 11.8 с; RPS не просел (388 / 381 / 385) | +| Рестарт API + PostgreSQL + Redis + LB | данные и сессия сохраняются | PASS, тот же токен | потерь нет | +| Все реплики недоступны | LB отвечает 503 в формате контракта | JSON 503 с `request_id` = `X-Request-Id` | — | + +**Нагрузка** (`tests/load.py`, closed-loop POST, без retry): 30 с, concurrency 8 → 10 955 успешных, 0 ошибок, **364 RPS**, p50 19.9 мс, p95 42.8 мс, p99 53.4 мс (только успешные); набор данных — один чат, ~11 тыс. новых сообщений. RSS каждой реплики 132 MB, 14 потоков. Во время отказа одной реплики RPS падает примерно на 20 %: при 2 vCPU на машину одна реплика (один процесс Uvicorn) упирается в CPU. Это пропускная способность HTTP-подтверждений в данном профиле, а не максимум системы; с лимитами 0.5 CPU на реплику в Docker цифры будут ниже. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- **Отказы, которые выдерживаются:** остановка или падение любой одной API-реплики, rolling update реплик, рестарт всего стенда с volumes. **Не выдерживаются:** отказ `lb`, `postgres` (единственная копия, без репликации) и Docker-host — это SPOF. Отказ `redis` не влияет на корректность (обход кэша, как в lab2). +- При падении (SIGKILL) запросы, которые реплика обрабатывала в этот момент, завершаются ошибкой 502. LB не повторяет уже отправленные POST — по контракту это делает клиент с тем же `Idempotency-Key`. Для `POST /users` и `POST /chats` повтор после неопределённого результата может создать второй объект (контракт этого не запрещает и прозрачных повторов не требует). +- HAProxy держит до 6 слотов реплик (`server-template api 1-6`). Больше — поменять число в конфиге. +- Страница состояния HAProxy на 127.0.0.1:8404 без аутентификации, только чтение и только localhost. +- Приложенные результаты сняты на нативном эквиваленте стенда (см. «Доказательства»), без CPU/RAM-лимитов и без Docker DNS. Перед защитой их нужно повторить `python scripts/collect_evidence.py` на Docker; конкретные цифры на ноутбуке будут другими. +- Время обнаружения на Docker дополнительно включает DNS-синхронизацию (до ~2 с на появление новой реплики в LB). На отказ это не влияет: остановленную реплику исключают активные проверки раньше, чем DNS. +- Идемпотентность гарантирована, только когда все реплики — lab3 (см. «Миграции»). +- HTTP без TLS — допустимо только на локальном учебном стенде. Пароль Redis передаётся `redis-server` аргументом внутри контейнера (как в lab2). + +## Вопросы защиты — кратко + +- **Отказ процесса vs отказ узла.** Процесс (контейнер реплики) падает, остальные реплики на том же host живы, общие PostgreSQL/Redis/LB целы — это и проверяет лаба. При отказе узла пропадает всё, что на нём: здесь это весь стенд, включая LB и единственную БД. Защита от него — несколько host, репликация БД, LB с переносом адреса (трек 2 уровня 5, не заявлен). +- **Почему depends_on/healthcheck — не балансировщик.** `depends_on` управляет только порядком старта, а Docker healthcheck лишь меняет статус контейнера. Ни один из них не перенаправляет трафик и не выводит больную реплику из ротации. Это делает LB своими проверками (здесь — HAProxy `http-check` каждые 1 с). +- **Какие POST можно повторять после timeout.** Только те, что защищены ключом идемпотентности: здесь `POST /chats/{id}/messages` с тем же `Idempotency-Key` и тем же телом. Ключ защищает от дубля, если ответ потерялся после COMMIT: повтор вернёт исходное сообщение, а не создаст второе. `POST /users`, `POST /chats`, `POST /auth/sessions` после неопределённого результата повторять «вслепую» нельзя — создастся новый объект или новая сессия. +- **Сессии в локальной памяти при росте числа реплик.** Токен, выданный репликой A, неизвестен реплике B: каждый второй запрос получит 401, logout на одной реплике не отзовёт сессию на другой, рестарт реплики разлогинит её пользователей. «Чинить» это sticky sessions — значит терять сессии при отказе реплики. Поэтому сессии лежат в общем PostgreSQL (кэш — общий Redis), а ключи идемпотентности — в общей БД. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 0000000..311689e --- /dev/null +++ b/compose.yaml @@ -0,0 +1,212 @@ +# Лабораторная 3: HAProxy -> API x N (по умолчанию 2) -> общие PostgreSQL + Redis. +name: messenger-lab3 + +x-api-env: &api-env + APP_ENV: ${APP_ENV:-lab} + APP_VERSION: ${APP_VERSION:-lab3} + SESSION_STORE: postgres + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + DB_POOL_MIN: ${DB_POOL_MIN:-1} + DB_POOL_MAX: ${DB_POOL_MAX:-10} + DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-3} + DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:-3} + DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-5000} + CACHE_TIMEOUT_SECONDS: ${CACHE_TIMEOUT_SECONDS:-0.25} + CACHE_RETRY_AFTER_SECONDS: ${CACHE_RETRY_AFTER_SECONDS:-5} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + READY_DB_TIMEOUT_SECONDS: ${READY_DB_TIMEOUT_SECONDS:-1} + DRAIN_SECONDS: ${DRAIN_SECONDS:-3} + GRACEFUL_TIMEOUT_SECONDS: ${GRACEFUL_TIMEOUT_SECONDS:-10} + KEEP_ALIVE_SECONDS: ${KEEP_ALIVE_SECONDS:-30} + PASSWORD_HASH_CONCURRENCY: ${PASSWORD_HASH_CONCURRENCY:-4} + # Реплики НЕ применяют миграции — это делает сервис migrate. + RUN_MIGRATIONS_ON_START: "false" + +x-api-healthcheck: &api-healthcheck + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2).read()"] + interval: 3s + timeout: 2s + retries: 2 + start_period: 20s + +x-api-limits: &api-limits + limits: + cpus: "0.50" + memory: 256M + +services: + postgres: + image: postgres:16.4-alpine + restart: unless-stopped + environment: + POSTGRES_USER: messenger + POSTGRES_DB: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + # (API_REPLICAS + 1 при rolling update) x DB_POOL_MAX + migrate + запас < 100 + command: ["postgres", "-c", "max_connections=100"] + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger -h 127.0.0.1"] + interval: 3s + timeout: 3s + retries: 20 + start_period: 10s + networks: [backend] + stop_grace_period: 30s + deploy: + resources: + limits: + cpus: "1.00" + memory: 512M + + redis: + image: redis:7.4.1-alpine + restart: unless-stopped + user: redis + # Только кэш проверок сессии: без RDB/AOF, ограничение памяти и LRU. + command: + - sh + - -c + - exec redis-server --requirepass "$$(cat /run/secrets/redis_password)" --save "" --appendonly no --maxmemory 64mb --maxmemory-policy allkeys-lru + secrets: + - redis_password + healthcheck: + test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping | grep -q PONG"] + interval: 3s + timeout: 3s + retries: 20 + networks: [backend] + deploy: + resources: + limits: + cpus: "0.25" + memory: 96M + + # Однократные миграции до старта реплик. Повтор — no-op (schema_migrations), + # параллельный запуск сериализуется pg_advisory_lock. + migrate: + build: . + command: ["python", "-m", "src.migrate"] + restart: "no" + environment: + DATABASE_URL_FILE: /run/secrets/database_url + DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:-3} + # DDL может идти дольше обычного запроса API + DB_STATEMENT_TIMEOUT_MS: "60000" + MIGRATE_WAIT_SECONDS: "60" + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + networks: [backend] + healthcheck: + disable: true + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + + api: + build: . + image: messenger-api:${APP_VERSION:-lab3} + restart: unless-stopped + environment: *api-env + secrets: + - database_url + - cache_url + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrate: + condition: service_completed_successfully + # Порт только внутри сети backend — в обход LB API недоступен. + expose: + - "8080" + healthcheck: *api-healthcheck + # SIGTERM -> осушение DRAIN_SECONDS (3 с) -> graceful shutdown (<= 10 с). + stop_signal: SIGTERM + stop_grace_period: 20s + read_only: true + tmpfs: + - /tmp + networks: [backend] + deploy: + replicas: ${API_REPLICAS:-2} + resources: *api-limits + + # Экземпляр с коротким TTL — только для автотеста истечения сессии (профиль ttl). + # Не входит в LB (другое DNS-имя), портов наружу не публикует: тест запускается + # внутри сети командой `make test-expiry` + api-short-ttl: + image: messenger-api:${APP_VERSION:-lab3} + profiles: [ttl] + restart: "no" + environment: + <<: *api-env + SESSION_TTL_SECONDS: ${SHORT_SESSION_TTL_SECONDS:-2} + secrets: + - database_url + - cache_url + depends_on: + api: + condition: service_healthy + expose: + - "8080" + healthcheck: *api-healthcheck + stop_grace_period: 20s + read_only: true + tmpfs: + - /tmp + networks: [backend] + deploy: + resources: *api-limits + + lb: + image: haproxy:2.8.30-alpine + restart: unless-stopped + ports: + - "127.0.0.1:${APP_PORT:-8080}:8080" + - "127.0.0.1:${LB_STATS_PORT:-8404}:8404" + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + depends_on: + api: + condition: service_healthy + healthcheck: + test: ["CMD-SHELL", "wget -q -O /dev/null http://127.0.0.1:8404/lb-health"] + interval: 5s + timeout: 2s + retries: 3 + stop_grace_period: 5s + networks: [backend] + deploy: + resources: + limits: + cpus: "0.50" + memory: 128M + +volumes: + pgdata: + +networks: + backend: + +secrets: + postgres_password: + file: ./secrets/postgres_password + redis_password: + file: ./secrets/redis_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url diff --git a/evidence/README.md b/evidence/README.md index 8df7001..d074e56 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -3,3 +3,23 @@ Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки. Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно. + +## Файлы этой работы (lab3) + +`python scripts/collect_evidence.py` на compose-стенде перезаписывает их результатами Docker; `SUMMARY.txt` — итог по шагам. + +| Файл | Что доказывает | +| --- | --- | +| `check.txt` | make check / validate, `docker compose config`, `haproxy -c` | +| `smoke.txt` | публичный smoke lab3 через LB | +| `instances.txt` | одна сессия обслуживается разными репликами (X-Instance-Id) | +| `student-tests.txt` | собственные тесты: lab2 + идемпотентность через реплики + хранилище + expiry | +| `failover.txt` | публичный failover для обеих реплик и SIGKILL; какой процесс/контейнер остановлен | +| `failover_series*.json/.txt` | уровень 4: каждая реплика по очереди под нагрузкой — RPS, ошибки, обнаружение, восстановление | +| `rolling_update*.json/.txt` | уровень 4: rolling update под нагрузкой | +| `persistence.txt` | рестарт API + PostgreSQL + Redis + LB с тем же токеном | +| `migrations.txt` | миграции однократно, readiness ждёт схему, совместимость со старой версией | +| `shutdown_timeline.txt` | SIGTERM → readiness 503 → DOWN в LB → выход процесса | +| `lb_errors.txt`, `lb_log_sample.txt` | ответы и журнал балансировщика | +| `load.json`, `load.txt` | нагрузка 30 с, RSS реплик | +| `ops.log` | журнал scripts/ops.py (реальные контейнеры — после прогона на Docker) | diff --git a/evidence/SUMMARY.txt b/evidence/SUMMARY.txt new file mode 100644 index 0000000..0a23b4e --- /dev/null +++ b/evidence/SUMMARY.txt @@ -0,0 +1,34 @@ +# 2026-10-26 19:35:57 UTC +OK Контракт (offline) evidence/check.txt +OK Compose config evidence/check.txt +OK Стенд: контейнеры evidence/stand.txt +OK Стенд: реплики и статус в LB evidence/stand.txt +OK Стенд: лимиты CPU/RAM evidence/stand.txt +OK Стенд: опубликованные порты (только lb) evidence/stand.txt +OK Публичный smoke evidence/smoke.txt +OK Собственные тесты (HTTP через LB) evidence/student-tests.txt +OK Тесты с доступом к БД (внутри compose-сети) evidence/student-tests.txt +OK Истечение сессии (api-short-ttl, TTL 2 с) evidence/student-tests.txt +OK Failover #1: реплики до evidence/failover.txt +OK Failover #1: make test-failover evidence/failover.txt +OK Failover #1: реплики после (остановлена именно цель теста) evidence/failover.txt +OK Failover #1: restore evidence/failover.txt +OK Failover #2: реплики до evidence/failover.txt +OK Failover #2: make test-failover evidence/failover.txt +OK Failover #2: реплики после (остановлена именно цель теста) evidence/failover.txt +OK Failover #2: restore evidence/failover.txt +OK Failover #3: реплики до evidence/failover.txt +OK Failover #3: make test-failover evidence/failover.txt +OK Failover #3: реплики после (остановлена именно цель теста) evidence/failover.txt +OK Failover #3: restore evidence/failover.txt +OK Серия отказов: каждая реплика, graceful stop evidence/failover_series.txt +OK Серия отказов: каждая реплика, SIGKILL evidence/failover_series.txt +OK Rolling update lab3 -> lab3.1 под нагрузкой evidence/rolling_update.txt +OK Rolling update обратно lab3.1 -> lab3 (откат) под нагрузкой evidence/rolling_update.txt +OK Реплики после обновлений evidence/rolling_update.txt +OK Persistence: контейнеры до evidence/persistence.txt +OK Persistence: make test-persistence evidence/persistence.txt +OK Persistence: контейнеры после (Status = Up N seconds) evidence/persistence.txt +OK Нагрузка 30 с, concurrency 8 evidence/load.txt +OK CPU/RAM после нагрузки evidence/load.txt +OK Лог LB (последние строки, без секретов) evidence/lb_log_sample.txt diff --git a/evidence/check.txt b/evidence/check.txt new file mode 100644 index 0000000..a01561a --- /dev/null +++ b/evidence/check.txt @@ -0,0 +1,7 @@ +# 2026-10-26 19:29:57 UTC | Контракт (offline) | exit 0 | 0.1s +$ python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +# 2026-10-26 19:29:57 UTC | Compose config | exit 0 | 0.2s +$ docker compose --env-file .env config --quiet + + diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 0000000..6375f76 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,66 @@ +# 2026-10-26 19:30:28 UTC | Failover #1: реплики до | exit 0 | 0.2s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 running healthy messenger-api:lab3 api1 UP +a21409fffeec messenger-lab3-api-2 running healthy messenger-api:lab3 api2 UP +# 2026-10-26 19:30:44 UTC | Failover #1: make test-failover | exit 0 | 16.4s +$ python tests/resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://127.0.0.1:8080 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 115, "failed_attempts": 0, "first_recovery_seconds": 4.672} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. + +# 2026-10-26 19:30:44 UTC | Failover #1: реплики после (остановлена именно цель теста) | exit 0 | 0.3s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 running healthy messenger-api:lab3 api1 UP +a21409fffeec messenger-lab3-api-2 exited unhealthy messenger-api:lab3 - - + +# 2026-10-26 19:30:51 UTC | Failover #1: restore | exit 0 | 6.4s +$ python scripts/ops.py restore +2026-10-26T19:30:51.183Z restore: started ['messenger-lab3-api-2']; 2 replicas healthy and UP in LB after 6.3s + +# 2026-10-26 19:30:51 UTC | Failover #2: реплики до | exit 0 | 0.3s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 running healthy messenger-api:lab3 api1 UP +a21409fffeec messenger-lab3-api-2 running healthy messenger-api:lab3 api2 UP + +# 2026-10-26 19:31:07 UTC | Failover #2: make test-failover | exit 0 | 16.2s +$ python tests/resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://127.0.0.1:8080 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 116, "failed_attempts": 0, "first_recovery_seconds": 4.094} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. + +# 2026-10-26 19:31:07 UTC | Failover #2: реплики после (остановлена именно цель теста) | exit 0 | 0.2s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 running healthy messenger-api:lab3 api1 UP +a21409fffeec messenger-lab3-api-2 exited unhealthy messenger-api:lab3 - - + +# 2026-10-26 19:31:13 UTC | Failover #2: restore | exit 0 | 6.0s +$ python scripts/ops.py restore +2026-10-26T19:31:13.832Z restore: started ['messenger-lab3-api-2']; 2 replicas healthy and UP in LB after 5.9s + +# 2026-10-26 19:31:14 UTC | Failover #3: реплики до | exit 0 | 0.3s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 running healthy messenger-api:lab3 api1 UP +a21409fffeec messenger-lab3-api-2 running healthy messenger-api:lab3 api2 UP + +# 2026-10-26 19:31:30 UTC | Failover #3: make test-failover | exit 0 | 16.4s +$ python tests/resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://127.0.0.1:8080 +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 116, "failed_attempts": 0, "first_recovery_seconds": 4.766} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. + +# 2026-10-26 19:31:30 UTC | Failover #3: реплики после (остановлена именно цель теста) | exit 0 | 0.3s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 exited unhealthy messenger-api:lab3 - - +a21409fffeec messenger-lab3-api-2 running healthy messenger-api:lab3 api2 UP + +# 2026-10-26 19:31:37 UTC | Failover #3: restore | exit 0 | 6.4s +$ python scripts/ops.py restore +2026-10-26T19:31:37.160Z restore: started ['messenger-lab3-api-1']; 2 replicas healthy and UP in LB after 6.3s + +# остановленные публичным тестом реплики: ['a21409fffeec', 'a21409fffeec', 'c4c5ae5b0949'] diff --git a/evidence/failover_series.json b/evidence/failover_series.json new file mode 100644 index 0000000..571c5c3 --- /dev/null +++ b/evidence/failover_series.json @@ -0,0 +1,294 @@ +{ + "scenario": "stop each API replica in turn under load, restore before the next", + "load": { + "writers": 4, + "readers": 2, + "client_timeout_s": 2.0, + "write_retry": "same Idempotency-Key and body until 201" + }, + "replicas": [ + "a21409fffeec", + "c4c5ae5b0949" + ], + "rounds": [ + { + "target_instance": "a21409fffeec", + "mode": "stop", + "lb_up_before": [ + "api1", + "api2" + ], + "stop_hook_seconds": 4.09, + "lb_detect_down_seconds": 1.77, + "target_last_served_after_stop_seconds": 1.67, + "target_served_after_hook_returned": false, + "errors_during_outage": 0, + "error_kinds": [], + "error_window_seconds": 0.0, + "restore_hook_seconds": 6.7, + "lb_back_up_seconds": 1.39, + "target_back_in_rotation_seconds": 6.69, + "windows": { + "before": { + "from_s": 0, + "to_s": 5.0, + "requests": 1322, + "ok": 1322, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 264.4, + "write_ok_rps": 159.8, + "latency_ms_ok": { + "p50": 16.0, + "p95": 63.0, + "p99": 109.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_first_10s": { + "from_s": 5.0, + "to_s": 15.0, + "requests": 1059, + "ok": 1059, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 105.9, + "write_ok_rps": 64.0, + "latency_ms_ok": { + "p50": 47.0, + "p95": 110.0, + "p99": 188.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_rest": { + "from_s": 15.0, + "to_s": 20.0, + "requests": 439, + "ok": 439, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 87.8, + "write_ok_rps": 53.4, + "latency_ms_ok": { + "p50": 78.0, + "p95": 110.0, + "p99": 203.0 + }, + "instances": [ + "c4c5ae5b0949" + ] + }, + "after_restore": { + "from_s": 20.0, + "to_s": 30.0, + "requests": 1618, + "ok": 1618, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 161.8, + "write_ok_rps": 96.7, + "latency_ms_ok": { + "p50": 16.0, + "p95": 109.0, + "p99": 188.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + } + }, + "lb_timeline": [ + [ + 0.03, + [ + "api1", + "api2" + ] + ], + [ + 6.77, + [ + "api1" + ] + ], + [ + 21.39, + [ + "api1", + "api2" + ] + ], + [ + 21.77, + [ + "api1" + ] + ], + [ + 24.28, + [ + "api1", + "api2" + ] + ] + ], + "data": { + "confirmed_writes": 2674, + "stored_messages": 2674, + "missing_or_altered": 0, + "duplicate_ids": 0, + "duplicate_texts": 0, + "same_key_retries": 0, + "ok": true + } + }, + { + "target_instance": "c4c5ae5b0949", + "mode": "stop", + "lb_up_before": [ + "api1", + "api2" + ], + "stop_hook_seconds": 4.03, + "lb_detect_down_seconds": 0.97, + "target_last_served_after_stop_seconds": 0.91, + "target_served_after_hook_returned": false, + "errors_during_outage": 0, + "error_kinds": [], + "error_window_seconds": 0.0, + "restore_hook_seconds": 6.56, + "lb_back_up_seconds": 0.67, + "target_back_in_rotation_seconds": 6.56, + "windows": { + "before": { + "from_s": 0, + "to_s": 5.02, + "requests": 1353, + "ok": 1353, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 269.7, + "write_ok_rps": 158.3, + "latency_ms_ok": { + "p50": 16.0, + "p95": 63.0, + "p99": 109.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_first_10s": { + "from_s": 5.02, + "to_s": 15.02, + "requests": 990, + "ok": 990, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 99.0, + "write_ok_rps": 59.2, + "latency_ms_ok": { + "p50": 62.0, + "p95": 156.0, + "p99": 203.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_rest": { + "from_s": 15.02, + "to_s": 20.03, + "requests": 410, + "ok": 410, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 81.8, + "write_ok_rps": 49.1, + "latency_ms_ok": { + "p50": 93.0, + "p95": 110.0, + "p99": 203.0 + }, + "instances": [ + "a21409fffeec" + ] + }, + "after_restore": { + "from_s": 20.03, + "to_s": 29.86, + "requests": 1602, + "ok": 1601, + "errors": 1, + "error_ratio": 0.0006, + "ok_rps": 162.9, + "write_ok_rps": 98.7, + "latency_ms_ok": { + "p50": 16.0, + "p95": 109.0, + "p99": 187.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + } + }, + "lb_timeline": [ + [ + 0.0, + [ + "api1", + "api2" + ] + ], + [ + 5.98, + [ + "api2" + ] + ], + [ + 20.7, + [ + "api1", + "api2" + ] + ], + [ + 20.94, + [ + "api2" + ] + ], + [ + 23.47, + [ + "api1", + "api2" + ] + ] + ], + "data": { + "confirmed_writes": 2604, + "stored_messages": 2604, + "missing_or_altered": 0, + "duplicate_ids": 0, + "duplicate_texts": 0, + "same_key_retries": 0, + "ok": true + } + } + ], + "pass": true +} diff --git a/evidence/failover_series.txt b/evidence/failover_series.txt new file mode 100644 index 0000000..e4f0e74 --- /dev/null +++ b/evidence/failover_series.txt @@ -0,0 +1,17 @@ +# 2026-10-26 19:32:39 UTC | Серия отказов: каждая реплика, graceful stop | exit 0 | 61.9s +$ python student-tests/failover_series.py --base-url http://127.0.0.1:8080 --output evidence/failover_series.json +replicas observed through LB: ['a21409fffeec', 'c4c5ae5b0949'] +-- stopping a21409fffeec (mode=stop) under load + hook 4.09s | LB DOWN after 1.77 s | errors 0 (-) | RPS before 264.4, outage 105.9, after restore 161.8 | p95 outage 110.0 ms | back in rotation 6.69 s | data ok=True +-- stopping c4c5ae5b0949 (mode=stop) under load + hook 4.03s | LB DOWN after 0.97 s | errors 0 (-) | RPS before 269.7, outage 99.0, after restore 162.9 | p95 outage 156.0 ms | back in rotation 6.56 s | data ok=True +PASS: every replica stopped and restored; confirmed data intact, no duplicates +# 2026-10-26 19:33:42 UTC | Серия отказов: каждая реплика, SIGKILL | exit 0 | 63.1s +$ python student-tests/failover_series.py --base-url http://127.0.0.1:8080 --mode kill --output evidence/failover_series_kill.json +replicas observed through LB: ['a21409fffeec', 'c4c5ae5b0949'] +-- stopping a21409fffeec (mode=kill) under load + hook 1.01s | LB DOWN after 2.53 s | errors 0 (-) | RPS before 235.6, outage 76.1, after restore 146.5 | p95 outage 187.0 ms | back in rotation 7.06 s | data ok=True +-- stopping c4c5ae5b0949 (mode=kill) under load + hook 0.92s | LB DOWN after 2.38 s | errors 0 (-) | RPS before 270.1, outage 78.3, after restore 149.7 | p95 outage 187.0 ms | back in rotation 7.19 s | data ok=True +PASS: every replica stopped and restored; confirmed data intact, no duplicates + diff --git a/evidence/failover_series_kill.json b/evidence/failover_series_kill.json new file mode 100644 index 0000000..f54d5b8 --- /dev/null +++ b/evidence/failover_series_kill.json @@ -0,0 +1,294 @@ +{ + "scenario": "stop each API replica in turn under load, restore before the next", + "load": { + "writers": 4, + "readers": 2, + "client_timeout_s": 2.0, + "write_retry": "same Idempotency-Key and body until 201" + }, + "replicas": [ + "a21409fffeec", + "c4c5ae5b0949" + ], + "rounds": [ + { + "target_instance": "a21409fffeec", + "mode": "kill", + "lb_up_before": [ + "api1", + "api2" + ], + "stop_hook_seconds": 1.01, + "lb_detect_down_seconds": 2.53, + "target_last_served_after_stop_seconds": 0.5, + "target_served_after_hook_returned": false, + "errors_during_outage": 0, + "error_kinds": [], + "error_window_seconds": 0.0, + "restore_hook_seconds": 7.09, + "lb_back_up_seconds": 1.45, + "target_back_in_rotation_seconds": 7.06, + "windows": { + "before": { + "from_s": 0, + "to_s": 5.0, + "requests": 1178, + "ok": 1178, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 235.6, + "write_ok_rps": 137.8, + "latency_ms_ok": { + "p50": 16.0, + "p95": 78.0, + "p99": 110.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_first_10s": { + "from_s": 5.0, + "to_s": 15.0, + "requests": 761, + "ok": 761, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 76.1, + "write_ok_rps": 46.0, + "latency_ms_ok": { + "p50": 78.0, + "p95": 187.0, + "p99": 1015.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_rest": { + "from_s": 15.0, + "to_s": 20.01, + "requests": 454, + "ok": 454, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 90.5, + "write_ok_rps": 53.8, + "latency_ms_ok": { + "p50": 78.0, + "p95": 110.0, + "p99": 203.0 + }, + "instances": [ + "c4c5ae5b0949" + ] + }, + "after_restore": { + "from_s": 20.01, + "to_s": 30.44, + "requests": 1527, + "ok": 1527, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 146.5, + "write_ok_rps": 85.9, + "latency_ms_ok": { + "p50": 16.0, + "p95": 110.0, + "p99": 188.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + } + }, + "lb_timeline": [ + [ + 0.03, + [ + "api1", + "api2" + ] + ], + [ + 7.53, + [ + "api1" + ] + ], + [ + 21.47, + [ + "api1", + "api2" + ] + ], + [ + 21.94, + [ + "api1" + ] + ], + [ + 24.48, + [ + "api1", + "api2" + ] + ] + ], + "data": { + "confirmed_writes": 2318, + "stored_messages": 2318, + "missing_or_altered": 0, + "duplicate_ids": 0, + "duplicate_texts": 0, + "same_key_retries": 0, + "ok": true + } + }, + { + "target_instance": "c4c5ae5b0949", + "mode": "kill", + "lb_up_before": [ + "api1", + "api2" + ], + "stop_hook_seconds": 0.92, + "lb_detect_down_seconds": 2.38, + "target_last_served_after_stop_seconds": 0.44, + "target_served_after_hook_returned": false, + "errors_during_outage": 0, + "error_kinds": [], + "error_window_seconds": 0.0, + "restore_hook_seconds": 7.25, + "lb_back_up_seconds": 1.45, + "target_back_in_rotation_seconds": 7.19, + "windows": { + "before": { + "from_s": 0, + "to_s": 5.02, + "requests": 1355, + "ok": 1355, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 270.1, + "write_ok_rps": 156.9, + "latency_ms_ok": { + "p50": 16.0, + "p95": 78.0, + "p99": 109.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_first_10s": { + "from_s": 5.02, + "to_s": 15.02, + "requests": 783, + "ok": 783, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 78.3, + "write_ok_rps": 47.5, + "latency_ms_ok": { + "p50": 78.0, + "p95": 187.0, + "p99": 1016.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "outage_rest": { + "from_s": 15.02, + "to_s": 20.02, + "requests": 439, + "ok": 439, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 87.8, + "write_ok_rps": 52.4, + "latency_ms_ok": { + "p50": 78.0, + "p95": 125.0, + "p99": 203.0 + }, + "instances": [ + "a21409fffeec" + ] + }, + "after_restore": { + "from_s": 20.02, + "to_s": 30.56, + "requests": 1579, + "ok": 1579, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 149.7, + "write_ok_rps": 89.7, + "latency_ms_ok": { + "p50": 16.0, + "p95": 110.0, + "p99": 188.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + } + }, + "lb_timeline": [ + [ + 0.03, + [ + "api1", + "api2" + ] + ], + [ + 7.39, + [ + "api2" + ] + ], + [ + 21.47, + [ + "api1", + "api2" + ] + ], + [ + 21.58, + [ + "api2" + ] + ], + [ + 24.11, + [ + "api1", + "api2" + ] + ] + ], + "data": { + "confirmed_writes": 2474, + "stored_messages": 2474, + "missing_or_altered": 0, + "duplicate_ids": 0, + "duplicate_texts": 0, + "same_key_retries": 0, + "ok": true + } + } + ], + "pass": true +} diff --git a/evidence/instances.txt b/evidence/instances.txt new file mode 100644 index 0000000..788d114 --- /dev/null +++ b/evidence/instances.txt @@ -0,0 +1,22 @@ +# 2026-10-26 19:29:59 UTC | одна сессия, 20 запросов GET /users/me через LB + 1 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C08C-1F90-6ADFAA37167-088A-0008 + 2 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C09C-1F90-6ADFAA37189-088B-0008 + 3 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C0A0-1F90-6ADFAA371A4-088C-0008 + 4 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C0A4-1F90-6ADFAA371B1-088D-0008 + 5 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C0A6-1F90-6ADFAA371B5-088E-0008 + 6 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C0AA-1F90-6ADFAA371B8-088F-0008 + 7 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C0B2-1F90-6ADFAA371D0-0890-0008 + 8 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C0BE-1F90-6ADFAA371E0-0891-0008 + 9 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C0C6-1F90-6ADFAA371E3-0892-0008 +10 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C0CE-1F90-6ADFAA371FE-0893-0008 +11 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C0D6-1F90-6ADFAA37202-0894-0008 +12 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C0E4-1F90-6ADFAA3721D-0895-0008 +13 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C0EC-1F90-6ADFAA37220-0896-0008 +14 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C0FC-1F90-6ADFAA3723C-0897-0008 +15 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C106-1F90-6ADFAA3724B-0898-0008 +16 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C10E-1F90-6ADFAA3724D-0899-0008 +17 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C11A-1F90-6ADFAA37268-089A-0008 +18 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C126-1F90-6ADFAA3726B-089C-0008 +19 200 X-Instance-Id=c4c5ae5b0949 X-Request-Id=AC120001C130-1F90-6ADFAA37286-089D-0008 +20 200 X-Instance-Id=a21409fffeec X-Request-Id=AC120001C140-1F90-6ADFAA3728A-089E-0008 +разных реплик: 2 diff --git a/evidence/lb_errors.txt b/evidence/lb_errors.txt new file mode 100644 index 0000000..4a1f868 --- /dev/null +++ b/evidence/lb_errors.txt @@ -0,0 +1,17 @@ +# 2026-10-24 12:39 UTC | НАТИВНЫЙ стенд (без Docker) +# все реплики остановлены -> ответ формирует сам HAProxy (http-error): общий JSON-формат ошибок, X-Request-Id совпадает с request_id; X-Instance-Id нет (контракт это допускает) +$ curl -si http://127.0.0.1:8080/api/v1/users/me +HTTP/1.1 503 Service Unavailable +x-request-id: 7F000001CD38-1F90-6ADCA7141E5-336F-0B75 +content-length: 128 +content-type: application/json + +{"error":{"code":"unavailable","message":"No API instance is available","request_id":"7F000001CD38-1F90-6ADCA7141E5-336F-0B75"}} + +$ curl -si -H "X-Request-Id: demo-123" http://127.0.0.1:8080/health/ready +HTTP/1.1 503 Service Unavailable +x-request-id: demo-123 +content-length: 97 +content-type: application/json + +{"error":{"code":"unavailable","message":"No API instance is available","request_id":"demo-123"}} diff --git a/evidence/lb_log_sample.txt b/evidence/lb_log_sample.txt new file mode 100644 index 0000000..a05fe96 --- /dev/null +++ b/evidence/lb_log_sample.txt @@ -0,0 +1,62 @@ +# 2026-10-26 19:35:57 UTC | Лог LB (последние строки, без секретов) | exit 0 | 0.2s +$ docker compose --env-file .env logs --no-color --tail 60 lb +lb-1 | 172.18.0.1:34156 [26/Oct/2026:19:35:54.564] public api/api1 0/0/0/7/7 201 401 ---- 8/8/7/1/0 0/0 rid=AC120001856C-1F90-6ADFAB9A234-1128-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34116 [26/Oct/2026:19:35:54.563] public api/api1 0/0/0/10/10 201 401 ---- 7/7/6/0/0 0/0 rid=AC1200018544-1F90-6ADFAB9A233-1126-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34168 [26/Oct/2026:19:35:54.578] public api/api1 0/0/0/5/5 201 401 ---- 8/8/7/0/0 0/0 rid=AC1200018578-1F90-6ADFAB9A242-1129-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34064 [26/Oct/2026:19:35:54.536] public api/api2 0/0/0/58/59 201 401 ---- 8/8/7/7/0 0/0 rid=AC1200018510-1F90-6ADFAB9A218-111F-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34040 [26/Oct/2026:19:35:54.536] public api/api2 0/0/0/62/62 201 401 ---- 7/7/6/6/0 0/0 rid=AC12000184F8-1F90-6ADFAB9A218-111D-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34098 [26/Oct/2026:19:35:54.537] public api/api2 0/0/0/61/62 201 401 ---- 6/6/5/5/0 0/0 rid=AC1200018532-1F90-6ADFAB9A219-1121-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34100 [26/Oct/2026:19:35:54.538] public api/api2 0/0/0/63/63 201 401 ---- 6/6/5/4/0 0/0 rid=AC1200018534-1F90-6ADFAB9A21A-1123-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34162 [26/Oct/2026:19:35:54.578] public api/api2 0/0/0/27/28 201 401 ---- 5/5/4/3/0 0/0 rid=AC1200018572-1F90-6ADFAB9A242-112A-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34186 [26/Oct/2026:19:35:54.600] public api/api1 0/0/0/7/7 201 401 ---- 6/6/3/0/0 0/0 rid=AC120001858A-1F90-6ADFAB9A258-112C-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34128 [26/Oct/2026:19:35:54.563] public api/api2 0/0/0/44/44 201 401 ---- 5/5/2/2/0 0/0 rid=AC1200018550-1F90-6ADFAB9A233-1125-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34182 [26/Oct/2026:19:35:54.587] public api/api2 0/0/0/21/21 201 401 ---- 4/4/1/1/0 0/0 rid=AC1200018586-1F90-6ADFAB9A24B-112B-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34142 [26/Oct/2026:19:35:54.564] public api/api2 0/0/0/45/45 201 401 ---- 3/3/0/0/0 0/0 rid=AC120001855E-1F90-6ADFAB9A234-1127-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34198 [26/Oct/2026:19:35:54.614] public api/api1 0/0/0/14/14 201 401 ---- 8/8/6/2/0 0/0 rid=AC1200018596-1F90-6ADFAB9A25F-112E-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34230 [26/Oct/2026:19:35:54.621] public api/api1 0/0/0/10/11 201 401 ---- 7/7/5/1/0 0/0 rid=AC12000185B6-1F90-6ADFAB9A26A-1130-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34242 [26/Oct/2026:19:35:54.622] public api/api1 0/0/0/9/9 201 401 ---- 6/6/4/0/0 0/0 rid=AC12000185C2-1F90-6ADFAB9A26E-1132-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34270 [26/Oct/2026:19:35:54.638] public api/api1 0/0/0/6/7 201 401 ---- 8/8/6/1/0 0/0 rid=AC12000185DE-1F90-6ADFAB9A27D-1134-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34266 [26/Oct/2026:19:35:54.640] public api/api1 0/0/0/6/6 201 401 ---- 7/7/5/0/0 0/0 rid=AC12000185DA-1F90-6ADFAB9A26E-1136-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34278 [26/Oct/2026:19:35:54.656] public api/api1 0/0/0/5/5 201 401 ---- 8/8/6/0/0 0/0 rid=AC12000185E6-1F90-6ADFAB9A27F-1138-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34302 [26/Oct/2026:19:35:54.686] public api/api1 0/0/0/6/6 201 401 ---- 8/8/7/0/0 0/0 rid=AC12000185FE-1F90-6ADFAB9A299-113A-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34282 [26/Oct/2026:19:35:54.639] public api/api2 0/0/0/66/66 201 401 ---- 8/8/7/7/0 0/0 rid=AC12000185EA-1F90-6ADFAB9A27F-1135-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34254 [26/Oct/2026:19:35:54.622] public api/api2 0/0/0/83/84 201 401 ---- 7/7/6/6/0 0/0 rid=AC12000185CE-1F90-6ADFAB9A26E-1133-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34294 [26/Oct/2026:19:35:54.671] public api/api2 0/0/0/36/36 201 401 ---- 6/6/5/5/0 0/0 rid=AC12000185F6-1F90-6ADFAB9A28C-1139-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34338 [26/Oct/2026:19:35:54.715] public api/api1 0/0/0/5/5 201 401 ---- 8/8/5/0/0 0/0 rid=AC1200018622-1F90-6ADFAB9A2CB-113C-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34346 [26/Oct/2026:19:35:54.734] public api/api1 0/0/1/6/7 201 401 ---- 8/8/7/0/0 0/0 rid=AC120001862A-1F90-6ADFAB9A2CC-113E-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34360 [26/Oct/2026:19:35:54.745] public api/api1 0/0/0/5/5 201 401 ---- 8/8/7/0/0 0/0 rid=AC1200018638-1F90-6ADFAB9A2E9-1140-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34290 [26/Oct/2026:19:35:54.652] public api/api2 0/0/0/56/123 201 401 ---- 8/8/7/7/0 0/0 rid=AC12000185F2-1F90-6ADFAB9A28C-1137-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34192 [26/Oct/2026:19:35:54.609] public api/api2 0/0/0/171/172 201 401 ---- 8/8/7/6/0 0/0 rid=AC1200018590-1F90-6ADFAB9A25E-112D-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34240 [26/Oct/2026:19:35:54.620] public api/api2 0/0/1/159/160 201 401 ---- 7/7/6/5/0 0/0 rid=AC12000185C0-1F90-6ADFAB9A26C-1131-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34214 [26/Oct/2026:19:35:54.620] public api/api2 0/0/1/160/161 201 401 ---- 6/6/5/4/0 0/0 rid=AC12000185A6-1F90-6ADFAB9A269-112F-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34312 [26/Oct/2026:19:35:54.698] public api/api2 0/0/0/87/87 201 401 ---- 5/5/4/3/0 0/0 rid=AC1200018608-1F90-6ADFAB9A2BA-113B-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34374 [26/Oct/2026:19:35:54.779] public api/api1 0/0/0/8/8 201 401 ---- 4/4/3/0/0 0/0 rid=AC1200018646-1F90-6ADFAB9A30B-1142-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34364 [26/Oct/2026:19:35:54.755] public api/api2 0/0/0/35/35 201 401 ---- 3/3/2/2/0 0/0 rid=AC120001863C-1F90-6ADFAB9A2F3-1141-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34326 [26/Oct/2026:19:35:54.734] public api/api2 0/0/0/59/59 201 401 ---- 2/2/1/1/0 0/0 rid=AC1200018616-1F90-6ADFAB9A2CB-113F-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34354 [26/Oct/2026:19:35:54.725] public api/api2 0/0/0/68/68 201 401 ---- 1/1/0/0/0 0/0 rid=AC1200018632-1F90-6ADFAB9A2D5-113D-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34384 [26/Oct/2026:19:35:54.801] public api/api1 0/0/0/14/14 201 401 ---- 8/8/7/3/0 0/0 rid=AC1200018650-1F90-6ADFAB9A31B-1144-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34426 [26/Oct/2026:19:35:54.802] public api/api1 0/0/0/15/16 201 401 ---- 7/7/6/2/0 0/0 rid=AC120001867A-1F90-6ADFAB9A322-1148-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34392 [26/Oct/2026:19:35:54.802] public api/api1 0/0/0/16/16 201 401 ---- 6/6/5/1/0 0/0 rid=AC1200018658-1F90-6ADFAB9A31D-1146-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34440 [26/Oct/2026:19:35:54.802] public api/api1 0/0/0/16/16 201 401 ---- 5/5/4/0/0 0/0 rid=AC1200018688-1F90-6ADFAB9A322-114A-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34390 [26/Oct/2026:19:35:54.799] public api/api2 0/0/1/18/20 201 401 ---- 4/4/3/3/0 0/0 rid=AC1200018656-1F90-6ADFAB9A31C-1143-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34382 [26/Oct/2026:19:35:54.801] public api/api2 0/0/0/18/18 201 401 ---- 3/3/2/2/0 0/0 rid=AC120001864E-1F90-6ADFAB9A31B-1145-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34408 [26/Oct/2026:19:35:54.802] public api/api2 0/0/0/17/17 201 401 ---- 2/2/1/1/0 0/0 rid=AC1200018668-1F90-6ADFAB9A322-1147-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34422 [26/Oct/2026:19:35:54.802] public api/api2 0/0/0/18/18 201 401 ---- 1/1/0/0/0 0/0 rid=AC1200018676-1F90-6ADFAB9A322-1149-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34462 [26/Oct/2026:19:35:54.837] public api/api1 0/0/0/14/14 201 401 ---- 8/8/7/3/0 0/0 rid=AC120001869E-1F90-6ADFAB9A344-114E-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34508 [26/Oct/2026:19:35:54.838] public api/api1 0/0/0/16/16 201 401 ---- 7/7/6/2/0 0/0 rid=AC12000186CC-1F90-6ADFAB9A346-1152-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34450 [26/Oct/2026:19:35:54.834] public api/api1 0/0/0/20/20 201 401 ---- 6/6/5/1/0 0/0 rid=AC1200018692-1F90-6ADFAB9A33F-114C-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34490 [26/Oct/2026:19:35:54.838] public api/api1 0/0/0/16/17 201 401 ---- 5/5/4/0/0 0/0 rid=AC12000186BA-1F90-6ADFAB9A346-1150-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34534 [26/Oct/2026:19:35:54.865] public api/api1 0/0/0/10/10 201 401 ---- 8/8/7/1/0 0/0 rid=AC12000186E6-1F90-6ADFAB9A361-1156-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34530 [26/Oct/2026:19:35:54.865] public api/api1 0/0/0/12/12 201 401 ---- 7/7/6/0/0 0/0 rid=AC12000186E2-1F90-6ADFAB9A361-1155-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34446 [26/Oct/2026:19:35:54.834] public api/api2 0/0/0/59/59 201 401 ---- 8/8/6/6/0 0/0 rid=AC120001868E-1F90-6ADFAB9A337-114B-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34458 [26/Oct/2026:19:35:54.836] public api/api2 0/0/0/62/62 201 401 ---- 8/8/6/5/0 0/0 rid=AC120001869A-1F90-6ADFAB9A343-114D-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34538 [26/Oct/2026:19:35:54.897] public api/api1 0/0/1/8/9 201 401 ---- 8/8/7/1/0 0/0 rid=AC12000186EA-1F90-6ADFAB9A372-1158-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34478 [26/Oct/2026:19:35:54.837] public api/api2 0/0/0/71/71 201 401 ---- 7/7/6/5/0 0/0 rid=AC12000186AE-1F90-6ADFAB9A345-114F-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34570 [26/Oct/2026:19:35:54.904] public api/api1 0/0/0/9/9 201 401 ---- 8/8/5/0/0 0/0 rid=AC120001870A-1F90-6ADFAB9A388-115A-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34594 [26/Oct/2026:19:35:54.934] public api/api1 0/0/1/5/6 201 401 ---- 7/7/6/0/0 0/0 rid=AC1200018722-1F90-6ADFAB9A391-115D-0008 inst=c38982836a1d "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34498 [26/Oct/2026:19:35:54.838] public api/api2 0/0/0/71/136 201 401 ---- 6/6/5/5/0 0/0 rid=AC12000186C2-1F90-6ADFAB9A346-1151-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34522 [26/Oct/2026:19:35:54.856] public api/api2 0/0/0/121/121 201 401 ---- 5/5/4/4/0 0/0 rid=AC12000186DA-1F90-6ADFAB9A358-1153-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34536 [26/Oct/2026:19:35:54.882] public api/api2 0/0/0/96/96 201 401 ---- 4/4/3/3/0 0/0 rid=AC12000186E8-1F90-6ADFAB9A372-1157-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34528 [26/Oct/2026:19:35:54.865] public api/api2 0/0/0/114/115 201 401 ---- 3/3/2/2/0 0/0 rid=AC12000186E0-1F90-6ADFAB9A361-1154-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34556 [26/Oct/2026:19:35:54.899] public api/api2 0/0/0/86/86 201 401 ---- 2/2/1/1/0 0/0 rid=AC12000186FC-1F90-6ADFAB9A383-1159-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" +lb-1 | 172.18.0.1:34586 [26/Oct/2026:19:35:54.934] public api/api2 0/0/1/51/53 201 401 ---- 1/1/0/0/0 0/0 rid=AC120001871A-1F90-6ADFAB9A391-115C-0008 inst=ecaa2acc2a0a "POST /api/v1/chats/6afb6bc0-d1d7-463c-9bae-0d680f8b449c/messages" diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 0000000..87063ba --- /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.093, + "concurrency": 8, + "successful_requests": 4367, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 145.117, + "successful_latency_ms": { + "p50": 32.0, + "p95": 157.0, + "p99": 203.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load.txt b/evidence/load.txt new file mode 100644 index 0000000..c7c17fb --- /dev/null +++ b/evidence/load.txt @@ -0,0 +1,28 @@ +# 2026-10-26 19:35:55 UTC | Нагрузка 30 с, concurrency 8 | exit 0 | 30.4s +$ python tests/load.py --base-url http://127.0.0.1:8080 --duration 30 --concurrency 8 --output evidence/load.json +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.093, + "concurrency": 8, + "successful_requests": 4367, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 145.117, + "successful_latency_ms": { + "p50": 32.0, + "p95": 157.0, + "p99": 203.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} +# 2026-10-26 19:35:57 UTC | CPU/RAM после нагрузки | exit 0 | 2.2s +$ docker stats --no-stream --format table {{.Name}} {{.CPUPerc}} {{.MemUsage}} {{.MemPerc}} +NAME CPU % MEM USAGE / LIMIT MEM % +messenger-lab3-api-6 19.92% 89.26MiB / 256MiB 34.87% +messenger-lab3-api-5 0.67% 89.33MiB / 256MiB 34.89% +messenger-lab3-lb-1 0.14% 14.34MiB / 128MiB 11.20% +messenger-lab3-postgres-1 11.42% 68.96MiB / 512MiB 13.47% +messenger-lab3-redis-1 2.36% 4.148MiB / 96MiB 4.32% + diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 0000000..b07edae --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1,26 @@ +# 2026-10-24 12:39 UTC | НАТИВНЫЙ стенд (без Docker), те же src/ и migrations/ +## 1. Реплика не готова, пока схема не мигрирована; migrate однократный, повтор — no-op; две копии одновременно — advisory lock +$ # реплика против ПУСТОЙ БД, миграции ещё не выполнялись (RUN_MIGRATIONS_ON_START=false) +$ curl -s -w " %{http_code}" http://127.0.0.1:18099/health/ready +{"error":{"code":"unavailable","message":"Database schema is not migrated","request_id":"1f3109e3-a934-4c1b-bfbd-22350e35e05d"}} 503 +$ psql -c "select to_regclass('schema_migrations')" +NULL +$ python -m src.migrate # = сервис migrate (one-shot) +applied migrations: 001_init, 002_session_cache_invalidations, 003_idempotency_keys +$ python -m src.migrate # повтор: no-op +schema is up to date; nothing applied +$ # две копии migrate одновременно (advisory lock) на ещё одной пустой БД +NOTICE: database "messenger_race" does not exist, skipping +copy A: schema is up to date; nothing applied +copy B: applied migrations: 001_init, 002_session_cache_invalidations, 003_idempotency_keys +schema_migrations rows: 001_init, 002_session_cache_invalidations, 003_idempotency_keys +$ curl -s -w " %{http_code}" http://127.0.0.1:18099/health/ready # та же реплика, без рестарта +{"status":"ok"} 200 + +## 2. Совместимость миграции 003 со старой версией (rolling update): код lab2 работает на схеме lab3 одновременно с репликами lab3 +$ # старая версия: код lab2 (без Idempotency-Key/X-Instance-Id) против БД, мигрированной до 003 +migrations applied at startup: none +$ cd lab2 && python tests/smoke.py --base-url http://127.0.0.1:18098 # контракт lab2 +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. +$ cd lab3 && python tests/smoke.py --base-url http://127.0.0.1:8080 # одновременно реплики lab3 за LB +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..6113558 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,24 @@ +# 2026-10-26 19:35:10 UTC | Persistence: контейнеры до | exit 0 | 0.3s +$ docker compose --env-file .env ps -a --format table {{.Name}} {{.Status}} {{.RunningFor}} +NAME STATUS CREATED +messenger-lab3-api-5 Up 31 seconds (healthy) 32 seconds ago +messenger-lab3-api-6 Up 21 seconds (healthy) 22 seconds ago +messenger-lab3-lb-1 Up 18 minutes (healthy) 44 minutes ago +messenger-lab3-migrate-1 Exited (0) 4 minutes ago 44 minutes ago +messenger-lab3-postgres-1 Up 18 minutes (healthy) 44 minutes ago +messenger-lab3-redis-1 Up 18 minutes (healthy) 44 minutes ago +# 2026-10-26 19:35:24 UTC | Persistence: make test-persistence | exit 0 | 14.1s +$ python tests/resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://127.0.0.1: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. + +# 2026-10-26 19:35:24 UTC | Persistence: контейнеры после (Status = Up N seconds) | exit 0 | 0.3s +$ docker compose --env-file .env ps -a --format table {{.Name}} {{.Status}} {{.RunningFor}} +NAME STATUS CREATED +messenger-lab3-api-5 Up 7 seconds (healthy) 46 seconds ago +messenger-lab3-api-6 Up 7 seconds (healthy) 36 seconds ago +messenger-lab3-lb-1 Up Less than a second (health: starting) 44 minutes ago +messenger-lab3-migrate-1 Exited (0) 5 minutes ago 44 minutes ago +messenger-lab3-postgres-1 Up 7 seconds (healthy) 44 minutes ago +messenger-lab3-redis-1 Up 7 seconds (healthy) 44 minutes ago + diff --git a/evidence/rolling_back.json b/evidence/rolling_back.json new file mode 100644 index 0000000..e79934d --- /dev/null +++ b/evidence/rolling_back.json @@ -0,0 +1,147 @@ +{ + "scenario": "rolling update of all API replicas under continuous load", + "update_command": "scripts/ops.py rolling-update", + "update_exit_code": 0, + "update_seconds": 27.69, + "replicas_before": [ + "6e2f0c643449", + "b6e350f043f3" + ], + "replicas_after": [ + "c38982836a1d", + "ecaa2acc2a0a" + ], + "all_replaced": true, + "errors_during_update": 0, + "error_kinds": [], + "windows": { + "before": { + "from_s": 0, + "to_s": 5.02, + "requests": 1342, + "ok": 1342, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 267.5, + "write_ok_rps": 159.5, + "latency_ms_ok": { + "p50": 16.0, + "p95": 63.0, + "p99": 94.0 + }, + "instances": [ + "6e2f0c643449", + "b6e350f043f3" + ] + }, + "during_update": { + "from_s": 5.02, + "to_s": 32.7, + "requests": 6993, + "ok": 6993, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 252.6, + "write_ok_rps": 149.3, + "latency_ms_ok": { + "p50": 16.0, + "p95": 78.0, + "p99": 140.0 + }, + "instances": [ + "6e2f0c643449", + "b6e350f043f3", + "c38982836a1d", + "ecaa2acc2a0a" + ] + }, + "after": { + "from_s": 32.7, + "to_s": 40.77, + "requests": 2045, + "ok": 2045, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 253.6, + "write_ok_rps": 152.8, + "latency_ms_ok": { + "p50": 16.0, + "p95": 78.0, + "p99": 94.0 + }, + "instances": [ + "c38982836a1d", + "ecaa2acc2a0a" + ] + } + }, + "lb_timeline": [ + [ + 0.02, + [ + "api1", + "api3" + ] + ], + [ + 11.42, + [ + "api1", + "api2", + "api3" + ] + ], + [ + 12.23, + [ + "api1", + "api3" + ] + ], + [ + 14.77, + [ + "api1", + "api2", + "api3" + ] + ], + [ + 19.16, + [ + "api1", + "api2" + ] + ], + [ + 25.72, + [ + "api1", + "api2", + "api3" + ] + ], + [ + 29.66, + [ + "api2", + "api3" + ] + ] + ], + "data": { + "confirmed_writes": 6166, + "stored_messages": 6166, + "missing_or_altered": 0, + "duplicate_ids": 0, + "duplicate_texts": 0, + "same_key_retries": 0, + "ok": true + }, + "load": { + "writers": 4, + "readers": 2, + "client_timeout_s": 2.0 + }, + "pass": true +} diff --git a/evidence/rolling_update.json b/evidence/rolling_update.json new file mode 100644 index 0000000..e4d09f8 --- /dev/null +++ b/evidence/rolling_update.json @@ -0,0 +1,147 @@ +{ + "scenario": "rolling update of all API replicas under continuous load", + "update_command": "scripts/ops.py rolling-update", + "update_exit_code": 0, + "update_seconds": 28.38, + "replicas_before": [ + "a21409fffeec", + "c4c5ae5b0949" + ], + "replicas_after": [ + "6e2f0c643449", + "b6e350f043f3" + ], + "all_replaced": true, + "errors_during_update": 0, + "error_kinds": [], + "windows": { + "before": { + "from_s": 0, + "to_s": 5.0, + "requests": 1161, + "ok": 1161, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 232.2, + "write_ok_rps": 136.2, + "latency_ms_ok": { + "p50": 16.0, + "p95": 78.0, + "p99": 187.0 + }, + "instances": [ + "a21409fffeec", + "c4c5ae5b0949" + ] + }, + "during_update": { + "from_s": 5.0, + "to_s": 33.38, + "requests": 6950, + "ok": 6950, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 244.9, + "write_ok_rps": 145.0, + "latency_ms_ok": { + "p50": 16.0, + "p95": 93.0, + "p99": 156.0 + }, + "instances": [ + "6e2f0c643449", + "a21409fffeec", + "b6e350f043f3", + "c4c5ae5b0949" + ] + }, + "after": { + "from_s": 33.38, + "to_s": 41.41, + "requests": 2008, + "ok": 2008, + "errors": 0, + "error_ratio": 0.0, + "ok_rps": 250.0, + "write_ok_rps": 147.6, + "latency_ms_ok": { + "p50": 16.0, + "p95": 78.0, + "p99": 110.0 + }, + "instances": [ + "6e2f0c643449", + "b6e350f043f3" + ] + } + }, + "lb_timeline": [ + [ + 0.0, + [ + "api1", + "api2" + ] + ], + [ + 12.5, + [ + "api1", + "api2", + "api3" + ] + ], + [ + 12.73, + [ + "api1", + "api2" + ] + ], + [ + 15.25, + [ + "api1", + "api2", + "api3" + ] + ], + [ + 19.28, + [ + "api2", + "api3" + ] + ], + [ + 25.73, + [ + "api1", + "api2", + "api3" + ] + ], + [ + 29.34, + [ + "api1", + "api3" + ] + ] + ], + "data": { + "confirmed_writes": 5981, + "stored_messages": 5981, + "missing_or_altered": 0, + "duplicate_ids": 0, + "duplicate_texts": 0, + "same_key_retries": 0, + "ok": true + }, + "load": { + "writers": 4, + "readers": 2, + "client_timeout_s": 2.0 + }, + "pass": true +} diff --git a/evidence/rolling_update.txt b/evidence/rolling_update.txt new file mode 100644 index 0000000..1fef464 --- /dev/null +++ b/evidence/rolling_update.txt @@ -0,0 +1,29 @@ +# 2026-10-26 19:34:26 UTC | Rolling update lab3 -> lab3.1 под нагрузкой | exit 0 | 44.1s +$ python student-tests/rolling_update_load.py --base-url http://127.0.0.1:8080 --output evidence/rolling_update.json +replicas before: ['a21409fffeec', 'c4c5ae5b0949'] +2026-10-26T19:33:48.176Z rolling-update: start; replicas=2 old=['c4c5ae5b0949', 'a21409fffeec'] +2026-10-26T19:33:51.770Z rolling-update: images built in 3.6s (tag lab3.1) +2026-10-26T19:33:53.990Z rolling-update: migrations once in 2.2s: schema is up to date; nothing applied +2026-10-26T19:34:04.788Z rolling-update: step 1/2 new=6e2f0c643449 (messenger-api:lab3.1, ready+UP in 6.8s) replaced old=c4c5ae5b0949 (graceful stop 3.8s) +2026-10-26T19:34:15.884Z rolling-update: step 2/2 new=b6e350f043f3 (messenger-api:lab3.1, ready+UP in 6.7s) replaced old=a21409fffeec (graceful stop 4.3s) +2026-10-26T19:34:16.330Z rolling-update: done in 28.1s; replicas now ['6e2f0c643449', 'b6e350f043f3'] +update 28.4s rc=0 | replicas ['a21409fffeec', 'c4c5ae5b0949'] -> ['6e2f0c643449', 'b6e350f043f3'] | errors during update 0 (-) | RPS before 232.2, during 244.9, after 250.0 | p95 during 93.0 ms | data ok=True +PASS: rolling update under load +# 2026-10-26 19:35:09 UTC | Rolling update обратно lab3.1 -> lab3 (откат) под нагрузкой | exit 0 | 43.4s +$ python student-tests/rolling_update_load.py --base-url http://127.0.0.1:8080 --output evidence/rolling_back.json +replicas before: ['6e2f0c643449', 'b6e350f043f3'] +2026-10-26T19:34:32.642Z rolling-update: start; replicas=2 old=['6e2f0c643449', 'b6e350f043f3'] +2026-10-26T19:34:35.497Z rolling-update: images built in 2.9s (tag lab3) +2026-10-26T19:34:37.818Z rolling-update: migrations once in 2.3s: schema is up to date; nothing applied +2026-10-26T19:34:48.605Z rolling-update: step 1/2 new=c38982836a1d (messenger-api:lab3, ready+UP in 7.0s) replaced old=6e2f0c643449 (graceful stop 3.7s) +2026-10-26T19:34:59.414Z rolling-update: step 2/2 new=ecaa2acc2a0a (messenger-api:lab3, ready+UP in 6.8s) replaced old=b6e350f043f3 (graceful stop 3.9s) +2026-10-26T19:34:59.817Z rolling-update: done in 27.4s; replicas now ['c38982836a1d', 'ecaa2acc2a0a'] +update 27.7s rc=0 | replicas ['6e2f0c643449', 'b6e350f043f3'] -> ['c38982836a1d', 'ecaa2acc2a0a'] | errors during update 0 (-) | RPS before 267.5, during 252.6, after 253.6 | p95 during 78.0 ms | data ok=True +PASS: rolling update under load + +# 2026-10-26 19:35:09 UTC | Реплики после обновлений | exit 0 | 0.3s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c38982836a1d messenger-lab3-api-5 running healthy messenger-api:lab3 api2 UP +ecaa2acc2a0a messenger-lab3-api-6 running healthy messenger-api:lab3 api3 UP + diff --git a/evidence/shutdown_timeline.txt b/evidence/shutdown_timeline.txt new file mode 100644 index 0000000..7c3bddb --- /dev/null +++ b/evidence/shutdown_timeline.txt @@ -0,0 +1,17 @@ +# 2026-10-24 12:39 UTC | НАТИВНЫЙ стенд (без Docker), те же src/ и migrations/ +# Настройки: HAProxy inter 1s / fastinter 500ms / fall 2 / rise 2 / timeout check 1.5s; API DRAIN_SECONDS=3, GRACEFUL_TIMEOUT_SECONDS=10 +# graceful stop timeline, t=0 — начало наблюдения; интервал опроса 50 мс + +0.02s (от SIGTERM -0.48s) LB api3: UP + +0.02s (от SIGTERM -0.48s) nat-api-3 /health/ready -> 200 + +0.50s (от SIGTERM -0.00s) SIGTERM -> nat-api-3 (pid 3196) + +0.51s (от SIGTERM +0.01s) nat-api-3 /health/ready -> 503 + +1.26s (от SIGTERM +0.76s) LB api3: UP 1/2 + +1.80s (от SIGTERM +1.30s) LB api3: DOWN + +3.52s (от SIGTERM +3.02s) nat-api-3 /health/ready -> connection refused + +3.62s (от SIGTERM +3.12s) nat-api-3 process exited + +# лог реплики: +2026-10-24 15:39:19,576 INFO messenger.server signal 15: instance nat-api-3 draining for 3.0s (readiness=503), then graceful stop +2026-10-24 15:39:22,580 INFO uvicorn.error Shutting down +2026-10-24 15:39:22,681 INFO messenger.api shutdown: instance=nat-api-3 closing pool +2026-10-24 15:39:22,682 INFO uvicorn.error Finished server process [3196] diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 0000000..574b73d --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,3 @@ +# 2026-10-26 19:30:00 UTC | Публичный smoke | exit 0 | 0.9s +$ python tests/smoke.py --base-url http://127.0.0.1:8080 +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/evidence/stand.txt b/evidence/stand.txt new file mode 100644 index 0000000..20ae6e5 --- /dev/null +++ b/evidence/stand.txt @@ -0,0 +1,33 @@ +# 2026-10-26 19:29:57 UTC | Стенд: контейнеры | exit 0 | 0.2s +$ docker compose --env-file .env ps -a +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +messenger-lab3-api-1 messenger-api:lab3 "python -m src.server" api 39 minutes ago Up 12 minutes (healthy) 8080/tcp +messenger-lab3-api-2 messenger-api:lab3 "python -m src.server" api 39 minutes ago Up 13 minutes (healthy) 8080/tcp +messenger-lab3-lb-1 haproxy:2.8.30-alpine "docker-entrypoint.s…" lb 39 minutes ago Up 13 minutes (healthy) 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp +messenger-lab3-migrate-1 messenger-lab3-migrate "python -m src.migra…" migrate 39 minutes ago Exited (0) 13 minutes ago +messenger-lab3-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 39 minutes ago Up 13 minutes (healthy) 5432/tcp +messenger-lab3-redis-1 redis:7.4.1-alpine "docker-entrypoint.s…" redis 39 minutes ago Up 13 minutes (healthy) 6379/tcp +# 2026-10-26 19:29:57 UTC | Стенд: реплики и статус в LB | exit 0 | 0.2s +$ python scripts/ops.py ps +X-Instance-Id container state health image lb lb_status +c4c5ae5b0949 messenger-lab3-api-1 running healthy messenger-api:lab3 api1 UP +a21409fffeec messenger-lab3-api-2 running healthy messenger-api:lab3 api2 UP + +# 2026-10-26 19:29:59 UTC | Стенд: лимиты CPU/RAM | exit 0 | 1.2s +$ docker stats --no-stream --format table {{.Name}} {{.CPUPerc}} {{.MemUsage}} {{.MemPerc}} +NAME CPU % MEM USAGE / LIMIT MEM % +messenger-lab3-lb-1 1.87% 12.87MiB / 128MiB 10.06% +messenger-lab3-api-2 16.79% 204.4MiB / 256MiB 79.86% +messenger-lab3-api-1 0.31% 222.9MiB / 256MiB 87.07% +messenger-lab3-postgres-1 2.23% 58.11MiB / 512MiB 11.35% +messenger-lab3-redis-1 0.22% 4.559MiB / 96MiB 4.75% + +# 2026-10-26 19:29:59 UTC | Стенд: опубликованные порты (только lb) | exit 0 | 0.3s +$ docker compose --env-file .env ps --format table {{.Service}} {{.Ports}} +SERVICE PORTS +api 8080/tcp +api 8080/tcp +lb 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp +postgres 5432/tcp +redis 6379/tcp + diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 0000000..2489d48 --- /dev/null +++ b/evidence/student-tests.txt @@ -0,0 +1,134 @@ +# 2026-10-26 19:30:06 UTC | Собственные тесты (HTTP через LB) | exit 0 | 6.2s +$ python student-tests/run_all.py --base-url http://127.0.0.1:8080 + +== API, auth, concurrency, idempotency tests (DB/expiry tests skip without their env) +test_chat_list_pagination (test_api.ApiBehaviorTests) ... ok +test_cursor_from_other_chat_returns_400 (test_api.ApiBehaviorTests) ... ok +test_duplicate_username_returns_409 (test_api.ApiBehaviorTests) ... ok +test_empty_message_returns_400 (test_api.ApiBehaviorTests) ... ok +test_malformed_json_returns_400 (test_api.ApiBehaviorTests) ... ok +test_naive_timestamp_cursor_returns_400 (test_api.ApiBehaviorTests) ... ok +test_outsider_cannot_access_chat (test_api.ApiBehaviorTests) ... ok +test_pagination_returns_all_messages_without_duplicates (test_api.ApiBehaviorTests) ... ok +test_password_never_returned (test_api.ApiBehaviorTests) ... ok +test_registration_without_password_returns_400 (test_api.ApiBehaviorTests) ... ok +test_sender_id_in_body_rejected (test_api.ApiBehaviorTests) ... ok +test_short_password_returns_400 (test_api.ApiBehaviorTests) ... ok +test_basic_on_business_endpoint_rejected (test_auth.AuthTests) ... ok +test_login_with_body_rejected (test_auth.AuthTests) +Контракт: вход — только заголовок Basic, без тела. Лишний ввод -> 400, сессии нет. ... ok +test_logout_revokes_only_current_session (test_auth.AuthTests) ... ok +test_malformed_basic_headers (test_auth.AuthTests) ... ok +test_password_with_colon_and_unicode (test_auth.AuthTests) ... ok +test_session_shape_and_token_entropy (test_auth.AuthTests) ... ok +test_unknown_and_garbage_tokens (test_auth.AuthTests) ... ok +test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTests) ... ok +test_x_user_id_gives_no_access (test_auth.AuthTests) ... ok +test_duplicate_and_missing_caller_rejected (test_concurrency.ChatRollbackTests) ... ok +test_unknown_member_rolls_back_whole_chat (test_concurrency.ChatRollbackTests) +Чат вставляется первым, затем участники по порядку (сначала сам владелец). ... ok +test_same_username_parallel_registration (test_concurrency.RegistrationRaceTests) ... ok +test_session_expires_even_when_cached (test_expiry.ExpiryTests) ... skipped 'set EXPIRY_BASE_URL to the short-TTL API instance' +test_auth_checked_before_key (test_idempotency.IdempotencyTests) ... ok +test_concurrent_same_key_across_replicas_creates_one_message (test_idempotency.IdempotencyTests) ... ok +test_concurrent_same_key_different_bodies_one_winner (test_idempotency.IdempotencyTests) ... ok +test_failed_access_does_not_burn_key (test_idempotency.IdempotencyTests) ... ok +test_json_formatting_and_key_order_do_not_matter (test_idempotency.IdempotencyTests) ... ok +test_key_survives_new_session_of_same_user (test_idempotency.IdempotencyTests) ... ok +test_missing_or_invalid_key_is_400 (test_idempotency.IdempotencyTests) ... ok +test_replay_rechecks_session (test_idempotency.IdempotencyTests) ... ok +test_scope_is_user_and_chat (test_idempotency.IdempotencyTests) ... ok +test_sequential_replay_and_conflict (test_idempotency.IdempotencyTests) ... ok +test_debt_survives_api_restart (test_session_cache.SessionRevocationCacheTests) +Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу. ... skipped 'DATABASE_URL is not configured' +test_normal_logout_leaves_no_debt (test_session_cache.SessionRevocationCacheTests) ... skipped 'DATABASE_URL is not configured' +test_revoked_token_rejected_after_partition_heals (test_session_cache.SessionRevocationCacheTests) ... skipped 'DATABASE_URL is not configured' +test_cleanup_runs_on_one_replica_at_a_time (test_storage_idempotency.StorageIdempotencyTests) ... skipped 'DATABASE_URL is not configured' +test_conflict_on_different_body (test_storage_idempotency.StorageIdempotencyTests) ... skipped 'DATABASE_URL is not configured' +test_expired_key_can_be_reused_and_is_cleaned (test_storage_idempotency.StorageIdempotencyTests) ... skipped 'DATABASE_URL is not configured' +test_failure_inside_transaction_stores_nothing (test_storage_idempotency.StorageIdempotencyTests) ... skipped 'DATABASE_URL is not configured' +test_threads_same_key_single_insert (test_storage_idempotency.StorageIdempotencyTests) ... skipped 'DATABASE_URL is not configured' +test_failure_after_inserts_leaves_nothing (test_storage_rollback.StorageRollbackTests) ... skipped 'DATABASE_URL is not configured' +test_migrations_are_idempotent (test_storage_rollback.StorageRollbackTests) ... skipped 'DATABASE_URL is not configured' +test_no_orphan_chats_in_database (test_storage_rollback.StorageRollbackTests) ... skipped 'DATABASE_URL is not configured' +test_passwords_stored_as_argon2id (test_storage_rollback.StorageRollbackTests) ... skipped 'DATABASE_URL is not configured' + +---------------------------------------------------------------------- +Ran 47 tests in 4.640s + +OK (skipped=13) + + 24 parallel POSTs, one key -> 1 message; replicas: ['a21409fffeec', 'c4c5ae5b0949'] + +== Concurrent write test +PASS: concurrent write test; 10 clients x 10 messages = 100 messages; no lost or duplicate messages + +ALL STUDENT TESTS PASSED +# 2026-10-26 19:30:14 UTC | Тесты с доступом к БД (внутри compose-сети) | exit 0 | 7.5s +$ python scripts/ops.py in-network storage + Container messenger-lab3-api-run-bdc116a8fd34 Creating + Container messenger-lab3-api-run-bdc116a8fd34 Created +test_cleanup_runs_on_one_replica_at_a_time (test_storage_idempotency.StorageIdempotencyTests.test_cleanup_runs_on_one_replica_at_a_time) ... ok +test_conflict_on_different_body (test_storage_idempotency.StorageIdempotencyTests.test_conflict_on_different_body) ... ok +test_expired_key_can_be_reused_and_is_cleaned (test_storage_idempotency.StorageIdempotencyTests.test_expired_key_can_be_reused_and_is_cleaned) ... ok +test_failure_inside_transaction_stores_nothing (test_storage_idempotency.StorageIdempotencyTests.test_failure_inside_transaction_stores_nothing) ... ok +test_threads_same_key_single_insert (test_storage_idempotency.StorageIdempotencyTests.test_threads_same_key_single_insert) ... ok +test_failure_after_inserts_leaves_nothing (test_storage_rollback.StorageRollbackTests.test_failure_after_inserts_leaves_nothing) ... ok +test_migrations_are_idempotent (test_storage_rollback.StorageRollbackTests.test_migrations_are_idempotent) ... ok +test_no_orphan_chats_in_database (test_storage_rollback.StorageRollbackTests.test_no_orphan_chats_in_database) ... ok +test_passwords_stored_as_argon2id (test_storage_rollback.StorageRollbackTests.test_passwords_stored_as_argon2id) ... ok + +---------------------------------------------------------------------- +Ran 9 tests in 3.223s + +OK + Container messenger-lab3-api-run-630b208e9588 Creating + Container messenger-lab3-api-run-630b208e9588 Created +test_debt_survives_api_restart (test_session_cache.SessionRevocationCacheTests.test_debt_survives_api_restart) +Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу. ... logout: cache invalidation deferred; positive cache disabled +ok +test_normal_logout_leaves_no_debt (test_session_cache.SessionRevocationCacheTests.test_normal_logout_leaves_no_debt) ... ok +test_revoked_token_rejected_after_partition_heals (test_session_cache.SessionRevocationCacheTests.test_revoked_token_rejected_after_partition_heals) ... logout: cache invalidation deferred; positive cache disabled +ok + +---------------------------------------------------------------------- +Ran 3 tests in 1.864s + +OK + +# 2026-10-26 19:30:27 UTC | Истечение сессии (api-short-ttl, TTL 2 с) | exit 0 | 13.7s +$ python scripts/ops.py in-network expiry + Container messenger-lab3-redis-1 Running + Container messenger-lab3-postgres-1 Running + Container messenger-lab3-api-1 Running + Container messenger-lab3-api-2 Running + Container messenger-lab3-api-short-ttl-1 Creating + Container messenger-lab3-api-short-ttl-1 Created + Container messenger-lab3-postgres-1 Waiting + Container messenger-lab3-postgres-1 Healthy + Container messenger-lab3-migrate-1 Starting + Container messenger-lab3-migrate-1 Started + Container messenger-lab3-migrate-1 Waiting + Container messenger-lab3-postgres-1 Waiting + Container messenger-lab3-redis-1 Waiting + Container messenger-lab3-redis-1 Healthy + Container messenger-lab3-postgres-1 Healthy + Container messenger-lab3-migrate-1 Exited + Container messenger-lab3-api-2 Waiting + Container messenger-lab3-api-1 Waiting + Container messenger-lab3-api-2 Healthy + Container messenger-lab3-api-1 Healthy + Container messenger-lab3-api-short-ttl-1 Starting + Container messenger-lab3-api-short-ttl-1 Started + Container messenger-lab3-api-run-a36baf72714e Creating + Container messenger-lab3-api-run-a36baf72714e Created +ready: http://api-short-ttl:8080/health/ready + Container messenger-lab3-api-run-c445a7ef00cd Creating + Container messenger-lab3-api-run-c445a7ef00cd Created +test_session_expires_even_when_cached (test_expiry.ExpiryTests.test_session_expires_even_when_cached) ... ok + +---------------------------------------------------------------------- +Ran 1 test in 3.620s + +OK + diff --git a/infra/README.md b/infra/README.md index 5a39e86..a1f3174 100644 --- a/infra/README.md +++ b/infra/README.md @@ -5,3 +5,9 @@ В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд. Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику. + +## Решение (lab3) + +- `haproxy/haproxy.cfg` — единственная публичная точка входа (`lb` в `compose.yaml`): roundrobin без sticky, активные проверки `GET /health/ready` (inter 1s, fastinter 500ms, fall 2, rise 2), обнаружение реплик через Docker DNS (`server-template api 1-6 api:8080 … resolvers docker`), JSON-ошибки самого LB (`http-error`), сквозной `X-Request-Id`, страница состояния на `:8404`. +- Таблица «роль → service → версия → health → volume → сеть/порт → credentials → лимиты», bootstrap и повторяемость — в `REPORT.md`, раздел «Инфраструктура». +- Операции со стендом (wait/ps/stop-one/restore/restart/rolling-update) — `scripts/ops.py`. diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 0000000..4f0b3a3 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,96 @@ +# HAProxy 2.8 LTS — единственная публичная точка входа lab3. +# +# Обнаружение реплик: Docker DNS (127.0.0.11) отдаёт по имени сервиса `api` +# A-записи ВСЕХ запущенных контейнеров сервиса. server-template держит до 6 слотов +# и каждые 2 с синхронизирует их с DNS: новый контейнер (scale / rolling update) +# появляется сам, остановленный исчезает. Перезапуск LB при масштабировании не нужен. +# +# Исключение недоступного backend (активные проверки): +# GET /health/ready каждые inter=1s; после первой неудачи — fastinter=500ms; +# fall=2 неудачи подряд -> DOWN; rise=2 удачи -> UP; timeout check 1500ms. +# Время обнаружения: +# * graceful stop (реплика сразу отвечает 503): <= 1 с + 0.5 с ~ 1.5 с +# * crash / kill (соединение отклонено/сброшено): ~1.5 с +# * зависание без ответа: <= 1 + 1.5 + 0.5 + 1.5 = 4.5 с +# Пока реплика ещё не помечена DOWN, запрос к ней, не сумевший СОЕДИНИТЬСЯ +# (timeout connect 1s), повторяется на другой реплике (retries 2 + redispatch). +# Повторяются только ошибки установления соединения (retry-on conn-failure по +# умолчанию): запрос ещё не был отправлен, поэтому это безопасно и для POST. +# Уже отправленные POST LB не повторяет — это делает клиент с тем же +# Idempotency-Key (контракт запрещает прозрачные повторы POST /users, /chats). +# +# Согласование таймаутов: +# API: пул БД 3 с + statement_timeout 5 с = максимум ~8 с на запрос +# -> timeout server 10s; graceful shutdown API 10 с; drain API 3 с > 1.5 с. +# Docker stop_grace_period 20 с > drain 3 с + graceful 10 с. + +global + log stdout format raw local0 info + maxconn 2000 + +resolvers docker + nameserver dns1 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 2s + hold obsolete 2s + hold nx 2s + hold other 2s + hold refused 2s + hold timeout 2s + # 8 КБ: в ответ DNS помещаются A-записи всех слотов. + accepted_payload_size 8192 + +defaults + mode http + log global + option httplog + option dontlognull + option redispatch 1 + retries 2 + timeout connect 1s + timeout client 30s + timeout server 10s + timeout http-request 10s + timeout http-keep-alive 10s + timeout queue 3s + timeout check 1500ms + default-server inter 1s fastinter 500ms downinter 2s fall 2 rise 2 + +frontend public + bind :8080 + # Сквозной идентификатор запроса: HAProxy генерирует X-Request-Id, если клиент + # не прислал свой; API отражает его в ответе и в теле ошибок, LB — в логе. + unique-id-format %{+X}o\ %ci%cp-%fp-%Ts%ms-%rt-%pid + http-request set-header X-Request-Id %[unique-id] unless { req.hdr(X-Request-Id) -m found } + log-format "%ci:%cp [%tr] %ft %b/%s %TR/%Tw/%Tc/%Tr/%Ta %ST %B %tsc %ac/%fc/%bc/%sc/%rc %sq/%bq rid=%[capture.req.hdr(0)] inst=%[capture.res.hdr(0)] \"%HM %HPO\"" + http-request capture req.hdr(X-Request-Id) len 64 + declare capture response len 32 + http-response capture res.hdr(X-Instance-Id) id 0 + default_backend api + +backend api + balance roundrobin + option httpchk + http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host lb + http-check expect status 200 + # Ответы, которые формирует сам LB (нет ни одной готовой реплики, таймаут), + # — в общем JSON-формате ошибок контракта, с тем же X-Request-Id. + http-error status 503 content-type application/json hdr X-Request-Id "%[req.hdr(X-Request-Id)]" lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"No API instance is available\",\"request_id\":\"%[req.hdr(X-Request-Id)]\"}}" + http-error status 504 content-type application/json hdr X-Request-Id "%[req.hdr(X-Request-Id)]" lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"API instance timeout\",\"request_id\":\"%[req.hdr(X-Request-Id)]\"}}" + http-error status 502 content-type application/json hdr X-Request-Id "%[req.hdr(X-Request-Id)]" lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Bad gateway\",\"request_id\":\"%[req.hdr(X-Request-Id)]\"}}" + # До 6 реплик (в т.ч. N+1 во время rolling update). init-addr none: LB стартует, + # даже если реплик ещё нет; слоты без адреса находятся в MAINT. + server-template api 1-6 api:8080 check resolvers docker init-addr none resolve-prefer ipv4 + +# Внутренняя страница состояния (UP/DOWN по репликам) — только чтение. +# Публикуется на 127.0.0.1:8404 хоста; используется scripts/ops.py. +frontend stats + bind :8404 + monitor-uri /lb-health + stats enable + stats uri /stats + stats refresh 2s + stats show-legends + http-request set-log-level silent diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 0000000..1bfb18f --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,66 @@ +-- 001_init: базовая схема мессенджера lab2. +-- Применяется src/migrate.py ровно один раз (таблица schema_migrations), +-- внутри одной транзакции; повторный запуск миграций ничего не дублирует. + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + 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) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_len CHECK (char_length(title) BETWEEN 1 AND 100) +); + +-- Список чатов пользователя: WHERE user_id = ? ORDER BY (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) ON DELETE RESTRICT, + position smallint NOT NULL, + PRIMARY KEY (chat_id, user_id), + CONSTRAINT chat_members_position_key UNIQUE (chat_id, position) +); + +-- "В каких чатах состоит пользователь" (GET /chats) +CREATE INDEX chat_members_user_id_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + sender_id uuid NOT NULL REFERENCES users (id) ON DELETE RESTRICT, + text text NOT NULL, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT messages_text_len CHECK (char_length(text) BETWEEN 1 AND 4000) +); + +-- История чата с keyset-пагинацией: +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +-- ORDER BY created_at, id LIMIT $4 +-- Обоснование и EXPLAIN (ANALYZE, BUFFERS): evidence/explain_history.txt +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); + +-- Серверные сессии. Источник истины для сессий — PostgreSQL; +-- Redis хранит только кэш проверок токена (см. REPORT.md). +-- Хранится SHA-256 от токена, сам токен в БД не попадает. +CREATE TABLE sessions ( + token_hash bytea PRIMARY KEY, + 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_token_hash_len CHECK (octet_length(token_hash) = 32), + 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); diff --git a/migrations/002_session_cache_invalidations.sql b/migrations/002_session_cache_invalidations.sql new file mode 100644 index 0000000..1c26116 --- /dev/null +++ b/migrations/002_session_cache_invalidations.sql @@ -0,0 +1,13 @@ +-- 002: надёжная инвалидация кэша сессий. +-- Строка вставляется В ТОЙ ЖЕ транзакции, что и sessions.revoked_at, и удаляется +-- только после того, как в Redis записано «надгробие» для этого токена. +-- Пока в таблице есть строки, API не доверяет положительным записям кэша +-- и проверяет каждый токен в PostgreSQL (см. src/sessions.py). +CREATE TABLE session_cache_invalidations ( + token_hash bytea PRIMARY KEY, + revoked_at timestamptz NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT session_cache_invalidations_hash_len CHECK (octet_length(token_hash) = 32) +); + +CREATE INDEX session_cache_invalidations_revoked_at_idx + ON session_cache_invalidations (revoked_at); diff --git a/migrations/003_idempotency_keys.sql b/migrations/003_idempotency_keys.sql new file mode 100644 index 0000000..af60c76 --- /dev/null +++ b/migrations/003_idempotency_keys.sql @@ -0,0 +1,40 @@ +-- 003 (lab3): общая идемпотентность POST /chats/{chat_id}/messages. +-- +-- Область уникальности по контракту: пользователь + HTTP-метод + путь чата + ключ. +-- Путь однозначно задаётся chat_id, метод сейчас всегда POST (колонка оставлена, +-- чтобы область ключа была записана явно и расширялась без смены PK). +-- +-- Атомарность: строка ключа и сообщение пишутся ОДНОЙ транзакцией. +-- 1. INSERT ключа (ON CONFLICT ...) — конкурентный повтор с тем же ключом +-- ждёт на уникальном индексе, пока первая транзакция не завершится; +-- 2. INSERT сообщения с заранее выбранным id; +-- 3. COMMIT. FK message_id -> messages проверяется в момент COMMIT +-- (DEFERRABLE INITIALLY DEFERRED), поэтому message_id NOT NULL с первого шага. +-- Ошибка/откат на любом шаге не оставляет ни сообщения, ни ключа: +-- транзиентный 5xx не фиксируется как окончательный результат. +-- +-- Совместимость с работающей версией (rolling update): миграция только +-- добавляет новую таблицу, старые таблицы и запросы не меняются. + +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id) ON DELETE CASCADE, + method text NOT NULL DEFAULT 'POST', + chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE, + idem_key text NOT NULL, + request_hash bytea NOT NULL, + message_id uuid NOT NULL + REFERENCES messages (id) ON DELETE CASCADE + DEFERRABLE INITIALLY DEFERRED, + created_at timestamptz NOT NULL DEFAULT clock_timestamp(), + expires_at timestamptz NOT NULL, + PRIMARY KEY (user_id, method, chat_id, idem_key), + CONSTRAINT idempotency_keys_key_format CHECK (idem_key ~ '^[A-Za-z0-9._:-]{1,128}$'), + CONSTRAINT idempotency_keys_method CHECK (method IN ('POST')), + CONSTRAINT idempotency_keys_hash_len CHECK (octet_length(request_hash) = 32), + CONSTRAINT idempotency_keys_expiry_after_create CHECK (expires_at > created_at) +); + +-- Периодическая очистка истёкших ключей (src/idempotency.py). +CREATE INDEX idempotency_keys_expires_at_idx ON idempotency_keys (expires_at); +-- ON DELETE CASCADE от messages без полного скана. +CREATE INDEX idempotency_keys_message_id_idx ON idempotency_keys (message_id); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..3810a15 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +fastapi==0.115.6 +uvicorn==0.34.0 +pydantic==2.10.4 +psycopg[binary]==3.2.3 +psycopg-pool==3.2.4 +redis==5.2.1 +argon2-cffi==23.1.0 diff --git a/scripts/collect_evidence.py b/scripts/collect_evidence.py new file mode 100644 index 0000000..e44c101 --- /dev/null +++ b/scripts/collect_evidence.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +"""Прогон всех проверок lab3 на запущенном compose-стенде с записью в evidence/. + + python scripts/collect_evidence.py # ~8-10 минут + python scripts/collect_evidence.py --quick # без kill-серии и нагрузки + +Перед запуском: стенд поднят (`docker compose --env-file .env up -d --build`, +`python scripts/ops.py wait`). Скрипт останавливает и восстанавливает реплики, +перезапускает хранилища (volumes сохраняются) и делает rolling update +lab3 -> lab3.1 -> lab3 (откат), поэтому запускайте его только на учебном стенде. +Токены и пароли в файлы не пишутся (тесты держат их в памяти). +""" +import argparse +import json +import os +import subprocess +import sys +import time +from datetime import datetime, timezone +from pathlib import Path +from urllib.request import Request, urlopen + +ROOT = Path(__file__).resolve().parents[1] +EV = ROOT / "evidence" +PY = sys.executable or "python" +WIN = os.name == "nt" +HOOK_STOP = str(ROOT / "scripts" / ("stop-one.cmd" if WIN else "stop-one.sh")) +HOOK_RESTART = str(ROOT / "scripts" / ("restart.cmd" if WIN else "restart.sh")) +BASE = "http://127.0.0.1:" + os.environ.get("APP_PORT", "8080") +RESULTS = [] + +try: + sys.stdout.reconfigure(errors="replace") +except AttributeError: + pass + + +def stamp(): + return datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S UTC") + + +def step(title, cmd, out_file, append=False, env=None, timeout=900): + """Выполнить команду, сохранить «$ команда + вывод» в evidence/.""" + print("\n== %s\n$ %s" % (title, " ".join(cmd)), flush=True) + started = time.monotonic() + try: + proc = subprocess.run(cmd, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, + timeout=timeout, env=dict(os.environ, **(env or {})), + encoding="utf-8", errors="replace") + output, rc = proc.stdout, proc.returncode + except subprocess.TimeoutExpired as exc: + output, rc = (exc.stdout or "") + "\nTIMEOUT", 124 + elapsed = time.monotonic() - started + shown = " ".join(c if c != PY else "python" for c in cmd).replace(str(ROOT) + os.sep, "") + text = "# %s | %s | exit %d | %.1fs\n$ %s\n%s\n" % (stamp(), title, rc, elapsed, shown, output.rstrip()) + path = EV / out_file + with path.open("a" if append else "w", encoding="utf-8") as f: + f.write(text + ("\n" if append else "")) + print(output.rstrip()[-1500:], flush=True) + RESULTS.append((title, rc, out_file)) + return rc, output + + +def instances_through_lb(n=20): + """Одна сессия, n запросов через LB -> какие реплики отвечали.""" + import base64 + import uuid + name = "inst_" + uuid.uuid4().hex[:12] + pw = "Inst-" + uuid.uuid4().hex + body = json.dumps({"username": name, "display_name": "Inst", "password": pw}).encode() + urlopen(Request(BASE + "/api/v1/users", data=body, headers={"Content-Type": "application/json"}), timeout=10) + cred = base64.b64encode((name + ":" + pw).encode()).decode() + sess = json.loads(urlopen(Request(BASE + "/api/v1/auth/sessions", data=b"", method="POST", + headers={"Authorization": "Basic " + cred}), timeout=10).read()) + lines = [] + for i in range(n): + with urlopen(Request(BASE + "/api/v1/users/me", headers={"Authorization": "Bearer " + sess["token"]}), timeout=5) as r: + lines.append("%2d %s X-Instance-Id=%s X-Request-Id=%s" % ( + i + 1, r.status, r.headers.get("X-Instance-Id"), r.headers.get("X-Request-Id"))) + return lines + + +def main(): + ap = argparse.ArgumentParser() + ap.add_argument("--quick", action="store_true") + args = ap.parse_args() + EV.mkdir(exist_ok=True) + (EV / "ops.log").write_text("", encoding="utf-8") + + step("Контракт (offline)", [PY, "scripts/check_contract.py"], "check.txt") + step("Compose config", ["docker", "compose", "--env-file", ".env", "config", "--quiet"], "check.txt", append=True) + step("Стенд: контейнеры", ["docker", "compose", "--env-file", ".env", "ps", "-a"], "stand.txt") + step("Стенд: реплики и статус в LB", [PY, "scripts/ops.py", "ps"], "stand.txt", append=True) + step("Стенд: лимиты CPU/RAM", ["docker", "stats", "--no-stream", "--format", + "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}"], "stand.txt", append=True) + step("Стенд: опубликованные порты (только lb)", ["docker", "compose", "--env-file", ".env", "ps", + "--format", "table {{.Service}}\t{{.Ports}}"], "stand.txt", append=True) + + lines = instances_through_lb() + (EV / "instances.txt").write_text("# %s | одна сессия, 20 запросов GET /users/me через LB\n%s\nразных реплик: %d\n" + % (stamp(), "\n".join(lines), len({l.split("X-Instance-Id=")[1].split()[0] for l in lines})), + encoding="utf-8") + print("\n".join(lines)) + + step("Публичный smoke", [PY, "tests/smoke.py", "--base-url", BASE], "smoke.txt") + step("Собственные тесты (HTTP через LB)", [PY, "student-tests/run_all.py", "--base-url", BASE], "student-tests.txt") + step("Тесты с доступом к БД (внутри compose-сети)", [PY, "scripts/ops.py", "in-network", "storage"], + "student-tests.txt", append=True) + step("Истечение сессии (api-short-ttl, TTL 2 с)", [PY, "scripts/ops.py", "in-network", "expiry"], + "student-tests.txt", append=True) + + # Публичный тест останавливает реплику, обслужившую его первое сообщение. + # Round-robin детерминирован, поэтому для второй реплики сдвигаем очередь + # лишними запросами, пока цель не окажется другой (README: «повторить для второй»). + targets = [] + for i in range(1, 5): + if len(set(targets)) >= 2: + break + for _ in range(i - 1): + urlopen(BASE + "/health/live", timeout=5).read() + step("Failover #%d: реплики до" % i, [PY, "scripts/ops.py", "ps"], "failover.txt", append=i > 1) + step("Failover #%d: make test-failover" % i, + [PY, "tests/resilience.py", "--mode", "failover", "--action-script", HOOK_STOP, "--base-url", BASE], + "failover.txt", append=True) + step("Failover #%d: реплики после (остановлена именно цель теста)" % i, [PY, "scripts/ops.py", "ps"], + "failover.txt", append=True) + step("Failover #%d: restore" % i, [PY, "scripts/ops.py", "restore"], "failover.txt", append=True) + stops = [l for l in (EV / "ops.log").read_text(encoding="utf-8").splitlines() if "stop-one: mode=" in l] + if stops: + targets.append(stops[-1].split("target=")[1].split()[0]) + with (EV / "failover.txt").open("a", encoding="utf-8") as f: + f.write("# остановленные публичным тестом реплики: %s\n" % targets) + + step("Серия отказов: каждая реплика, graceful stop", [PY, "student-tests/failover_series.py", "--base-url", BASE, + "--output", "evidence/failover_series.json"], "failover_series.txt") + if not args.quick: + step("Серия отказов: каждая реплика, SIGKILL", [PY, "student-tests/failover_series.py", "--base-url", BASE, + "--mode", "kill", "--output", "evidence/failover_series_kill.json"], + "failover_series.txt", append=True) + + step("Rolling update lab3 -> lab3.1 под нагрузкой", + [PY, "student-tests/rolling_update_load.py", "--base-url", BASE, "--output", "evidence/rolling_update.json"], + "rolling_update.txt", env={"APP_VERSION": "lab3.1"}) + step("Rolling update обратно lab3.1 -> lab3 (откат) под нагрузкой", + [PY, "student-tests/rolling_update_load.py", "--base-url", BASE, "--output", "evidence/rolling_back.json"], + "rolling_update.txt", append=True, env={"APP_VERSION": "lab3"}) + step("Реплики после обновлений", [PY, "scripts/ops.py", "ps"], "rolling_update.txt", append=True) + + step("Persistence: контейнеры до", ["docker", "compose", "--env-file", ".env", "ps", "-a", "--format", + "table {{.Name}}\t{{.Status}}\t{{.RunningFor}}"], "persistence.txt") + step("Persistence: make test-persistence", + [PY, "tests/resilience.py", "--mode", "persistence", "--action-script", HOOK_RESTART, "--base-url", BASE], + "persistence.txt", append=True) + step("Persistence: контейнеры после (Status = Up N seconds)", ["docker", "compose", "--env-file", ".env", "ps", "-a", + "--format", "table {{.Name}}\t{{.Status}}\t{{.RunningFor}}"], + "persistence.txt", append=True) + + if not args.quick: + step("Нагрузка 30 с, concurrency 8", [PY, "tests/load.py", "--base-url", BASE, "--duration", "30", + "--concurrency", "8", "--output", "evidence/load.json"], "load.txt") + step("CPU/RAM после нагрузки", ["docker", "stats", "--no-stream", "--format", + "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}\t{{.MemPerc}}"], "load.txt", append=True) + + step("Лог LB (последние строки, без секретов)", ["docker", "compose", "--env-file", ".env", "logs", "--no-color", + "--tail", "60", "lb"], "lb_log_sample.txt") + + summary = ["# %s" % stamp()] + ["%-4s %-60s evidence/%s" % ("OK" if rc == 0 else "FAIL", t, f) for t, rc, f in RESULTS] + (EV / "SUMMARY.txt").write_text("\n".join(summary) + "\n", encoding="utf-8") + print("\n" + "\n".join(summary)) + sys.exit(0 if all(rc == 0 for _, rc, _ in RESULTS) else 1) + + +if __name__ == "__main__": + main() diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 0000000..49de415 --- /dev/null +++ b/scripts/init_secrets.py @@ -0,0 +1,45 @@ +#!/usr/bin/env python3 +"""Создаёт локальные учебные секреты в ./secrets (каталог в .gitignore). + +Повторный запуск ничего не перезаписывает: пароль PostgreSQL задаётся только +при первой инициализации volume, и смена файла сломала бы подключение. +Значения секретов не печатаются. +""" +import os +import secrets +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +DIR = ROOT / "secrets" + + +def write(name: str, value: str) -> None: + path = DIR / name + if path.exists(): + print("keep secrets/%s" % name) + return + path.write_text(value + "\n", encoding="utf-8") + # Каталог 0700, файлы 0644: внутри контейнера их читают непривилегированные + # пользователи (appuser, redis), а на хосте каталог закрыт. + os.chmod(path, 0o644) + print("create secrets/%s" % name) + + +def read(name: str) -> str: + return (DIR / name).read_text(encoding="utf-8").strip() + + +def main() -> None: + DIR.mkdir(exist_ok=True) + try: + os.chmod(DIR, 0o700) + except OSError: + pass + write("postgres_password", secrets.token_hex(24)) + write("redis_password", secrets.token_hex(24)) + write("database_url", "postgresql://messenger:%s@postgres:5432/messenger" % read("postgres_password")) + write("cache_url", "redis://:%s@redis:6379/0" % read("redis_password")) + + +if __name__ == "__main__": + main() diff --git a/scripts/ops.py b/scripts/ops.py new file mode 100644 index 0000000..02d16c5 --- /dev/null +++ b/scripts/ops.py @@ -0,0 +1,398 @@ +#!/usr/bin/env python3 +"""Операции над compose-стендом lab3. Python 3.9+, только стандартная библиотека. + +Работает одинаково в Windows (PowerShell/cmd), Linux и macOS: вызывает +`docker compose` и `docker` без shell-интерполяции. Секреты не печатает. + + python scripts/ops.py wait # дождаться N здоровых реплик и LB + python scripts/ops.py ps # реплики: контейнер, X-Instance-Id, health, статус в LB + python scripts/ops.py stop-one # TARGET_INSTANCE_ID=; оставляет остановленной + python scripts/ops.py restore # запустить остановленные реплики и дождаться UP в LB + python scripts/ops.py restart # hook persistence: API + PostgreSQL + Redis + LB, volumes целы + python scripts/ops.py rolling-update # поочерёдная замена реплик без остановки сервиса + python scripts/ops.py in-network storage # тесты с прямым доступом к БД — внутри compose-сети + python scripts/ops.py in-network expiry # истечение сессии на api-short-ttl (TTL 2 с) + +Переменные окружения: + COMPOSE_PROJECT_NAME имя проекта (по умолчанию messenger-lab3, как `name:` в compose.yaml) + ENV_FILE файл переменных (по умолчанию .env, если существует) + API_REPLICAS ожидаемое число реплик (по умолчанию из .env, иначе 2) + APP_PORT, LB_STATS_PORT опубликованные на 127.0.0.1 порты LB (8080, 8404) + STOP_MODE stop-one: stop (SIGTERM, graceful, по умолчанию) | kill (SIGKILL, «падение») + +Каждое действие дописывается в evidence/ops.log (время, контейнер, результат) — +это доказательство того, какой контейнер реально остановлен/заменён. +""" +import csv +import io +import json +import os +import subprocess +import sys +import time +import urllib.error +import urllib.request +from datetime import datetime, timezone +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +OPS_LOG = ROOT / "evidence" / "ops.log" + +try: # консоль Windows может быть не в UTF-8 + sys.stdout.reconfigure(errors="replace") + sys.stderr.reconfigure(errors="replace") +except AttributeError: + pass + + +# ---------------------------------------------------------------- settings + +def _dotenv(): + path = Path(os.environ.get("ENV_FILE", str(ROOT / ".env"))) + values = {} + if path.is_file(): + for line in path.read_text(encoding="utf-8").splitlines(): + line = line.strip() + if line and not line.startswith("#") and "=" in line: + k, v = line.split("=", 1) + values[k.strip()] = v.strip().strip('"').strip("'") + return path if path.is_file() else None, values + + +ENV_PATH, DOTENV = _dotenv() + + +def setting(name, default): + return os.environ.get(name) or DOTENV.get(name) or default + + +PROJECT = setting("COMPOSE_PROJECT_NAME", "messenger-lab3") +REPLICAS = int(setting("API_REPLICAS", "2")) +APP_PORT = int(setting("APP_PORT", "8080")) +STATS_PORT = int(setting("LB_STATS_PORT", "8404")) +LB_URL = "http://127.0.0.1:%d" % APP_PORT +STATS_URL = "http://127.0.0.1:%d/stats;csv" % STATS_PORT + + +def now_iso(): + return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" + + +def log(msg): + line = "%s %s" % (now_iso(), msg) + print(line, flush=True) + try: + OPS_LOG.parent.mkdir(exist_ok=True) + with OPS_LOG.open("a", encoding="utf-8") as f: + f.write(line + "\n") + except OSError: + pass + + +# ---------------------------------------------------------------- docker + +def compose_cmd(*args): + cmd = ["docker", "compose", "-p", PROJECT] + if ENV_PATH: + cmd += ["--env-file", str(ENV_PATH)] + return cmd + list(args) + + +def run(cmd, check=True, capture=False, timeout=300, show=False): + """capture: вернуть вывод; show: показать вывод в консоли; иначе — тихо.""" + out = None if show else (subprocess.PIPE if capture else subprocess.DEVNULL) + result = subprocess.run( + cmd, cwd=ROOT, check=False, timeout=timeout, + stdout=out, stderr=out, text=True, + ) + if check and result.returncode != 0: + detail = (result.stderr or "").strip()[-400:] if capture else "" + raise SystemExit("command failed (%d): %s %s" % (result.returncode, " ".join(cmd[:4]), detail)) + return result + + +def compose(*args, timeout=300): + return run(compose_cmd(*args), timeout=timeout, capture=True) + + +def api_containers(include_stopped=True): + """[{id, short, name, state, health, image, ip}] — только сервис api, без one-off.""" + cmd = ["docker", "ps", "--no-trunc", "--format", "{{.ID}}", + "--filter", "label=com.docker.compose.project=" + PROJECT, + "--filter", "label=com.docker.compose.service=api", + "--filter", "label=com.docker.compose.oneoff=False"] + if include_stopped: + cmd.insert(2, "-a") + ids = [x for x in run(cmd, capture=True).stdout.split() if x] + if not ids: + return [] + raw = run(["docker", "inspect"] + ids, capture=True).stdout + result = [] + for item in json.loads(raw): + state = item["State"] + nets = item.get("NetworkSettings", {}).get("Networks") or {} + ips = [n.get("IPAddress") for n in nets.values() if n.get("IPAddress")] + result.append({ + "id": item["Id"], + "short": item["Id"][:12], + "hostname": item["Config"].get("Hostname", ""), + "name": item["Name"].lstrip("/"), + "state": state.get("Status"), + "health": (state.get("Health") or {}).get("Status", "-"), + "image": item["Config"].get("Image"), + "ip": ips[0] if ips else "", + "created": item.get("Created", "")[:19], + }) + result.sort(key=lambda c: c["name"]) + return result + + +def running(containers=None): + return [c for c in (containers if containers is not None else api_containers()) if c["state"] == "running"] + + +# ---------------------------------------------------------------- load balancer + +def lb_servers(): + """[{name, status, addr}] backend api из CSV-статистики HAProxy (слоты с адресом).""" + data = urllib.request.urlopen(STATS_URL, timeout=2).read().decode("utf-8", "replace") + rows = csv.DictReader(io.StringIO(data.lstrip("# "))) + servers = [] + for r in rows: + if r.get("pxname") != "api" or r.get("svname") in ("BACKEND", "FRONTEND"): + continue + addr = r.get("addr") or "" + status = r.get("status", "") + if status.startswith("MAINT") and not addr: + continue # пустой слот server-template + servers.append({"name": r["svname"], "status": status, "addr": addr}) + return servers + + +def lb_up_count(): + return sum(1 for s in lb_servers() if s["status"].startswith("UP")) + + +def lb_ready(): + try: + with urllib.request.urlopen(LB_URL + "/health/ready", timeout=2) as r: + return r.status == 200 + except (urllib.error.URLError, OSError): + return False + + +def wait_until(predicate, timeout, what, interval=0.3): + deadline = time.monotonic() + timeout + last_exc = None + while time.monotonic() < deadline: + try: + if predicate(): + return True + except (urllib.error.URLError, OSError, ValueError, KeyError) as exc: + last_exc = exc + time.sleep(interval) + raise SystemExit("timeout after %ss waiting for %s%s" % ( + timeout, what, (" (%s)" % type(last_exc).__name__) if last_exc else "")) + + +def wait_healthy(ids, timeout=90): + def ok(): + states = {c["id"]: c for c in api_containers()} + return all(states.get(i, {}).get("health") == "healthy" for i in ids) + wait_until(ok, timeout, "containers healthy: " + ", ".join(i[:12] for i in ids)) + + +def wait_stack(replicas, timeout=120): + wait_until(lambda: len([c for c in running() if c["health"] == "healthy"]) >= replicas, + timeout, "%d healthy api replicas" % replicas) + wait_until(lambda: lb_up_count() >= replicas, 30, "%d replicas UP in HAProxy" % replicas) + wait_until(lb_ready, 30, "LB /health/ready = 200") + + +# ---------------------------------------------------------------- commands + +def cmd_wait(_args): + t0 = time.monotonic() + wait_stack(REPLICAS) + print("ready: %d api replicas healthy and UP in LB (%.1fs)" % (REPLICAS, time.monotonic() - t0)) + + +def cmd_ps(_args): + containers = api_containers() + try: + by_addr = {s["addr"].rsplit(":", 1)[0]: s for s in lb_servers()} + except (urllib.error.URLError, OSError): + by_addr = {} + print("%-14s %-28s %-9s %-10s %-22s %-6s %s" % ("X-Instance-Id", "container", "state", "health", "image", "lb", "lb_status")) + for c in containers: + s = by_addr.get(c["ip"], {}) + print("%-14s %-28s %-9s %-10s %-22s %-6s %s" % ( + c["hostname"], c["name"], c["state"], c["health"], c["image"], s.get("name", "-"), s.get("status", "-"))) + + +def find_target(target): + for c in api_containers(): + # X-Instance-Id = hostname контейнера = первые 12 символов его ID. + if target and (c["hostname"] == target or c["id"].startswith(target)): + return c + return None + + +def cmd_stop_one(_args): + target = os.environ.get("TARGET_INSTANCE_ID", "").strip() + if not target: + raise SystemExit("TARGET_INSTANCE_ID is required (X-Instance-Id of the replica to stop)") + mode = os.environ.get("STOP_MODE", "stop").strip().lower() + c = find_target(target) + if c is None: + raise SystemExit("no api container of project %s matches X-Instance-Id %s" % (PROJECT, target)) + if c["state"] != "running": + raise SystemExit("container %s is already %s" % (c["name"], c["state"])) + t0 = time.monotonic() + log("stop-one: mode=%s target=%s container=%s ip=%s" % (mode, target, c["name"], c["ip"])) + if mode == "kill": + # «Падение» процесса. Политику restart снимаем, чтобы Docker не поднял + # контейнер сам: тест требует, чтобы реплика оставалась остановленной. + run(["docker", "update", "--restart", "no", c["id"]]) + run(["docker", "kill", "--signal", "KILL", c["id"]]) + else: + # SIGTERM -> осушение 3 с (readiness 503) -> graceful stop; SIGKILL не позже 20 с. + run(["docker", "stop", "--time", "20", c["id"]], timeout=40) + after = find_target(target) or {} + log("stop-one: container=%s state=%s after %.2fs; left stopped (restore: python scripts/ops.py restore)" + % (c["name"], after.get("state", "removed"), time.monotonic() - t0)) + + +def cmd_restore(_args): + t0 = time.monotonic() + stopped = [c for c in api_containers() if c["state"] != "running"] + for c in stopped: # вернуть политику, снятую в режиме kill + run(["docker", "update", "--restart", "unless-stopped", c["id"]], check=False) + # --no-recreate: не пересоздавать работающие; up запускает остановленные + # и добирает число контейнеров до deploy.replicas. + compose("up", "-d", "--no-deps", "--no-recreate", "api") + wait_stack(REPLICAS) + log("restore: started %s; %d replicas healthy and UP in LB after %.1fs" + % ([c["name"] for c in stopped] or "nothing", REPLICAS, time.monotonic() - t0)) + + +def cmd_restart(_args): + """Hook для make test-persistence: перезапуск API, ВСЕХ хранилищ и LB. + + Volumes не удаляются, данные не пересоздаются. Порядок: сначала LB и API + (новые записи не принимаются), затем PostgreSQL (штатный shutdown с + checkpoint) и Redis, затем API и LB в порядке зависимостей. + """ + t0 = time.monotonic() + before = {c["name"]: c["short"] for c in running()} + pg_before = container_started("postgres") + redis_before = container_started("redis") + compose("stop", "lb", "api", timeout=120) + compose("restart", "postgres", "redis", timeout=120) + compose("start", "api", timeout=120) + wait_until(lambda: len([c for c in running() if c["health"] == "healthy"]) >= REPLICAS, + 80, "api healthy after restart") + compose("start", "lb", timeout=60) + log("restart: postgres started_at %s -> %s; redis %s -> %s; api %s restarted; lb restarted; %.1fs" + % (pg_before, container_started("postgres"), redis_before, container_started("redis"), + sorted(before), time.monotonic() - t0)) + + +def container_started(service): + ids = run(["docker", "ps", "-aq", "--filter", "label=com.docker.compose.project=" + PROJECT, + "--filter", "label=com.docker.compose.service=" + service], capture=True).stdout.split() + if not ids: + return "-" + return run(["docker", "inspect", "-f", "{{.State.StartedAt}}", ids[0]], capture=True).stdout.strip()[:23] + + +def cmd_rolling_update(args): + """Поочерёдная замена реплик: +1 новая -> healthy и UP в LB -> graceful stop старой. + + В любой момент в ротации >= N реплик. Миграции — один раз, до замены, и только + расширяющие (expand): старая версия продолжает работать на новой схеме. + """ + t_all = time.monotonic() + if [c for c in api_containers() if c["state"] != "running"]: + raise SystemExit("some api containers are stopped; run `python scripts/ops.py restore` first") + old = running() + n = len(old) + if n < 1: + raise SystemExit("no running api replicas") + log("rolling-update: start; replicas=%d old=%s" % (n, [c["short"] for c in old])) + if "--no-build" not in args: + t = time.monotonic() + compose("build", "api", "migrate", timeout=900) + log("rolling-update: images built in %.1fs (tag %s)" % (time.monotonic() - t, setting("APP_VERSION", "lab3"))) + t = time.monotonic() + out = compose("run", "--rm", "-T", "migrate", timeout=300).stdout.strip().splitlines() + log("rolling-update: migrations once in %.1fs: %s" % (time.monotonic() - t, out[-1] if out else "")) + for i, victim in enumerate(old, 1): + before = {c["id"] for c in api_containers()} + t = time.monotonic() + compose("up", "-d", "--no-deps", "--no-recreate", "--scale", "api=%d" % (n + 1), "api", timeout=180) + new = [c for c in api_containers() if c["id"] not in before] + if len(new) != 1: + raise SystemExit("expected exactly one new container, got %d" % len(new)) + fresh = new[0] + wait_healthy([fresh["id"]], timeout=90) + wait_until(lambda: lb_up_count() >= n + 1, 30, "new replica UP in HAProxy") + t_ready = time.monotonic() - t + t = time.monotonic() + run(["docker", "stop", "--time", "20", victim["id"]], timeout=40) + run(["docker", "rm", victim["id"]]) + log("rolling-update: step %d/%d new=%s (%s, ready+UP in %.1fs) replaced old=%s (graceful stop %.1fs)" + % (i, n, fresh["short"], fresh["image"], t_ready, victim["short"], time.monotonic() - t)) + wait_stack(n) + log("rolling-update: done in %.1fs; replicas now %s" % (time.monotonic() - t_all, [c["short"] for c in running()])) + + +def cmd_in_network(args): + """Тесты, которым нужен прямой доступ к PostgreSQL/Redis или экземпляр api-short-ttl. + + Запускаются в one-off контейнере образа API внутри сети backend: порты БД и + реплик наружу не публикуются. One-off контейнер не получает DNS-имя `api`, + поэтому LB его не видит. + """ + which = args[0] if args else "" + mount = "%s:/app/student-tests:ro" % (ROOT / "student-tests") + base = compose_cmd("run", "--rm", "-T", "--no-deps", "-v", mount) + if which == "storage": + for pattern in ("test_storage_*.py", "test_session_cache.py"): + run(base + ["api", "python", "-m", "unittest", "discover", "-s", "student-tests", "-p", pattern, "-v"], + show=True, timeout=600) + elif which == "expiry": + prof = compose_cmd("--profile", "ttl") + run(prof + ["up", "-d", "--no-recreate", "api-short-ttl"], show=True, timeout=300) + env = ["-e", "EXPIRY_BASE_URL=http://api-short-ttl:8080", "-e", "BASE_URL=http://lb:8080"] + try: + run(base + env + ["api", "python", "student-tests/wait_url.py", "http://api-short-ttl:8080/health/ready"], + show=True, timeout=120) + run(base + env + ["api", "python", "-m", "unittest", "discover", "-s", "student-tests", + "-p", "test_expiry.py", "-v"], show=True, timeout=300) + finally: + run(prof + ["rm", "-sf", "api-short-ttl"], check=False, timeout=120) + else: + raise SystemExit("usage: python scripts/ops.py in-network storage|expiry") + + +COMMANDS = { + "wait": cmd_wait, + "ps": cmd_ps, + "stop-one": cmd_stop_one, + "restore": cmd_restore, + "restart": cmd_restart, + "rolling-update": cmd_rolling_update, + "in-network": cmd_in_network, +} + + +def main(): + if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS: + print(__doc__) + sys.exit(2) + COMMANDS[sys.argv[1]](sys.argv[2:]) + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..4b8e3ed --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,9 @@ +@echo off +rem Windows-вариант restart.sh: API + PostgreSQL + Redis + LB, volumes сохраняются. +rem python tests\resilience.py --mode persistence --action-script scripts\restart.cmd +setlocal +cd /d "%~dp0.." +set PY=python +where python >nul 2>nul || set PY=py -3 +%PY% scripts\ops.py restart +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 0000000..b6c12b9 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,8 @@ +#!/bin/sh +# Hook для make test-persistence: перезапускает API (все реплики), PostgreSQL, +# Redis и LB, сохраняя volumes. Никаких down -v / flush / повторного seed. +# Возвращает 0, когда API снова healthy; готовность LB тест ждёт сам. +set -eu +cd "$(dirname "$0")/.." +PY=$(command -v python3 || command -v python) +exec "$PY" scripts/ops.py restart diff --git a/scripts/sql/explain_history.sql b/scripts/sql/explain_history.sql new file mode 100644 index 0000000..d2ee413 --- /dev/null +++ b/scripts/sql/explain_history.sql @@ -0,0 +1,93 @@ +-- Обоснование индекса истории: EXPLAIN (ANALYZE, BUFFERS) на >= 10 000 сообщений. +-- Всё выполняется в ОДНОЙ транзакции и откатывается (ROLLBACK): синтетические +-- данные и временное удаление индекса не остаются в БД. +-- Запуск (compose): +-- docker compose exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 \ +-- < scripts/sql/explain_history.sql > evidence/explain_history.txt +-- Внимание: DROP INDEX внутри транзакции берёт эксклюзивную блокировку messages +-- до ROLLBACK (несколько секунд) — запускать на учебном стенде. + +\set ON_ERROR_STOP 1 +\timing off +SET TimeZone = 'UTC'; +-- Убираем мёртвые версии строк от прошлых запусков (VACUUM нельзя внутри транзакции). +VACUUM (ANALYZE) messages, chat_members, chats, users; +BEGIN; + +INSERT INTO users (id, username, display_name, password_hash) +VALUES ('00000000-0000-4000-8000-00000000e001', 'explain_alice', 'Explain', 'x'), + ('00000000-0000-4000-8000-00000000e002', 'explain_bob', 'Explain', 'x'); + +-- 1 большой чат (12 000 сообщений) + 40 чатов по 1 000 = 52 000 сообщений. +INSERT INTO chats (id, title, created_at) +SELECT CASE WHEN g = 0 THEN '00000000-0000-4000-8000-0000000c0000'::uuid ELSE gen_random_uuid() END, + 'explain-' || g, timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second' +FROM generate_series(0, 40) AS g; + +INSERT INTO chat_members (chat_id, user_id, position) +SELECT c.id, u.id, u.pos +FROM chats c +CROSS JOIN (VALUES ('00000000-0000-4000-8000-00000000e001'::uuid, 0), + ('00000000-0000-4000-8000-00000000e002'::uuid, 1)) AS u(id, pos) +WHERE c.title LIKE 'explain-%'; + +INSERT INTO messages (id, chat_id, sender_id, text, created_at) +SELECT gen_random_uuid(), c.id, + CASE WHEN g % 2 = 0 THEN '00000000-0000-4000-8000-00000000e001'::uuid + ELSE '00000000-0000-4000-8000-00000000e002'::uuid END, + 'synthetic message ' || g, + timestamptz '2026-01-02 00:00:00+00' + g * interval '1 millisecond' + (c.created_at - timestamptz '2026-01-01 00:00:00+00') +FROM chats c +CROSS JOIN LATERAL generate_series(1, CASE WHEN c.title = 'explain-0' THEN 12000 ELSE 1000 END) AS g +WHERE c.title LIKE 'explain-%'; + +ANALYZE users, chats, chat_members, messages; + +\echo '=== dataset' +SELECT count(*) AS total_messages, + count(*) FILTER (WHERE chat_id = '00000000-0000-4000-8000-0000000c0000') AS big_chat_messages +FROM messages; + +-- Позиция курсора после 10 000-го сообщения большого чата (как в next_cursor). +SELECT created_at AS cur_ts, id AS cur_id +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' +ORDER BY created_at, id OFFSET 9999 LIMIT 1 \gset + +\echo '=== 1. first page (no cursor), LIMIT 51 = limit+1' +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' +ORDER BY created_at, id +LIMIT 51; + +\echo '=== 2. deep page: keyset cursor after message #10000 (query used by API)' +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' + AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id +LIMIT 51; + +\echo '=== 3. for comparison: OFFSET pagination to the same page (NOT used by API)' +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' +ORDER BY created_at, id +OFFSET 10000 LIMIT 51; + +\echo '=== 4. same keyset query WITHOUT messages_chat_created_id_idx (index dropped inside the transaction)' +DROP INDEX messages_chat_created_id_idx; +EXPLAIN (ANALYZE, BUFFERS, COSTS, TIMING) +SELECT id, chat_id, sender_id, text, created_at +FROM messages +WHERE chat_id = '00000000-0000-4000-8000-0000000c0000' + AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid) +ORDER BY created_at, id +LIMIT 51; + +ROLLBACK; +\echo '=== rolled back: synthetic data removed, index restored' diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 0000000..1bd3049 --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,9 @@ +@echo off +rem Windows-вариант stop-one.sh: TARGET_INSTANCE_ID -> один контейнер api, остаётся остановленным. +rem python tests\resilience.py --mode failover --action-script scripts\stop-one.cmd +setlocal +cd /d "%~dp0.." +set PY=python +where python >nul 2>nul || set PY=py -3 +%PY% scripts\ops.py stop-one +exit /b %ERRORLEVEL% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 0000000..6a86861 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,10 @@ +#!/bin/sh +# Hook для make test-failover: останавливает ОДНУ API-реплику, которую тест передал +# в TARGET_INSTANCE_ID (= X-Instance-Id = hostname контейнера = короткий ID), и +# оставляет её остановленной. По умолчанию graceful (docker stop: SIGTERM -> +# осушение 3 с -> graceful shutdown); STOP_MODE=kill — «падение» (SIGKILL). +# БД, Redis, LB и volumes не трогает. Восстановление: python3 scripts/ops.py restore +set -eu +cd "$(dirname "$0")/.." +PY=$(command -v python3 || command -v python) +exec "$PY" scripts/ops.py stop-one diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/config.py b/src/config.py new file mode 100644 index 0000000..5963d18 --- /dev/null +++ b/src/config.py @@ -0,0 +1,122 @@ +"""Конфигурация из переменных окружения. + +Секреты (строки подключения с паролями) читаются из файлов *_FILE, +которые Compose монтирует как secrets в /run/secrets/. Для локального +запуска без Docker допускаются и прямые переменные DATABASE_URL / CACHE_URL. +""" +import os +from dataclasses import dataclass +from typing import Optional + + +def _read_secret(name: str) -> Optional[str]: + path = os.environ.get(name + "_FILE") + if path: + with open(path, "r", encoding="utf-8") as handle: + value = handle.read().strip() + return value or None + value = os.environ.get(name, "").strip() + return value or None + + +def _int(name: str, default: int) -> int: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + return int(raw) + + +def _float(name: str, default: float) -> float: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + return float(raw) + + +def _bool(name: str, default: bool) -> bool: + raw = os.environ.get(name) + if raw is None or raw.strip() == "": + return default + return raw.strip().lower() in {"1", "true", "yes", "on"} + + +@dataclass(frozen=True) +class Settings: + app_env: str + app_version: str + instance_id: str + database_url: str + cache_url: Optional[str] + session_store: str + session_ttl_seconds: int + session_cache_ttl_seconds: int + db_pool_min: int + db_pool_max: int + db_pool_timeout: float + db_connect_timeout: int + db_statement_timeout_ms: int + cache_timeout_seconds: float + cache_retry_after_seconds: float + migrate_wait_seconds: int + run_migrations_on_start: bool + idempotency_ttl_seconds: int + idempotency_cleanup_interval_seconds: int + ready_db_timeout_seconds: float + drain_seconds: float + graceful_timeout_seconds: int + keep_alive_seconds: int + password_hash_concurrency: int + + +def load_settings() -> Settings: + database_url = _read_secret("DATABASE_URL") + if not database_url: + raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE must be set") + + ttl = _int("SESSION_TTL_SECONDS", 3600) + if ttl < 1: + raise RuntimeError("SESSION_TTL_SECONDS must be positive") + + session_store = os.environ.get("SESSION_STORE", "postgres").strip().lower() + # Источник истины для сессий в этой реализации всегда PostgreSQL; + # Redis (CACHE_URL) — только кэш проверок токена. + if session_store != "postgres": + raise RuntimeError("only SESSION_STORE=postgres is supported") + + idem_ttl = _int("IDEMPOTENCY_TTL_SECONDS", 86400) + if idem_ttl < 86400: + # Контракт: повтор в течение 24 часов возвращает тот же результат. + raise RuntimeError("IDEMPOTENCY_TTL_SECONDS must be >= 86400") + + # X-Instance-Id: по умолчанию hostname контейнера (= короткий ID контейнера + # Docker), стабилен в пределах жизни процесса. INSTANCE_ID — для запуска без Docker. + from .runtime import INSTANCE_ID as instance_id + + return Settings( + app_env=os.environ.get("APP_ENV", "lab"), + app_version=os.environ.get("APP_VERSION", "lab3"), + instance_id=instance_id, + database_url=database_url, + cache_url=_read_secret("CACHE_URL"), + session_store=session_store, + session_ttl_seconds=ttl, + session_cache_ttl_seconds=_int("SESSION_CACHE_TTL_SECONDS", 60), + db_pool_min=_int("DB_POOL_MIN", 1), + db_pool_max=_int("DB_POOL_MAX", 10), + db_pool_timeout=_float("DB_POOL_TIMEOUT_SECONDS", 3.0), + db_connect_timeout=_int("DB_CONNECT_TIMEOUT_SECONDS", 3), + db_statement_timeout_ms=_int("DB_STATEMENT_TIMEOUT_MS", 5000), + cache_timeout_seconds=_float("CACHE_TIMEOUT_SECONDS", 0.25), + cache_retry_after_seconds=_float("CACHE_RETRY_AFTER_SECONDS", 5.0), + migrate_wait_seconds=_int("MIGRATE_WAIT_SECONDS", 60), + # lab3: миграции выполняет отдельный one-shot сервис `migrate`, + # реплики API их не запускают (нет гонки N реплик за схему). + run_migrations_on_start=_bool("RUN_MIGRATIONS_ON_START", False), + idempotency_ttl_seconds=idem_ttl, + idempotency_cleanup_interval_seconds=_int("IDEMPOTENCY_CLEANUP_INTERVAL_SECONDS", 300), + ready_db_timeout_seconds=_float("READY_DB_TIMEOUT_SECONDS", 1.0), + drain_seconds=_float("DRAIN_SECONDS", 3.0), + graceful_timeout_seconds=_int("GRACEFUL_TIMEOUT_SECONDS", 10), + keep_alive_seconds=_int("KEEP_ALIVE_SECONDS", 30), + password_hash_concurrency=_int("PASSWORD_HASH_CONCURRENCY", 4), + ) diff --git a/src/db.py b/src/db.py new file mode 100644 index 0000000..d8d413b --- /dev/null +++ b/src/db.py @@ -0,0 +1,130 @@ +"""Пул соединений PostgreSQL и версионируемые миграции.""" +import logging +import time +from pathlib import Path +from typing import Optional + +import psycopg +from psycopg_pool import ConnectionPool + +from .config import Settings + +log = logging.getLogger("messenger.db") + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + +# Произвольная константа: один процесс за раз применяет миграции, +# даже если одновременно стартуют несколько реплик API (lab3). +MIGRATION_LOCK_ID = 2026_0002 + + +def conninfo_kwargs(settings: Settings) -> dict: + return { + "connect_timeout": settings.db_connect_timeout, + # Все timestamptz приходят в UTC; любой запрос ограничен по времени. + "options": "-c TimeZone=UTC -c statement_timeout=%d" + % settings.db_statement_timeout_ms, + "application_name": "messenger-api", + } + + +def create_pool(settings: Settings) -> ConnectionPool: + pool = ConnectionPool( + conninfo=settings.database_url, + kwargs=conninfo_kwargs(settings), + min_size=settings.db_pool_min, + max_size=settings.db_pool_max, + # Сколько запрос ждёт свободное соединение, прежде чем получить 503. + timeout=settings.db_pool_timeout, + # Битые после рестарта БД соединения отбрасываются при выдаче из пула. + check=ConnectionPool.check_connection, + max_idle=300, + reconnect_timeout=3600, + open=False, + name="messenger", + ) + # wait=False: процесс поднимается, даже если БД ещё/уже недоступна; + # readiness это покажет, а запросы получат 503. + pool.open(wait=False) + return pool + + +def _migration_files(): + files = sorted(MIGRATIONS_DIR.glob("*.sql")) + if not files: + raise RuntimeError("no migrations found in %s" % MIGRATIONS_DIR) + return files + + +def required_schema_version() -> str: + """Последняя миграция, которую знает этот образ. + + Реплика готова (readiness) только если она уже применена: миграции + запускает отдельный сервис `migrate`, а не сама реплика. + """ + return _migration_files()[-1].stem + + +def schema_has_version(pool: ConnectionPool, version: str, timeout: float) -> bool: + with pool.connection(timeout=timeout) as conn: + row = conn.execute( + "SELECT to_regclass('schema_migrations') IS NOT NULL" + ).fetchone() + if not row[0]: + return False + return conn.execute( + "SELECT EXISTS (SELECT 1 FROM schema_migrations WHERE version = %s)", + (version,), + ).fetchone()[0] + + +def apply_migrations(settings: Settings) -> list: + """Применяет недостающие миграции; возвращает список применённых версий.""" + applied_now = [] + with psycopg.connect( + settings.database_url, autocommit=True, **conninfo_kwargs(settings) + ) as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK_ID,)) + try: + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() + ) + """ + ) + done = { + row[0] + for row in conn.execute("SELECT version FROM schema_migrations") + } + for path in _migration_files(): + version = path.stem + if version in done: + continue + sql = path.read_text(encoding="utf-8") + # DDL и отметка о версии — одна транзакция: либо всё, либо ничего. + with conn.transaction(): + conn.execute(sql) + conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", + (version,), + ) + applied_now.append(version) + log.info("applied migration %s", version) + finally: + conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK_ID,)) + return applied_now + + +def wait_and_migrate(settings: Settings) -> list: + deadline = time.monotonic() + settings.migrate_wait_seconds + last_error: Optional[Exception] = None + while time.monotonic() < deadline: + try: + return apply_migrations(settings) + except psycopg.OperationalError as exc: + last_error = exc + log.warning("database not ready for migrations, retrying") + time.sleep(1) + raise RuntimeError("database unavailable for migrations") from last_error diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..be9c4c6 --- /dev/null +++ b/src/main.py @@ -0,0 +1,482 @@ +import base64 +import hashlib +import json +import logging +import re +import threading +from contextlib import asynccontextmanager +from datetime import datetime +from typing import Callable, Dict, Optional, Tuple +from uuid import UUID, uuid4 + +import psycopg +from fastapi import Depends, FastAPI, Query, Request, Response +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from psycopg_pool import PoolTimeout +from starlette.exceptions import HTTPException as StarletteHTTPException +from starlette.middleware.base import BaseHTTPMiddleware + +from .config import load_settings +from .db import create_pool, required_schema_version, schema_has_version, wait_and_migrate +from .models import ( + Chat, + ChatCreate, + ChatPage, + Message, + MessageCreate, + MessagePage, + Session, + User, + UserCreate, +) +from .runtime import DRAIN, INSTANCE_ID +from .security import ( + configure_kdf_concurrency, + hash_password, + parse_basic, + parse_bearer, + verify_password, +) +from .sessions import SessionCache, SessionService +from .storage import ( + IdempotencyConflict, + IdempotencyRace, + NotChatMember, + Storage, + UnknownMember, + UsernameTaken, +) + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s") +log = logging.getLogger("messenger.api") + +BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"' +BEARER_CHALLENGE = 'Bearer realm="messenger"' +REQUEST_ID_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") +# Контракт lab3: Idempotency-Key — ASCII [A-Za-z0-9._:-]{1,128}. +IDEMPOTENCY_KEY_RE = re.compile(r"[A-Za-z0-9._:-]{1,128}") + + +def _idempotency_cleanup_loop(storage: Storage, interval: float, stop: threading.Event) -> None: + """Фоновая очистка истёкших ключей. Advisory lock — одна реплика за раз.""" + while not stop.wait(interval): + try: + deleted = storage.delete_expired_idempotency_keys() + if deleted: + log.info("deleted %d expired idempotency keys", deleted) + except Exception as exc: # БД недоступна — попробуем в следующий раз + log.warning("idempotency cleanup skipped: %s", type(exc).__name__) + + +@asynccontextmanager +async def lifespan(app: FastAPI): + settings = load_settings() + if settings.run_migrations_on_start: + # Только для локальной разработки. В compose миграции выполняет + # отдельный one-shot сервис `migrate` до старта реплик. + applied = wait_and_migrate(settings) + log.info("migrations applied at startup: %s", applied or "none") + configure_kdf_concurrency(settings.password_hash_concurrency) + pool = create_pool(settings) + storage = Storage(pool) + cache = SessionCache(settings) + app.state.settings = settings + app.state.storage = storage + app.state.cache = cache + app.state.sessions = SessionService(storage, cache, settings) + app.state.required_schema = required_schema_version() + app.state.schema_ok = False + stop_cleanup = threading.Event() + cleanup = threading.Thread( + target=_idempotency_cleanup_loop, + args=(storage, settings.idempotency_cleanup_interval_seconds, stop_cleanup), + name="idempotency-cleanup", + daemon=True, + ) + cleanup.start() + log.info( + "started: instance=%s version=%s session_ttl=%ss cache=%s pool=%s..%s schema>=%s", + INSTANCE_ID, + settings.app_version, + settings.session_ttl_seconds, + "redis" if cache.client is not None else "disabled", + settings.db_pool_min, + settings.db_pool_max, + app.state.required_schema, + ) + try: + yield + finally: + log.info("shutdown: instance=%s closing pool", INSTANCE_ID) + stop_cleanup.set() + pool.close() + if cache.client is not None: + cache.client.close() + + +app = FastAPI( + title="MTUSI Messenger (lab3: LB + replicas)", + version="3.0.0", + lifespan=lifespan, +) + + +# Request ID + +class RequestIdMiddleware(BaseHTTPMiddleware): + async def dispatch(self, request: Request, call_next: Callable): + incoming = request.headers.get("X-Request-Id", "") + request_id = incoming if REQUEST_ID_RE.match(incoming) else str(uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + if DRAIN.active: + # Во время осушения не держим keep-alive: следующий запрос клиент/LB + # откроет новым соединением — уже к другой реплике. + response.headers["Connection"] = "close" + return response + + +app.add_middleware(RequestIdMiddleware) + + +# errors + +class ApiError(Exception): + def __init__(self, status_code: int, code: str, message: str, headers: Optional[Dict[str, str]] = None): + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers or {} + + +def unauthorized(challenge: str = BEARER_CHALLENGE) -> ApiError: + return ApiError(401, "unauthorized", "Authentication required", {"WWW-Authenticate": challenge}) + + +def bad_request(message: str = "Invalid request") -> ApiError: + return ApiError(400, "invalid_request", message) + + +def not_found() -> ApiError: + return ApiError(404, "not_found", "Not found") + + +def error_response( + request: Request, + status_code: int, + code: str, + message: str, + headers: Optional[Dict[str, str]] = None, +) -> JSONResponse: + request_id = getattr(request.state, "request_id", None) or str(uuid4()) + all_headers = {"X-Request-Id": request_id, "X-Instance-Id": INSTANCE_ID} + all_headers.update(headers or {}) + return JSONResponse( + status_code=status_code, + content={"error": {"code": code, "message": message, "request_id": request_id}}, + headers=all_headers, + ) + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError) -> JSONResponse: + return error_response(request, exc.status_code, exc.code, exc.message, exc.headers) + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse: + return error_response(request, 400, "invalid_request", "Invalid request") + + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse: + status_to_code = { + 400: "invalid_request", + 401: "unauthorized", + 404: "not_found", + 409: "conflict", + 413: "payload_too_large", + 415: "unsupported_media_type", + 429: "rate_limited", + 503: "unavailable", + } + status_code = exc.status_code if exc.status_code in status_to_code else 500 + code = status_to_code.get(status_code, "internal_error") + message = str(exc.detail) if status_code != 500 else "Internal server error" + return error_response(request, status_code, code, message) + + +async def dependency_unavailable(request: Request, exc: Exception) -> JSONResponse: + # Наружу — только общий 503, без SQL, адресов и текста драйвера. + log.warning("database unavailable: %s", type(exc).__name__) + return error_response(request, 503, "unavailable", "Service temporarily unavailable") + + +app.add_exception_handler(psycopg.OperationalError, dependency_unavailable) +app.add_exception_handler(psycopg.InterfaceError, dependency_unavailable) +app.add_exception_handler(PoolTimeout, dependency_unavailable) + + +@app.exception_handler(Exception) +async def unexpected_exception_handler(request: Request, exc: Exception) -> JSONResponse: + log.exception("unexpected error") + return error_response(request, 500, "internal_error", "Internal server error") + + +# helpers + +def require_json_content_type(request: Request) -> None: + content_type = request.headers.get("content-type", "") + if not content_type.lower().startswith("application/json"): + raise ApiError(415, "unsupported_media_type", "Unsupported media type") + + +def ensure_not_blank(value: str) -> None: + if not value.strip(): + raise bad_request() + + +def storage_of(request: Request) -> Storage: + return request.app.state.storage + + +def current_user(request: Request) -> User: + """Только Authorization: Bearer. Basic и X-User-Id здесь не дают доступа.""" + token = parse_bearer(request.headers.get("Authorization")) + if token is None: + raise unauthorized() + user = request.app.state.sessions.resolve(token) + if user is None: + raise unauthorized() + request.state.token = token + return user + + +def encode_cursor(resource_id: UUID, created_at: datetime, item_id: UUID) -> str: + payload = { + "resource_id": str(resource_id), + "created_at": created_at.isoformat(), + "item_id": str(item_id), + } + raw = json.dumps(payload, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(cursor: Optional[str], expected_resource_id: UUID) -> Optional[Tuple[datetime, UUID]]: + if cursor is None: + return None + try: + padding = "=" * (-len(cursor) % 4) + raw = base64.urlsafe_b64decode(cursor + padding) + payload = json.loads(raw.decode("utf-8")) + resource_id = UUID(payload["resource_id"]) + created_at = datetime.fromisoformat(payload["created_at"]) + item_id = UUID(payload["item_id"]) + if created_at.tzinfo is None or created_at.utcoffset() is None: + raise ValueError("invalid_cursor") + except (ValueError, KeyError, TypeError, AttributeError, json.JSONDecodeError): + raise bad_request("Invalid cursor") + if resource_id != expected_resource_id: + raise bad_request("Invalid cursor") + return created_at, item_id + + +# health + +@app.get("/health/live", response_model=Dict[str, str]) +def liveness() -> Dict[str, str]: + return {"status": "ok"} + + +@app.get("/health/ready", response_model=Dict[str, str]) +def readiness(request: Request) -> Dict[str, str]: + """Готовность к обязательному синхронному пути. + + * SIGTERM получен (фаза осушения) -> 503: LB выводит реплику из ротации; + * PostgreSQL недоступна за READY_DB_TIMEOUT_SECONDS -> 503; + * схема ещё не мигрирована до версии, которую знает образ -> 503 + (миграции выполняет отдельный сервис `migrate`). + Redis не критичен: это кэш с обходом (см. REPORT.md). + """ + if DRAIN.active: + raise ApiError(503, "unavailable", "Instance is shutting down") + state = request.app.state + timeout = state.settings.ready_db_timeout_seconds + try: + if state.schema_ok: + with state.storage.pool.connection(timeout=timeout) as conn: + conn.execute("SELECT 1") + elif schema_has_version(state.storage.pool, state.required_schema, timeout): + state.schema_ok = True + else: + raise ApiError(503, "unavailable", "Database schema is not migrated") + except (psycopg.Error, PoolTimeout): + raise ApiError(503, "unavailable", "Database is not available") + return {"status": "ok"} + + +# users + +@app.post("/api/v1/users", response_model=User, status_code=201) +def register_user(request: Request, data: UserCreate) -> User: + require_json_content_type(request) + ensure_not_blank(data.display_name) + ensure_not_blank(data.password) + password_hash = hash_password(data.password) + try: + return storage_of(request).create_user(data.username, data.display_name, password_hash) + except UsernameTaken: + raise ApiError(409, "conflict", "Username already exists") + + +@app.get("/api/v1/users/me", response_model=User) +def get_current_user(user: User = Depends(current_user)) -> User: + return user + + +# sessions + +async def require_empty_body(request: Request) -> None: + """Вход — только заголовок Authorization: Basic, без тела (контракт). + + Любые байты в теле (JSON или нет) — 400. Проверка выполняется до + дорогой проверки пароля и до создания сессии. + """ + if await request.body(): + raise bad_request("Request body is not allowed") + + +@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201, + dependencies=[Depends(require_empty_body)]) +def create_session(request: Request) -> Session: + credentials = parse_basic(request.headers.get("Authorization")) + if credentials is None: + raise unauthorized(BASIC_CHALLENGE) + username, password = credentials + found = storage_of(request).get_credentials(username) + user, password_hash = found if found else (None, None) + # verify_password выполняется и для несуществующего username (с хешем-пустышкой). + if not verify_password(password_hash, password) or user is None: + raise unauthorized(BASIC_CHALLENGE) + token, expires_at = request.app.state.sessions.create(user) + return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user) + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def delete_current_session(request: Request, user: User = Depends(current_user)) -> Response: + if not request.app.state.sessions.revoke(request.state.token): + raise unauthorized() + return Response(status_code=204) + + +# chats + +@app.post("/api/v1/chats", response_model=Chat, status_code=201) +def create_chat(request: Request, data: ChatCreate, user: User = Depends(current_user)) -> Chat: + require_json_content_type(request) + ensure_not_blank(data.title) + if len(data.member_ids) != len(set(data.member_ids)): + raise bad_request("Duplicate member ids") + if user.id not in data.member_ids: + raise bad_request("Caller must be a chat member") + try: + return storage_of(request).create_chat(data.title, data.member_ids) + except UnknownMember: + raise bad_request("Unknown member") + + +@app.get("/api/v1/chats", response_model=ChatPage) +def list_chats( + request: Request, + user: User = Depends(current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +) -> ChatPage: + after = decode_cursor(cursor, user.id) + items, has_more = storage_of(request).list_user_chats(user.id, limit, after) + next_cursor = None + if has_more and items: + next_cursor = encode_cursor(user.id, items[-1].created_at, items[-1].id) + return ChatPage(items=items, next_cursor=next_cursor) + + +@app.get("/api/v1/chats/{chat_id}", response_model=Chat) +def get_chat(request: Request, chat_id: UUID, user: User = Depends(current_user)) -> Chat: + chat = storage_of(request).get_chat_for_member(chat_id, user.id) + if chat is None: + raise not_found() + return chat + + +# messages + +def request_fingerprint(data: MessageCreate) -> bytes: + """SHA-256 канонического JSON тела. + + Канонизация: проверенная модель -> JSON с сортировкой ключей и без пробелов. + Поэтому порядок ключей и форматирование исходного JSON не влияют на hash. + (С lab4 в модель добавится attachment_ids со значением по умолчанию [], + и отсутствующее поле будет равно явному [] — как требует контракт.) + """ + canonical = json.dumps( + data.model_dump(mode="json"), sort_keys=True, separators=(",", ":"), ensure_ascii=False + ) + return hashlib.sha256(canonical.encode("utf-8")).digest() + + +@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201) +def create_message( + request: Request, + response: Response, + chat_id: UUID, + data: MessageCreate, + user: User = Depends(current_user), +) -> Message: + # Порядок: аутентификация (dependency) -> ключ -> тело -> доступ к чату. + key = request.headers.get("Idempotency-Key") + if key is None or not IDEMPOTENCY_KEY_RE.fullmatch(key): + raise bad_request("Missing or invalid Idempotency-Key") + require_json_content_type(request) + ensure_not_blank(data.text) + settings = request.app.state.settings + try: + message, replayed = storage_of(request).create_message( + chat_id, + user.id, + data.text, + key, + request_fingerprint(data), + settings.idempotency_ttl_seconds, + ) + except NotChatMember: + raise not_found() + except IdempotencyConflict: + raise ApiError(409, "conflict", "Idempotency-Key was used with a different request") + except IdempotencyRace: + raise ApiError(503, "unavailable", "Please retry with the same Idempotency-Key") + if replayed: + # Информационный заголовок (не часть контракта): ответ — повтор. + response.headers["Idempotency-Replayed"] = "true" + return message + + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +def list_messages( + request: Request, + chat_id: UUID, + user: User = Depends(current_user), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +) -> MessagePage: + after = decode_cursor(cursor, chat_id) + result = storage_of(request).list_messages(chat_id, user.id, limit, after) + if result is None: + raise not_found() + items, has_more = result + next_cursor = None + if has_more and items: + next_cursor = encode_cursor(chat_id, items[-1].created_at, items[-1].id) + return MessagePage(items=items, next_cursor=next_cursor) diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 0000000..0963b22 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,25 @@ +"""Однократный запуск миграций: python -m src.migrate + +lab3: это команда one-shot сервиса `migrate` в compose.yaml. Реплики API +миграции не применяют (RUN_MIGRATIONS_ON_START=false) и стартуют только после +успешного завершения `migrate` (depends_on: service_completed_successfully). +Повторный запуск ничего не меняет; одновременный запуск нескольких копий +сериализуется pg_advisory_lock (см. src/db.py). +""" +import logging + +from .config import load_settings +from .db import wait_and_migrate + + +def main() -> None: + logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s %(message)s") + applied = wait_and_migrate(load_settings()) + if applied: + print("applied migrations: " + ", ".join(applied)) + else: + print("schema is up to date; nothing applied") + + +if __name__ == "__main__": + main() diff --git a/src/models.py b/src/models.py new file mode 100644 index 0000000..2a4dfc1 --- /dev/null +++ b/src/models.py @@ -0,0 +1,83 @@ +from datetime import datetime +from typing import List, Optional +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field + + +class StrictModel(BaseModel): + model_config = ConfigDict(extra="forbid") + + +class UserCreate(StrictModel): + username: str = Field( + min_length=3, + max_length=32, + pattern=r"^[a-z0-9_]{3,32}$", + ) + display_name: str = Field( + min_length=1, + max_length=100, + ) + # lab2: пароль обязателен; длина в Unicode code points (len() в Python). + password: str = Field( + min_length=12, + max_length=128, + ) + + +class User(StrictModel): + id: UUID + username: str + display_name: str + created_at: datetime + + +class Session(StrictModel): + token: str + token_type: str = "Bearer" + expires_at: datetime + user: User + + +class ChatCreate(StrictModel): + title: str = Field( + min_length=1, + max_length=100, + ) + member_ids: List[UUID] = Field( + min_length=1, + max_length=100, + ) + + +class Chat(StrictModel): + id: UUID + title: str + member_ids: List[UUID] + created_at: datetime + + +class MessageCreate(StrictModel): + text: str = Field( + min_length=1, + max_length=4000, + ) + + +class Message(StrictModel): + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + + +class ChatPage(StrictModel): + items: List[Chat] + next_cursor: Optional[str] + + +class MessagePage(StrictModel): + items: List[Message] + next_cursor: Optional[str] diff --git a/src/runtime.py b/src/runtime.py new file mode 100644 index 0000000..57904cb --- /dev/null +++ b/src/runtime.py @@ -0,0 +1,39 @@ +"""Состояние процесса, общее для middleware, readiness и сервера. + +INSTANCE_ID — значение X-Instance-Id. По умолчанию hostname контейнера: +Docker задаёт его равным короткому ID контейнера, поэтому scripts/ops.py +однозначно сопоставляет заголовок конкретному контейнеру (stop-one). +Значение не меняется в течение жизни процесса. + +DRAIN — фаза «осушения» после SIGTERM (см. src/server.py): процесс ещё +обслуживает запросы, но /health/ready уже отвечает 503, и балансировщик +выводит реплику из ротации до того, как она перестанет принимать соединения. +""" +import os +import socket +import threading +import time +from typing import Optional + +INSTANCE_ID = os.environ.get("INSTANCE_ID", "").strip() or socket.gethostname() + + +class Drain: + def __init__(self) -> None: + self._event = threading.Event() + self.started_at: Optional[float] = None + + def begin(self) -> bool: + """True, если осушение началось этим вызовом.""" + if self._event.is_set(): + return False + self.started_at = time.monotonic() + self._event.set() + return True + + @property + def active(self) -> bool: + return self._event.is_set() + + +DRAIN = Drain() diff --git a/src/security.py b/src/security.py new file mode 100644 index 0000000..6656463 --- /dev/null +++ b/src/security.py @@ -0,0 +1,97 @@ +"""Пароли, разбор Basic/Bearer и генерация токенов.""" +import base64 +import binascii +import hashlib +import re +import secrets +import threading +from typing import Optional, Tuple + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerificationError, VerifyMismatchError + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + +# Argon2id (библиотека argon2-cffi). Параметры — рекомендация OWASP для +# Argon2id: m=19 MiB, t=2, p=1. Пароль хешируется целиком в UTF-8, без усечения. +_hasher = PasswordHasher(time_cost=2, memory_cost=19 * 1024, parallelism=1) + +# Хеш-«пустышка»: проверка для несуществующего пользователя стоит столько же, +# сколько для существующего, — время ответа не выдаёт наличие username. +_DUMMY_HASH = _hasher.hash("dummy-password-for-timing-equalization") + +# 32 байта случайности = 256 бит энтропии; base64url без padding = 43 символа. +TOKEN_BYTES = 32 +MAX_TOKEN_LENGTH = 256 + + +# lab3: у каждой реплики лимит памяти (deploy.resources.limits). Один хеш Argon2id +# занимает 19 MiB, а sync-обработчики FastAPI выполняются в threadpool до 40 потоков. +# Без ограничения всплеск входов мог бы занять 40 x 19 MiB и привести к OOM-kill +# реплики. Семафор ограничивает число одновременных хешей (PASSWORD_HASH_CONCURRENCY). +_kdf_slots = threading.BoundedSemaphore(4) + + +def configure_kdf_concurrency(limit: int) -> None: + global _kdf_slots + _kdf_slots = threading.BoundedSemaphore(max(1, limit)) + + +def hash_password(password: str) -> str: + with _kdf_slots: + return _hasher.hash(password) + + +def verify_password(password_hash: Optional[str], password: str) -> bool: + try: + with _kdf_slots: + return _hasher.verify(password_hash or _DUMMY_HASH, password) and bool( + password_hash + ) + except (VerifyMismatchError, VerificationError, InvalidHashError): + return False + + +def new_token() -> str: + return secrets.token_urlsafe(TOKEN_BYTES) + + +def token_digest(token: str) -> bytes: + """Токен высокоэнтропийный, поэтому для поиска достаточно быстрого SHA-256. + + В отличие от пароля, перебор 256-битного токена невозможен, и KDF здесь + только замедлил бы каждый запрос. + """ + return hashlib.sha256(token.encode("ascii")).digest() + + +def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]: + """Authorization: Basic base64(username:password) -> (username, password).""" + if not header: + return None + scheme, _, value = header.strip().partition(" ") + if scheme.lower() != "basic" or not value.strip(): + return None + try: + raw = base64.b64decode(value.strip(), validate=True) + decoded = raw.decode("utf-8") + except (binascii.Error, ValueError, UnicodeDecodeError): + return None + username, sep, password = decoded.partition(":") # двоеточие в пароле допустимо + if not sep or not USERNAME_RE.match(username): + return None + if not 12 <= len(password) <= 128: + return None + return username, password + + +def parse_bearer(header: Optional[str]) -> Optional[str]: + if not header: + return None + scheme, _, value = header.strip().partition(" ") + token = value.strip() + if scheme.lower() != "bearer" or not token or len(token) > MAX_TOKEN_LENGTH: + return None + if not token.isascii() or any(ch.isspace() for ch in token): + return None + return token diff --git a/src/server.py b/src/server.py new file mode 100644 index 0000000..361d81a --- /dev/null +++ b/src/server.py @@ -0,0 +1,65 @@ +"""Точка входа контейнера: Uvicorn с фазой осушения (drain) перед остановкой. + +Последовательность при SIGTERM (docker stop / rolling update / stop-one): + + t=0 SIGTERM. Реплика ПРОДОЛЖАЕТ принимать и обслуживать запросы, + но /health/ready -> 503 и ответы идут с Connection: close. + t<=~1.5 с HAProxy (inter 1s, fastinter 500ms, fall 2) помечает реплику DOWN + и больше не отправляет ей новые запросы. + t=DRAIN_SECONDS (3 с) + Uvicorn закрывает listening-сокет, дожидается завершения запросов + в обработке (не дольше GRACEFUL_TIMEOUT_SECONDS = 10 с), закрывает + пул PostgreSQL и выходит. + stop_grace_period 20 с > 3 + 10 — Docker не успевает прислать SIGKILL. + +Повторный SIGTERM/SIGINT во время осушения — немедленный переход к остановке. +Запуск: python -m src.server (CMD в Dockerfile, процесс — PID 1). +""" +import logging +import os +import threading + +import uvicorn + +from .runtime import DRAIN, INSTANCE_ID + +log = logging.getLogger("messenger.server") + + +class DrainingServer(uvicorn.Server): + drain_seconds = 3.0 + + def handle_exit(self, sig, frame): # вызывается из обработчика сигнала + if self.should_exit or not DRAIN.begin(): + # Второй сигнал (или уже останавливаемся) — без ожидания. + return super().handle_exit(sig, frame) + log.info( + "signal %s: instance %s draining for %.1fs (readiness=503), then graceful stop", + sig, INSTANCE_ID, self.drain_seconds, + ) + timer = threading.Timer(self.drain_seconds, super().handle_exit, args=(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( + "src.main:app", + host=os.environ.get("APP_HOST", "0.0.0.0"), + port=int(os.environ.get("APP_PORT", "8080")), + # Дольше, чем HAProxy держит простаивающие соединения к серверу + # (pool-purge-delay 5s): соединение закрывает LB, а не сервер под запросом. + timeout_keep_alive=int(os.environ.get("KEEP_ALIVE_SECONDS", "30")), + timeout_graceful_shutdown=int(os.environ.get("GRACEFUL_TIMEOUT_SECONDS", "10")), + access_log=False, + server_header=False, + log_config=None, + ) + server = DrainingServer(config) + server.drain_seconds = float(os.environ.get("DRAIN_SECONDS", "3")) + server.run() + + +if __name__ == "__main__": + main() diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 0000000..d906fea --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,240 @@ +"""Сессии: PostgreSQL — источник истины, Redis — кэш проверок токена. + +Роль Redis +---------- +Каждый защищённый запрос сначала ищет `sess:` в Redis. +* попадание -> пользователь берётся из кэша, PostgreSQL не трогаем; +* промах -> читаем sessions JOIN users в PostgreSQL и кладём результат + в Redis через SET NX с TTL = min(SESSION_CACHE_TTL_SECONDS, + время до expires_at). Запись кэша никогда не переживает сессию. + +Инвалидация (logout) +-------------------- +1. UPDATE sessions SET revoked_at (COMMIT в PostgreSQL — момент отзыва); +2. SET sess: = "revoked" PX=SESSION_CACHE_TTL (обычный SET, перезаписывает). +Заполнение кэша идёт через SET NX, поэтому параллельный запрос, прочитавший +сессию до отзыва, не может перезаписать «надгробие» валидной записью. + +Надёжность отзыва при сбое Redis +-------------------------------- +Отзыв в PostgreSQL и строка-«долг» в session_cache_invalidations пишутся +ОДНОЙ транзакцией (миграция 002). Строка удаляется только после успешной +записи «надгробия» в Redis. Если записать его не удалось (таймаут, обрыв +связи, Redis заморожен), на кэш больше нельзя полагаться: в нём могла +остаться положительная запись отозванного токена. Поэтому: +* пока долг не погашен, положительные попадания кэша НЕ принимаются — + каждый токен проверяется в PostgreSQL (отозванный -> 401); +* не чаще раза в секунду API пытается погасить долг: пишет надгробия в + Redis и удаляет строки; строки старше SESSION_CACHE_TTL + 5 с удаляются + без записи (любая положительная запись к этому моменту уже истекла); +* наличие долга перечитывается из PostgreSQL не реже раза в секунду, так что + и другие реплики (lab3) перестают доверять кэшу не позже чем через 1 с; + реплика, выполнившая logout, — сразу, до ответа 204. + +Отказ Redis +----------- +Любая ошибка Redis (таймаут 250 мс) -> кэш пропускается, проверка идёт в +PostgreSQL; на CACHE_RETRY_AFTER_SECONDS Redis выключается (простой +circuit breaker), чтобы не платить таймаут на каждом запросе. +Redis работает без persistence: после рестарта кэш пуст, и это безопасно — +следующие запросы просто заполнят его из PostgreSQL. +""" +import json +import logging +import threading +import time +from datetime import datetime, timezone +from typing import Optional, Tuple + +import redis + +from .config import Settings +from .models import User +from .security import new_token, token_digest +from .storage import Storage + +log = logging.getLogger("messenger.sessions") + +REVOKED = "revoked" + + +class SessionCache: + def __init__(self, settings: Settings) -> None: + self.ttl_ms = settings.session_cache_ttl_seconds * 1000 + self.retry_after = settings.cache_retry_after_seconds + self._down_until = 0.0 + self._lock = threading.Lock() + self.client: Optional[redis.Redis] = None + if settings.cache_url: + self.client = redis.Redis.from_url( + settings.cache_url, + socket_timeout=settings.cache_timeout_seconds, + socket_connect_timeout=settings.cache_timeout_seconds, + retry_on_timeout=False, + health_check_interval=30, + max_connections=20, + decode_responses=True, + ) + # Счётчики для наблюдения и тестов (GET /health/cache не нужен контракту, + # поэтому они только логируются). + self.hits = 0 + self.misses = 0 + self.errors = 0 + + @staticmethod + def key(digest: bytes) -> str: + return "sess:" + digest.hex() + + def _available(self) -> bool: + return self.client is not None and time.monotonic() >= self._down_until + + def _failed(self, exc: Exception) -> None: + with self._lock: + self.errors += 1 + if time.monotonic() >= self._down_until: + log.warning("redis unavailable (%s); bypassing cache for %.0fs", + type(exc).__name__, self.retry_after) + self._down_until = time.monotonic() + self.retry_after + + def get(self, digest: bytes): + """None — промах/кэш недоступен; REVOKED — отозвано; иначе (User, expires_at).""" + if not self._available(): + return None + try: + raw = self.client.get(self.key(digest)) + except redis.RedisError as exc: + self._failed(exc) + return None + if raw is None: + self.misses += 1 + return None + self.hits += 1 + if raw == REVOKED: + return REVOKED + try: + data = json.loads(raw) + expires_at = datetime.fromisoformat(data["expires_at"]) + return User(**data["user"]), expires_at + except (ValueError, KeyError, TypeError): + return None + + def put(self, digest: bytes, user: User, expires_at: datetime) -> None: + if not self._available(): + return + remaining_ms = int((expires_at - datetime.now(timezone.utc)).total_seconds() * 1000) + ttl = min(self.ttl_ms, remaining_ms) + if ttl <= 0: + return + value = json.dumps({"user": user.model_dump(mode="json"), "expires_at": expires_at.isoformat()}) + try: + self.client.set(self.key(digest), value, px=ttl, nx=True) + except redis.RedisError as exc: + self._failed(exc) + + def revoke(self, digest: bytes) -> bool: + """True — надгробие записано (или кэша нет вовсе); False — не удалось.""" + if self.client is None: + return True + if not self._available(): + return False + try: + self.client.set(self.key(digest), REVOKED, px=self.ttl_ms) + return True + except redis.RedisError as exc: + self._failed(exc) + return False + + def ping(self) -> bool: + if self.client is None: + return False + try: + return bool(self.client.ping()) + except redis.RedisError: + return False + + +class SessionService: + # Как часто перечитывать из PostgreSQL наличие непогашенных инвалидаций. + RECHECK_SECONDS = 1.0 + + def __init__(self, storage: Storage, cache: SessionCache, settings: Settings) -> None: + self.storage = storage + self.cache = cache + self.ttl = settings.session_ttl_seconds + # Строки старше этого возраста можно удалять без записи в Redis. + self.stale_after = settings.session_cache_ttl_seconds + 5 + self._lock = threading.Lock() + self._pending = True # до первой сверки с БД кэшу не доверяем + self._checked_at = float("-inf") + + def create(self, user: User) -> Tuple[str, datetime]: + token = new_token() + expires_at = self.storage.create_session(token_digest(token), user.id, self.ttl) + return token, expires_at + + def _reconcile(self) -> None: + """Погасить долг инвалидации; вызывается под self._lock.""" + try: + rows = self.storage.pending_invalidations() + done = [] + for digest, age in rows: + if age > self.stale_after or self.cache.revoke(digest): + done.append(digest) + else: + break # Redis всё ещё недоступен — попробуем позже + self.storage.delete_invalidations(done) + self._pending = len(done) < len(rows) or len(rows) >= 500 + if rows and not self._pending: + log.info("cache invalidation backlog cleared (%d)", len(done)) + except Exception as exc: # PostgreSQL недоступна: доверять кэшу нельзя + log.warning("cannot verify cache invalidations: %s", type(exc).__name__) + self._pending = True + # Пробрасываем сразу (-> 503): иначе запрос ждал бы пул второй раз + # в find_session и отвечал за 2 x DB_POOL_TIMEOUT_SECONDS. + raise + + def cache_trusted(self) -> bool: + now = time.monotonic() + if now - self._checked_at < self.RECHECK_SECONDS: + return not self._pending + with self._lock: + if now - self._checked_at >= self.RECHECK_SECONDS: + self._reconcile() + self._checked_at = time.monotonic() + return not self._pending + + def resolve(self, token: str) -> Optional[User]: + digest = token_digest(token) + # Сначала сверка (она может дописать надгробия в Redis), и только + # потом чтение кэша — иначе прочитанная до сверки запись устарела бы. + trusted = self.cache_trusted() + cached = self.cache.get(digest) + if cached == REVOKED: + return None + if cached is not None and trusted: + user, expires_at = cached + if expires_at > datetime.now(timezone.utc): + return user + found = self.storage.find_session(digest) # PostgreSQL недоступна -> исключение -> 503 + if found is None: + return None + user, expires_at = found + self.cache.put(digest, user, expires_at) + return user + + def revoke(self, token: str) -> bool: + digest = token_digest(token) + if not self.storage.revoke_session(digest): # COMMIT: отзыв + долг инвалидации + return False + if self.cache.revoke(digest): + try: + self.storage.delete_invalidations([digest]) + except Exception: + pass # строка останется и будет удалена при следующей сверке + else: + # Надгробие не записано: до погашения долга кэшу не доверяем. + with self._lock: + self._pending = True + self._checked_at = time.monotonic() + log.warning("logout: cache invalidation deferred; positive cache disabled") + return True diff --git a/src/storage.py b/src/storage.py new file mode 100644 index 0000000..dd1ff6d --- /dev/null +++ b/src/storage.py @@ -0,0 +1,411 @@ +"""Доступ к PostgreSQL. Все запросы параметризованы (%s), SQL не склеивается +со значениями пользователя. Каждая публичная операция — одна транзакция +(`with pool.connection()` делает COMMIT при успехе и ROLLBACK при исключении). +""" +from datetime import datetime +from typing import List, Optional, Sequence, Tuple +from uuid import UUID, uuid4 + +from psycopg import errors +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool + +from .models import Chat, Message, User + + +class UsernameTaken(Exception): + pass + + +class UnknownMember(Exception): + pass + + +class NotChatMember(Exception): + """Чата нет или пользователь не участник -> 404.""" + + +class IdempotencyConflict(Exception): + """Тот же ключ уже использован с другим телом -> 409.""" + + +class IdempotencyRace(Exception): + """Строка ключа исчезла между шагами -> 503, клиент повторяет с тем же ключом.""" + + +# Одна реплика за раз чистит истёкшие ключи идемпотентности. +IDEMPOTENCY_CLEANUP_LOCK_ID = 2026_0003 + + +Position = Optional[Tuple[datetime, UUID]] + + +def _user(row) -> User: + return User( + id=row["id"], + username=row["username"], + display_name=row["display_name"], + created_at=row["created_at"], + ) + + +class Storage: + def __init__(self, pool: ConnectionPool) -> None: + self.pool = pool + + def ping(self) -> None: + with self.pool.connection() as conn: + conn.execute("SELECT 1") + + # users + + def create_user(self, username: str, display_name: str, password_hash: str) -> User: + try: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + INSERT INTO users (id, username, display_name, password_hash) + VALUES (%s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (uuid4(), username, display_name, password_hash), + ).fetchone() + except errors.UniqueViolation: + # Гонку двух одинаковых регистраций решает UNIQUE(username) в БД, + # а не проверка «SELECT, потом INSERT» в приложении. + raise UsernameTaken() + return _user(row) + + def get_credentials(self, username: str) -> Optional[Tuple[User, str]]: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + SELECT id, username, display_name, created_at, password_hash + FROM users WHERE username = %s + """, + (username,), + ).fetchone() + if row is None: + return None + return _user(row), row["password_hash"] + + # sessions (источник истины) + + def create_session(self, token_hash: bytes, user_id: UUID, ttl_seconds: int) -> datetime: + with self.pool.connection() as conn: + # Заодно убираем давно истёкшие сессии этого пользователя. + conn.execute( + "DELETE FROM sessions WHERE user_id = %s AND expires_at < now() - interval '1 day'", + (user_id,), + ) + row = conn.execute( + """ + INSERT INTO sessions (token_hash, user_id, expires_at) + VALUES (%s, %s, clock_timestamp() + make_interval(secs => %s)) + RETURNING expires_at + """, + (token_hash, user_id, ttl_seconds), + ).fetchone() + return row[0] + + def find_session(self, token_hash: bytes) -> Optional[Tuple[User, datetime]]: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at + FROM sessions s JOIN users u ON u.id = s.user_id + WHERE s.token_hash = %s + AND s.revoked_at IS NULL + AND s.expires_at > clock_timestamp() + """, + (token_hash,), + ).fetchone() + if row is None: + return None + return _user(row), row["expires_at"] + + def revoke_session(self, token_hash: bytes) -> bool: + """Отзыв и долг «инвалидировать кэш» фиксируются одним COMMIT.""" + with self.pool.connection() as conn: + with conn.transaction(): + row = conn.execute( + """ + UPDATE sessions SET revoked_at = clock_timestamp() + WHERE token_hash = %s + AND revoked_at IS NULL + AND expires_at > clock_timestamp() + RETURNING 1 + """, + (token_hash,), + ).fetchone() + if row is not None: + conn.execute( + """ + INSERT INTO session_cache_invalidations (token_hash) + VALUES (%s) ON CONFLICT (token_hash) DO NOTHING + """, + (token_hash,), + ) + return row is not None + + # долг инвалидации кэша + + def has_pending_invalidations(self) -> bool: + with self.pool.connection() as conn: + return conn.execute( + "SELECT EXISTS (SELECT 1 FROM session_cache_invalidations)" + ).fetchone()[0] + + def pending_invalidations(self, limit: int = 500) -> List[Tuple[bytes, float]]: + """[(token_hash, возраст в секундах)] — самые старые первыми.""" + with self.pool.connection() as conn: + rows = conn.execute( + """ + SELECT token_hash, EXTRACT(EPOCH FROM clock_timestamp() - revoked_at) + FROM session_cache_invalidations + ORDER BY revoked_at LIMIT %s + """, + (limit,), + ).fetchall() + return [(bytes(h), float(age)) for h, age in rows] + + def delete_invalidations(self, token_hashes: Sequence[bytes]) -> None: + if not token_hashes: + return + with self.pool.connection() as conn: + conn.execute( + "DELETE FROM session_cache_invalidations WHERE token_hash = ANY(%s)", + (list(token_hashes),), + ) + + # chats + + def _insert_members(self, conn, chat_id: UUID, member_ids: Sequence[UUID]) -> None: + with conn.cursor() as cur: + cur.executemany( + "INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)", + [(chat_id, member_id, pos) for pos, member_id in enumerate(member_ids)], + ) + + def create_chat(self, title: str, member_ids: Sequence[UUID]) -> Chat: + """Чат и все участники создаются в одной транзакции. + + Существование участников проверяет внешний ключ chat_members.user_id: + если хоть один id неизвестен, INSERT падает, и откатывается вся + транзакция, включая уже вставленную строку chats и других участников. + """ + chat_id = uuid4() + try: + with self.pool.connection() as conn: + with conn.transaction(): + created_at = conn.execute( + "INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at", + (chat_id, title), + ).fetchone()[0] + self._insert_members(conn, chat_id, member_ids) + except errors.ForeignKeyViolation: + raise UnknownMember() + return Chat(id=chat_id, title=title, member_ids=list(member_ids), created_at=created_at) + + def _members_for(self, conn, chat_ids: List[UUID]) -> dict: + members = {chat_id: [] for chat_id in chat_ids} + if not chat_ids: + return members + rows = conn.execute( + """ + SELECT chat_id, user_id FROM chat_members + WHERE chat_id = ANY(%s) ORDER BY chat_id, position + """, + (chat_ids,), + ).fetchall() + for chat_id, user_id in rows: + members[chat_id].append(user_id) + return members + + def get_chat_for_member(self, chat_id: UUID, user_id: UUID) -> Optional[Chat]: + with self.pool.connection() as conn: + row = conn.cursor(row_factory=dict_row).execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id AND m.user_id = %s + WHERE c.id = %s + """, + (user_id, chat_id), + ).fetchone() + if row is None: + return None + members = self._members_for(conn, [row["id"]]) + return Chat(id=row["id"], title=row["title"], member_ids=members[row["id"]], created_at=row["created_at"]) + + def list_user_chats(self, user_id: UUID, limit: int, after: Position) -> Tuple[List[Chat], bool]: + params: list = [user_id] + keyset = "" + if after is not None: + keyset = "AND (c.created_at, c.id) > (%s, %s)" + params.extend(after) + params.append(limit + 1) + with self.pool.connection() as conn: + rows = conn.cursor(row_factory=dict_row).execute( + """ + SELECT c.id, c.title, c.created_at + FROM chat_members m JOIN chats c ON c.id = m.chat_id + WHERE m.user_id = %s {keyset} + ORDER BY c.created_at, c.id + LIMIT %s + """.format(keyset=keyset), + params, + ).fetchall() + has_more = len(rows) > limit + rows = rows[:limit] + members = self._members_for(conn, [r["id"] for r in rows]) + chats = [ + Chat(id=r["id"], title=r["title"], member_ids=members[r["id"]], created_at=r["created_at"]) + for r in rows + ] + return chats, has_more + + # messages + + @staticmethod + def _insert_message(conn, message_id: UUID, chat_id: UUID, sender_id: UUID, text: str) -> Optional[Message]: + """Проверка членства и вставка — один оператор, без окна гонки.""" + row = conn.cursor(row_factory=dict_row).execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text) + SELECT %s, %s, %s, %s + WHERE EXISTS ( + SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s + ) + RETURNING id, chat_id, sender_id, text, created_at + """, + (message_id, chat_id, sender_id, text, chat_id, sender_id), + ).fetchone() + return Message(**row) if row is not None else None + + def create_message( + self, + chat_id: UUID, + sender_id: UUID, + text: str, + idem_key: str, + request_hash: bytes, + idem_ttl_seconds: int, + ) -> Tuple[Message, bool]: + """Идемпотентная отправка. Возвращает (сообщение, replayed). + + Всё — одна транзакция READ COMMITTED (см. migrations/003): + 1. INSERT строки ключа. Если такой ключ уже есть и он не истёк, + ON CONFLICT ... WHERE ничего не меняет и RETURNING пуст. Если + конкурентная транзакция с тем же ключом ещё не завершилась, INSERT + ЖДЁТ её COMMIT/ROLLBACK на уникальном индексе — поэтому одновременные + повторы через разные реплики создают ровно одно сообщение. + 2a. Ключ наш -> INSERT сообщения (с проверкой членства). Не участник -> + исключение -> ROLLBACK: ключ не «сгорает» на 404. + 2b. Ключ чужой (уже подтверждён) -> снова проверяем доступ, сравниваем + hash тела: совпал -> то же сообщение; нет -> 409. + Ошибка/обрыв на любом шаге откатывает и ключ, и сообщение. + """ + new_id = uuid4() + with self.pool.connection() as conn: + with conn.transaction(): + owned = conn.execute( + """ + INSERT INTO idempotency_keys + (user_id, method, chat_id, idem_key, request_hash, message_id, expires_at) + VALUES (%s, 'POST', %s, %s, %s, %s, + clock_timestamp() + make_interval(secs => %s)) + ON CONFLICT (user_id, method, chat_id, idem_key) DO UPDATE + SET request_hash = EXCLUDED.request_hash, + message_id = EXCLUDED.message_id, + created_at = clock_timestamp(), + expires_at = EXCLUDED.expires_at + -- истёкший (ещё не удалённый очисткой) ключ можно занять заново + WHERE idempotency_keys.expires_at <= clock_timestamp() + RETURNING message_id + """, + (sender_id, chat_id, idem_key, request_hash, new_id, idem_ttl_seconds), + ).fetchone() + if owned is not None: + message = self._insert_message(conn, new_id, chat_id, sender_id, text) + if message is None: + raise NotChatMember() # -> ROLLBACK вместе со строкой ключа + return message, False + + # Ключ уже подтверждён другой (возможно, конкурентной) транзакцией. + member = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, sender_id), + ).fetchone() + if member is None: + raise NotChatMember() + row = conn.cursor(row_factory=dict_row).execute( + """ + 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 = %s AND k.method = 'POST' + AND k.chat_id = %s AND k.idem_key = %s + """, + (sender_id, chat_id, idem_key), + ).fetchone() + if row is None: + # Теоретически: строка удалена между шагами (очистка/каскад). + # Отдаём 503-подобную транзиентную ошибку, клиент повторит с тем же ключом. + raise IdempotencyRace() + if bytes(row.pop("request_hash")) != request_hash: + raise IdempotencyConflict() + return Message(**row), True + + def delete_expired_idempotency_keys(self, batch: int = 1000) -> Optional[int]: + """Удаляет истёкшие ключи пачкой. None — очистку сейчас выполняет другая реплика.""" + with self.pool.connection() as conn: + with conn.transaction(): + got = conn.execute( + "SELECT pg_try_advisory_xact_lock(%s)", (IDEMPOTENCY_CLEANUP_LOCK_ID,) + ).fetchone()[0] + if not got: + return None + cur = conn.execute( + """ + DELETE FROM idempotency_keys + WHERE ctid IN ( + SELECT ctid FROM idempotency_keys + WHERE expires_at <= clock_timestamp() + LIMIT %s + ) + """, + (batch,), + ) + return cur.rowcount + + def list_messages( + self, chat_id: UUID, user_id: UUID, limit: int, after: Position + ) -> Optional[Tuple[List[Message], bool]]: + params: list = [chat_id] + keyset = "" + if after is not None: + keyset = "AND (created_at, id) > (%s, %s)" + params.extend(after) + params.append(limit + 1) + with self.pool.connection() as conn: + member = conn.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id), + ).fetchone() + if member is None: + return None + # Keyset-пагинация по индексу messages_chat_created_id_idx: + # Index Scan сразу с позиции курсора, читается limit+1 строк. + rows = conn.cursor(row_factory=dict_row).execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s {keyset} + ORDER BY created_at, id + LIMIT %s + """.format(keyset=keyset), + params, + ).fetchall() + has_more = len(rows) > limit + return [Message(**r) for r in rows[:limit]], has_more diff --git a/student-tests/common.py b/student-tests/common.py new file mode 100644 index 0000000..e8b6423 --- /dev/null +++ b/student-tests/common.py @@ -0,0 +1,108 @@ +"""Общие HTTP-помощники собственных тестов (только стандартная библиотека).""" +import base64 +import json +import os +import uuid +from urllib.error import HTTPError, URLError +from urllib.request import Request, urlopen + +BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/") + + +class Resp: + def __init__(self, status, data, headers, elapsed=0.0): + self.status = status + self.json = data + self.headers = headers + self.elapsed = elapsed + + +def request(method, path, token=None, payload=None, raw=None, headers=None, + base_url=None, timeout=10): + import time + h = {"Accept": "application/json"} + if token is not None: + h["Authorization"] = "Bearer " + token + body = None + if payload is not None: + body = json.dumps(payload, ensure_ascii=False).encode("utf-8") + h["Content-Type"] = "application/json" + elif raw is not None: + body = raw + h["Content-Type"] = "application/json" + h.update(headers or {}) + # Переход 2 -> 3: POST сообщения требует Idempotency-Key. Старые тесты lab2 + # его не передают — добавляем уникальный ключ, если тест не задал свой. + # Явное значение None в headers означает «не отправлять заголовок вовсе». + if method == "POST" and path.split("?")[0].endswith("/messages") \ + and not any(k.lower() == "idempotency-key" for k in h): + h["Idempotency-Key"] = uuid.uuid4().hex + h = {k: v for k, v in h.items() if v is not None} + req = Request((base_url or BASE_URL) + path, data=body, headers=h, method=method) + started = time.monotonic() + try: + response = urlopen(req, timeout=timeout) + except HTTPError as error: + response = error + with response: + content = response.read() + status = response.status if hasattr(response, "status") else response.code + rh = response.headers + try: + data = json.loads(content.decode("utf-8")) if content else None + except (UnicodeDecodeError, json.JSONDecodeError): + data = None + return Resp(status, data, rh, time.monotonic() - started) + + +def basic(username, password): + raw = (username + ":" + password).encode("utf-8") + return "Basic " + base64.b64encode(raw).decode("ascii") + + +def new_password(): + return "Pw-" + uuid.uuid4().hex + + +def register(prefix="t", password=None, base_url=None): + username = (prefix + "_" + uuid.uuid4().hex[:16])[:32] + password = password or new_password() + r = request("POST", "/api/v1/users", base_url=base_url, payload={ + "username": username, + "display_name": "Test " + prefix, + "password": password, + }) + assert r.status == 201, (r.status, r.json) + user = r.json + user["_password"] = password + return user + + +def login(user, base_url=None): + r = request("POST", "/api/v1/auth/sessions", base_url=base_url, + headers={"Authorization": basic(user["username"], user["_password"])}) + assert r.status == 201, (r.status, r.json) + return r.json["token"] + + +def actor(prefix="t", base_url=None): + user = register(prefix, base_url=base_url) + user["_token"] = login(user, base_url=base_url) + return user + + +def create_chat(owner, *members, base_url=None): + r = request("POST", "/api/v1/chats", token=owner["_token"], base_url=base_url, payload={ + "title": "Test chat " + uuid.uuid4().hex[:8], + "member_ids": [owner["id"]] + [m["id"] for m in members], + }) + assert r.status == 201, (r.status, r.json) + return r.json + + +def reachable(base_url): + try: + urlopen(base_url.rstrip("/") + "/health/live", timeout=2).read() + return True + except (URLError, OSError, HTTPError): + return False diff --git a/student-tests/dependency_failure.py b/student-tests/dependency_failure.py new file mode 100644 index 0000000..b543fde --- /dev/null +++ b/student-tests/dependency_failure.py @@ -0,0 +1,206 @@ +#!/usr/bin/env python3 +"""Автоматическая проверка недоступности Redis и PostgreSQL. + +Сценарий явно останавливает зависимости, поэтому не входит в discovery +unittest. По умолчанию использует docker compose из корня репозитория: + + python student-tests/dependency_failure.py --base-url http://127.0.0.1:8080 + +Команды остановки/запуска можно переопределить (--stop-redis и т.д.), например +для стенда без Docker. Результат — JSON-сводка (без токенов) в stdout и, +при --output, в файл. + +Ожидаемое поведение: +* Redis недоступен -> API обходит кэш, всё работает через PostgreSQL, + readiness = 200, задержка ограничена таймаутом Redis (250 мс) и + circuit breaker'ом; logout по-прежнему отзывает сессию. +* Разрыв сети API <-> Redis БЕЗ рестарта Redis (данные кэша живы) и logout + во время разрыва -> logout 204, и отозванный токен получает 401 и во время + разрыва, и сразу после восстановления связи, и после закрытия circuit + breaker (регрессия: раньше доверяли старой положительной записи ~60 с). +* PostgreSQL недоступна -> /health/live = 200, /health/ready = 503, + запросы к данным -> 503 unavailable за ограниченное время; анонимный + запрос -> 401; неизвестный токен не принимается (503, а не 200). +* После возврата зависимости тот же токен снова работает, данные на месте. +""" +import argparse +import json +import shlex +import subprocess +import sys +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import common # noqa: E402 +from common import actor, basic, create_chat, login, request # noqa: E402 + +ROOT = Path(__file__).resolve().parents[1] +MAX_FAIL_SECONDS = 6.0 # верхняя граница ответа при отказе зависимости +MAX_DEGRADED_SECONDS = 1.5 # верхняя граница ответа при отказе Redis + + +class Check: + def __init__(self): + self.results = [] + + def __call__(self, name, condition, detail=""): + self.results.append({"check": name, "ok": bool(condition), "detail": detail}) + print(("PASS " if condition else "FAIL ") + name + (" — " + detail if detail else ""), flush=True) + return condition + + @property + def ok(self): + return all(r["ok"] for r in self.results) + + +def run(cmd): + print("$ " + cmd, flush=True) + subprocess.run(shlex.split(cmd), cwd=ROOT, check=True, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) + + +def wait_ready(timeout=90): + deadline = time.monotonic() + timeout + started = time.monotonic() + while time.monotonic() < deadline: + try: + if request("GET", "/health/ready", timeout=3).status == 200: + return time.monotonic() - started + except OSError: + pass + time.sleep(0.5) + return None + + +def is_unavailable(r): + return (r.status == 503 and r.json and r.json["error"]["code"] == "unavailable" + and r.json["error"]["request_id"] == r.headers.get("X-Request-Id")) + + +def main(): + p = argparse.ArgumentParser(description=__doc__.split("\n")[0]) + p.add_argument("--base-url", default="http://127.0.0.1:8080") + p.add_argument("--stop-redis", default="docker compose stop redis") + p.add_argument("--start-redis", default="docker compose up -d --wait redis") + p.add_argument("--partition-redis", + default="docker network disconnect messenger-lab3_backend messenger-lab3-redis-1", + help="cut API<->Redis network WITHOUT restarting Redis") + p.add_argument("--heal-redis", + default="docker network connect --alias redis messenger-lab3_backend messenger-lab3-redis-1") + p.add_argument("--stop-postgres", default="docker compose stop postgres") + p.add_argument("--start-postgres", default="docker compose up -d --wait postgres") + p.add_argument("--output") + args = p.parse_args() + common.BASE_URL = args.base_url.rstrip("/") + + check = Check() + summary = {"base_url": common.BASE_URL, "timings": {}} + + alice, bob = actor("dep"), actor("dep") + chat = create_chat(alice, bob) + path = "/api/v1/chats/%s/messages" % chat["id"] + first = request("POST", path, token=alice["_token"], payload={"text": "до отказов"}).json + request("GET", "/api/v1/users/me", token=alice["_token"]) # прогрев кэша + + # 1. Redis недоступен + run(args.stop_redis) + try: + r = request("GET", "/api/v1/users/me", token=alice["_token"]) + check("redis down: existing token still valid via PostgreSQL", r.status == 200, "%.3fs" % r.elapsed) + summary["timings"]["redis_down_first_request_s"] = round(r.elapsed, 3) + timings = [] + for i in range(10): + r = request("POST", path, token=bob["_token"], payload={"text": "redis down %d" % i}) + timings.append(r.elapsed) + if r.status != 201: + break + check("redis down: writes succeed", r.status == 201) + check("redis down: bounded latency", max(timings) < MAX_DEGRADED_SECONDS, + "max %.3fs over %d requests" % (max(timings), len(timings))) + summary["timings"]["redis_down_max_write_s"] = round(max(timings), 3) + check("redis down: readiness stays 200 (cache is not critical)", + request("GET", "/health/ready").status == 200) + token = login(bob) + check("redis down: login works", bool(token)) + check("redis down: logout works", + request("DELETE", "/api/v1/auth/sessions/current", token=token).status == 204) + check("redis down: revoked token rejected", + request("GET", "/api/v1/users/me", token=token).status == 401) + check("redis down: anonymous rejected", request("GET", "/api/v1/users/me").status == 401) + check("redis down: unknown token rejected", + request("GET", "/api/v1/users/me", token="x" * 43).status == 401) + finally: + run(args.start_redis) + time.sleep(6) # больше CACHE_RETRY_AFTER_SECONDS: API снова пробует Redis + check("redis back: requests ok", + request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200) + + # 2. Разрыв связи с живым Redis + logout (замечание ревью №1) + carol = actor("dep") + for _ in range(2): # промах -> запись в кэш, затем попадание + request("GET", "/api/v1/users/me", token=carol["_token"]) + run(args.partition_redis) + try: + r = request("DELETE", "/api/v1/auth/sessions/current", token=carol["_token"]) + check("redis partition: logout -> 204", r.status == 204, "status %d, %.3fs" % (r.status, r.elapsed)) + check("redis partition: revoked token -> 401", + request("GET", "/api/v1/users/me", token=carol["_token"]).status == 401) + finally: + run(args.heal_redis) + # Опрашиваем дольше CACHE_RETRY_AFTER_SECONDS (5 с): после закрытия circuit + # breaker API снова читает Redis, где жила положительная запись этого токена. + statuses = set() + deadline = time.monotonic() + 8 + while time.monotonic() < deadline: + statuses.add(request("GET", "/api/v1/users/me", token=carol["_token"]).status) + statuses.add(request("POST", path, token=carol["_token"], payload={"text": "revoked"}).status) + time.sleep(0.25) + check("redis healed (same data): revoked token stays 401 for 8 s", statuses == {401}, str(sorted(statuses))) + check("redis healed: valid token works", request("GET", "/api/v1/users/me", token=alice["_token"]).status == 200) + + # 3. PostgreSQL недоступна + run(args.stop_postgres) + try: + check("postgres down: liveness 200", request("GET", "/health/live").status == 200) + r = request("GET", "/health/ready") + check("postgres down: readiness 503 unavailable", is_unavailable(r), "%.3fs" % r.elapsed) + r = request("GET", "/api/v1/users/me") + check("postgres down: anonymous -> 401 (not trusted)", r.status == 401, "status %d" % r.status) + r = request("GET", "/api/v1/users/me", token="y" * 43) + check("postgres down: unknown token is not accepted (503)", is_unavailable(r), + "status %d, %.3fs" % (r.status, r.elapsed)) + r = request("POST", path, token=alice["_token"], payload={"text": "должно не записаться"}) + check("postgres down: write -> 503 within bound", is_unavailable(r) and r.elapsed < MAX_FAIL_SECONDS, + "status %d, %.3fs" % (r.status, r.elapsed)) + summary["timings"]["postgres_down_write_s"] = round(r.elapsed, 3) + r = request("GET", path, token=alice["_token"]) + check("postgres down: history read -> 503", is_unavailable(r), "status %d" % r.status) + r = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic(alice["username"], alice["_password"])}) + check("postgres down: login -> 503 (not 401, not 201)", is_unavailable(r), "status %d" % r.status) + body = json.dumps(r.json, ensure_ascii=False) + check("postgres down: error hides internals", + not any(s in body.lower() for s in ("psycopg", "postgres", "select", "traceback", "5432"))) + finally: + run(args.start_postgres) + recovered = wait_ready() + check("postgres back: readiness recovered", recovered is not None, + "%.1fs" % recovered if recovered is not None else "timeout") + summary["timings"]["postgres_recovery_s"] = round(recovered or -1, 2) + r = request("GET", path + "?limit=100", token=alice["_token"]) + ok = r.status == 200 and r.json["items"][0] == first + texts = [m["text"] for m in r.json["items"]] if r.status == 200 else [] + check("postgres back: same token reads intact history", ok) + check("postgres back: rejected write was not stored", "должно не записаться" not in texts) + + summary["checks"] = check.results + summary["passed"] = check.ok + if args.output: + Path(args.output).write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print(("PASS" if check.ok else "FAIL") + ": dependency failure scenario") + sys.exit(0 if check.ok else 1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/failover_series.py b/student-tests/failover_series.py new file mode 100644 index 0000000..18e85e0 --- /dev/null +++ b/student-tests/failover_series.py @@ -0,0 +1,163 @@ +#!/usr/bin/env python3 +"""Уровень 4: последовательная остановка КАЖДОЙ API-реплики под нагрузкой. + +Для каждой реплики (по X-Instance-Id): нагрузка -> stop-one -> 15 с работы без неё +-> restore -> возврат реплики в ротацию. Собираются RPS, ошибки, задержки по +окнам, время обнаружения отказа балансировщиком (по странице HAProxy) и время +восстановления. Перед следующей репликой предыдущая уже восстановлена. + + python student-tests/failover_series.py --output evidence/failover_series.json + python student-tests/failover_series.py --mode kill --output evidence/failover_series_kill.json + +Остановка/восстановление по умолчанию — scripts/ops.py (docker compose); +для другого стенда их можно переопределить --stop-cmd / --restore-cmd. +""" +import argparse +import json +import os +import shlex +import subprocess +import sys +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import common # noqa: E402 +from common import request # noqa: E402 +from loadgen import Load # noqa: E402 + +ROOT = Path(__file__).resolve().parents[1] + + +def observe_instances(token, n=40): + seen = set() + for _ in range(n): + r = request("GET", "/api/v1/users/me", token=token, timeout=3) + seen.add(r.headers.get("X-Instance-Id")) + return sorted(x for x in seen if x) + + +def run_hook(cmd, env_extra, timeout): + env = dict(os.environ, **env_extra) + started = time.monotonic() + proc = subprocess.run(cmd, cwd=ROOT, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True, timeout=timeout) + return proc.returncode, time.monotonic() - started, proc.stdout[-2000:] + + +def one_round(args, target): + load = Load(args.base_url, writers=args.writers, readers=args.readers, stats_url=args.stats_url).start() + time.sleep(args.pre) + up_before = load.lb[-1][1] if load.lb else () + t_stop = load.now() + rc, stop_s, out = run_hook(args.stop_cmd, {"TARGET_INSTANCE_ID": target, "STOP_MODE": args.mode}, 60) + if rc != 0: + load.stop() + raise SystemExit("stop hook failed for %s:\n%s" % (target, out)) + time.sleep(max(0.0, args.post - stop_s)) + t_restore = load.now() + rc, restore_s, out = run_hook(args.restore_cmd, {}, 180) + if rc != 0: + load.stop() + raise SystemExit("restore hook failed:\n%s" % out) + # ждём, пока восстановленная реплика снова обслужит запрос + back = None + deadline = time.monotonic() + 30 + while back is None and time.monotonic() < deadline: + for e in reversed(load.events): + if e[0] >= t_restore and e[2] and e[4] == target: + back = e[0] + break + time.sleep(0.2) + time.sleep(args.tail) + load.stop() + t_end = load.now() + + detect = next((t - t_stop for t, up in load.lb if t >= t_stop and len(up) < len(up_before)), None) + lb_back = next((t - t_restore for t, up in load.lb if t >= t_restore and len(up) >= len(up_before)), None) + errs = load.errors_between(t_stop, t_restore) + # Сколько ещё после SIGTERM реплика отвечала (фаза осушения), до restore. + served_after = [e[0] - t_stop for e in load.events if t_stop <= e[0] < t_restore and e[2] and e[4] == target] + # После возврата hook (реплика остановлена) и до restore она не должна отвечать. + after_stop_ok = [e for e in load.events if t_stop + stop_s <= e[0] < t_restore and e[2]] + return { + "target_instance": target, + "mode": args.mode, + "lb_up_before": list(up_before), + "stop_hook_seconds": round(stop_s, 2), + "lb_detect_down_seconds": round(detect, 2) if detect is not None else None, + "target_last_served_after_stop_seconds": round(max(served_after), 2) if served_after else None, + "target_served_after_hook_returned": any(e[4] == target for e in after_stop_ok), + "errors_during_outage": len(errs), + "error_kinds": sorted({str(e[3]) for e in errs}), + "error_window_seconds": round(max(e[0] for e in errs) - t_stop, 2) if errs else 0.0, + "restore_hook_seconds": round(restore_s, 2), + "lb_back_up_seconds": round(lb_back, 2) if lb_back is not None else None, + "target_back_in_rotation_seconds": round(back - t_restore, 2) if back is not None else None, + "windows": { + "before": load.window(0, t_stop), + "outage_first_10s": load.window(t_stop, t_stop + 10), + "outage_rest": load.window(t_stop + 10, t_restore), + "after_restore": load.window(t_restore, t_end), + }, + "lb_timeline": [[round(t, 2), list(up)] for t, up in load.lb], + "data": load.verify(), + } + + +def main(): + py = sys.executable or "python" + p = argparse.ArgumentParser() + p.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://127.0.0.1:8080")) + p.add_argument("--stats-url", default="http://127.0.0.1:%s/stats;csv" % os.environ.get("LB_STATS_PORT", "8404")) + p.add_argument("--stop-cmd", default=None, help="default: python scripts/ops.py stop-one") + p.add_argument("--restore-cmd", default=None, help="default: python scripts/ops.py restore") + p.add_argument("--mode", choices=["stop", "kill"], default="stop", help="stop = SIGTERM (graceful), kill = SIGKILL") + p.add_argument("--writers", type=int, default=4) + p.add_argument("--readers", type=int, default=2) + p.add_argument("--pre", type=float, default=5) + p.add_argument("--post", type=float, default=15) + p.add_argument("--tail", type=float, default=3) + p.add_argument("--output") + args = p.parse_args() + args.stop_cmd = shlex.split(args.stop_cmd) if args.stop_cmd else [py, "scripts/ops.py", "stop-one"] + args.restore_cmd = shlex.split(args.restore_cmd) if args.restore_cmd else [py, "scripts/ops.py", "restore"] + common.BASE_URL = args.base_url.rstrip("/") + + probe = common.actor("probe") + instances = observe_instances(probe["_token"]) + if len(instances) < 2: + raise SystemExit("need >= 2 replicas behind LB, observed %s" % instances) + print("replicas observed through LB: %s" % instances, flush=True) + rounds = [] + for target in instances: + print("-- stopping %s (mode=%s) under load" % (target, args.mode), flush=True) + r = one_round(args, target) + rounds.append(r) + w = r["windows"] + print(" hook %.2fs | LB DOWN after %s s | errors %d (%s) | RPS before %.1f, outage %.1f, after restore %.1f" + " | p95 outage %s ms | back in rotation %s s | data ok=%s" + % (r["stop_hook_seconds"], r["lb_detect_down_seconds"], r["errors_during_outage"], + ",".join(r["error_kinds"]) or "-", w["before"]["ok_rps"], w["outage_first_10s"]["ok_rps"], + w["after_restore"]["ok_rps"], w["outage_first_10s"]["latency_ms_ok"]["p95"], + r["target_back_in_rotation_seconds"], r["data"]["ok"]), flush=True) + report = { + "scenario": "stop each API replica in turn under load, restore before the next", + "load": {"writers": args.writers, "readers": args.readers, "client_timeout_s": 2.0, + "write_retry": "same Idempotency-Key and body until 201"}, + "replicas": instances, + "rounds": rounds, + } + ok = all(r["data"]["ok"] and r["target_back_in_rotation_seconds"] is not None + and not r["target_served_after_hook_returned"] for r in rounds) + report["pass"] = ok + 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") + print(("PASS" if ok else "FAIL") + ": every replica stopped and restored; confirmed data intact, no duplicates") + sys.exit(0 if ok else 1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/loadgen.py b/student-tests/loadgen.py new file mode 100644 index 0000000..b2772f9 --- /dev/null +++ b/student-tests/loadgen.py @@ -0,0 +1,169 @@ +"""Фоновая нагрузка для сценариев отказа/обновления (только стандартная библиотека). + +Писатели: POST сообщения с Idempotency-Key. Неопределённый результат (обрыв, +timeout, 5xx) повторяется с ТЕМ ЖЕ ключом и телом, как требует контракт, пока +не будет 201. Читатели: GET истории и /users/me. Параллельно опрашивается +страница состояния HAProxy (UP/DOWN реплик), чтобы измерить время обнаружения. + +Каждая попытка записывается как событие (время от старта, тип, успех, статус, +X-Instance-Id, задержка). По событиям считаются RPS/ошибки/перцентили в окнах. +""" +import csv +import io +import math +import threading +import time +import uuid +from urllib.parse import quote +from urllib.request import urlopen + +import common +from common import actor, create_chat, request + + +def percentile(values, p): + if not values: + return None + values = sorted(values) + return round(1000 * values[max(0, math.ceil(p * len(values)) - 1)], 1) + + +class Load: + def __init__(self, base_url, writers=4, readers=2, timeout=2.0, stats_url=None): + common.BASE_URL = base_url.rstrip("/") + self.writers, self.readers, self.timeout = writers, readers, timeout + self.stats_url = stats_url + self.events = [] # (t, kind, ok, status, instance, latency) + self.lb = [] # (t, tuple(sorted UP servers)) + self.confirmed = [] + self.same_key_retries = 0 + self._lock = threading.Lock() + self._stop = threading.Event() + self._threads = [] + self.alice = actor("lda") + self.bob = actor("ldb") + self.chat = create_chat(self.alice, self.bob) + self.t0 = None + + def now(self): + return time.monotonic() - self.t0 + + def _record(self, kind, ok, status, instance, latency): + with self._lock: + self.events.append((self.now(), kind, ok, status, instance, latency)) + + def _call(self, kind, method, path, token, payload=None, headers=None): + started = time.monotonic() + try: + r = request(method, path, token=token, payload=payload, headers=headers, timeout=self.timeout) + ok = r.status < 500 + self._record(kind, ok, r.status, r.headers.get("X-Instance-Id"), time.monotonic() - started) + return r + except OSError as exc: # обрыв соединения / timeout — результат неизвестен + self._record(kind, False, type(exc).__name__, None, time.monotonic() - started) + return None + + def _writer(self, wid): + n = 0 + path = "/api/v1/chats/%s/messages" % self.chat["id"] + while not self._stop.is_set(): + key = "lg-%d-%d-%s" % (wid, n, uuid.uuid4().hex[:8]) + body = {"text": "load %d/%d %s" % (wid, n, key)} + for attempt in range(200): + r = self._call("w", "POST", path, self.alice["_token"], body, {"Idempotency-Key": key}) + if r is not None and r.status == 201: + with self._lock: + self.confirmed.append(r.json) + break + if r is not None and r.status < 500: + raise AssertionError("unexpected %s on write: %s" % (r.status, r.json)) + with self._lock: + self.same_key_retries += 1 + time.sleep(0.05) # повтор с тем же ключом и телом + n += 1 + + def _reader(self, rid): + i = 0 + while not self._stop.is_set(): + if i % 2: + self._call("r", "GET", "/api/v1/users/me", self.bob["_token"]) + else: + self._call("r", "GET", "/api/v1/chats/%s/messages?limit=20" % self.chat["id"], self.bob["_token"]) + i += 1 + + def _lb_poller(self): + last = None + while not self._stop.is_set(): + try: + data = urlopen(self.stats_url, timeout=1).read().decode("utf-8", "replace") + rows = csv.DictReader(io.StringIO(data.lstrip("# "))) + up = tuple(sorted(r["svname"] for r in rows if r.get("pxname") == "api" + and r.get("svname") not in ("BACKEND", "FRONTEND") + and r.get("status", "").startswith("UP"))) + if up != last: + with self._lock: + self.lb.append((self.now(), up)) + last = up + except Exception: + pass + time.sleep(0.1) + + def start(self): + self.t0 = time.monotonic() + targets = [(self._writer, i) for i in range(self.writers)] + [(self._reader, i) for i in range(self.readers)] + if self.stats_url: + targets.append((self._lb_poller, None)) + for fn, arg in targets: + t = threading.Thread(target=fn, args=(() if arg is None else (arg,)), daemon=True) + t.start() + self._threads.append(t) + return self + + def stop(self): + self._stop.set() + for t in self._threads: + t.join(timeout=30) + + def window(self, a, b): + ev = [e for e in self.events if a <= e[0] < b] + ok = [e for e in ev if e[2]] + dur = max(b - a, 1e-9) + lat = [e[5] for e in ok] + return { + "from_s": round(a, 2), "to_s": round(b, 2), + "requests": len(ev), "ok": len(ok), "errors": len(ev) - len(ok), + "error_ratio": round((len(ev) - len(ok)) / len(ev), 4) if ev else None, + "ok_rps": round(len(ok) / dur, 1), + "write_ok_rps": round(sum(1 for e in ok if e[1] == "w") / dur, 1), + "latency_ms_ok": {"p50": percentile(lat, .5), "p95": percentile(lat, .95), "p99": percentile(lat, .99)}, + "instances": sorted({e[4] for e in ok if e[4]}), + } + + def errors_between(self, a, b): + return [e for e in self.events if a <= e[0] < b and not e[2]] + + def verify(self): + """Все подтверждённые сообщения на месте, дублей (в т.ч. от повторов) нет.""" + items, cursor = [], None + while True: + path = "/api/v1/chats/%s/messages?limit=100" % self.chat["id"] + if cursor: + path += "&cursor=" + quote(cursor, safe="") + page = request("GET", path, token=self.bob["_token"], timeout=10).json + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + ids = [m["id"] for m in items] + texts = [m["text"] for m in items] + by_id = {m["id"]: m for m in items} + missing = [m for m in self.confirmed if by_id.get(m["id"]) != m] + return { + "confirmed_writes": len(self.confirmed), + "stored_messages": len(items), + "missing_or_altered": len(missing), + "duplicate_ids": len(ids) - len(set(ids)), + "duplicate_texts": len(texts) - len(set(texts)), + "same_key_retries": self.same_key_retries, + "ok": not missing and len(ids) == len(set(ids)) and len(texts) == len(set(texts)), + } diff --git a/student-tests/race.py b/student-tests/race.py new file mode 100644 index 0000000..655b54a --- /dev/null +++ b/student-tests/race.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +"""Конкурентная запись: 10 клиентов x 10 сообщений (перенесено из lab1, Bearer).""" +import argparse +import base64 +import json +import threading +import urllib.request +import uuid +from concurrent.futures import ThreadPoolExecutor +from urllib.parse import urlencode + + +def request(base_url, method, path, token=None, body=None, headers=None): + headers = dict(headers or {}) + headers["Accept"] = "application/json" + + if token: + headers["Authorization"] = "Bearer " + token + + data = None + if body is not None: + data = json.dumps(body, ensure_ascii=False).encode("utf-8") + headers["Content-Type"] = "application/json" + + request = urllib.request.Request( + base_url + path, + data=data, + headers=headers, + method=method, + ) + + with urllib.request.urlopen(request, timeout=10) as response: + return response.status, json.loads(response.read().decode("utf-8")) + + +def create_user(base_url, name): + username = "race_%s_%s" % (name, uuid.uuid4().hex[:8]) + password = "Race-password-" + uuid.uuid4().hex + + status, user = request( + base_url, + "POST", + "/api/v1/users", + body={ + "username": username, + "display_name": "Race " + name, + "password": password, + }, + ) + assert status == 201 + + credential = base64.b64encode((username + ":" + password).encode()).decode() + status, session = request( + base_url, + "POST", + "/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert status == 201 + user["token"] = session["token"] + return user + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--base-url", + default="http://127.0.0.1:8080", + ) + args = parser.parse_args() + + base_url = args.base_url.rstrip("/") + + users = [ + create_user(base_url, str(i)) + for i in range(10) + ] + + owner = users[0] + + status, chat = request( + base_url, + "POST", + "/api/v1/chats", + token=owner["token"], + body={ + "title": "Concurrent race test", + "member_ids": [user["id"] for user in users], + }, + ) + + assert status == 201 + + chat_id = chat["id"] + + barrier = threading.Barrier(10) + + def worker(worker_id): + user = users[worker_id] + created = [] + + barrier.wait() + + for message_id in range(10): + text = "race-%d-%d" % (worker_id, message_id) + + status, message = request( + base_url, + "POST", + "/api/v1/chats/%s/messages" % chat_id, + token=user["token"], + body={"text": text}, + headers={"Idempotency-Key": "race-%d-%d-%s" % (worker_id, message_id, uuid.uuid4().hex[:8])}, + ) + + assert status == 201 + created.append(message) + + return created + + with ThreadPoolExecutor(max_workers=10) as executor: + results = list(executor.map(worker, range(10))) + + created = [ + message + for worker_messages in results + for message in worker_messages + ] + + assert len(created) == 100 + + created_ids = {message["id"] for message in created} + created_texts = {message["text"] for message in created} + + assert len(created_ids) == 100 + assert len(created_texts) == 100 + + messages = [] + seen_cursors = set() + cursor = None + page_limit = 13 + + while True: + path = ( + "/api/v1/chats/%s/messages?limit=%d" + % (chat_id, page_limit) + ) + + if cursor is not None: + path += "&" + urlencode({"cursor": cursor}) + + status, page = request( + base_url, + "GET", + path, + token=owner["token"], + ) + + assert status == 200 + + page_messages = page["items"] + messages.extend(page_messages) + + next_cursor = page["next_cursor"] + + if next_cursor is None: + break + + assert next_cursor not in seen_cursors, ( + "Cursor повторился: возможен бесконечный цикл пагинации" + ) + + seen_cursors.add(next_cursor) + cursor = next_cursor + + assert len(messages) == 100 + + history_ids = {message["id"] for message in messages} + history_texts = {message["text"] for message in messages} + + assert len(history_ids) == 100 + assert len(history_texts) == 100 + + assert history_ids == created_ids + assert history_texts == created_texts + + user_ids = {user["id"] for user in users} + + assert all( + message["sender_id"] in user_ids + for message in messages + ) + + print( + "PASS: concurrent write test; " + "10 clients x 10 messages = 100 messages; " + "no lost or duplicate messages" + ) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/student-tests/revocation_partition.py b/student-tests/revocation_partition.py new file mode 100644 index 0000000..1193a24 --- /dev/null +++ b/student-tests/revocation_partition.py @@ -0,0 +1,37 @@ +#!/usr/bin/env python3 +"""Минимальное воспроизведение замечания ревью №1 (отзыв токена при разрыве с Redis). + +Прогрев кэша -> разрыв сети API<->Redis без рестарта Redis -> logout -> +восстановление связи -> 8 с опроса старого токена (дольше circuit breaker). +Ожидается только 401. По умолчанию — команды docker compose-стенда: + python student-tests/revocation_partition.py --base-url http://127.0.0.1:8080 +""" +import argparse, shlex, subprocess, sys, time +from pathlib import Path +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import common +from common import actor, request + +p = argparse.ArgumentParser() +p.add_argument("--base-url", default="http://127.0.0.1:8080") +p.add_argument("--partition", default="docker network disconnect messenger-lab3_backend messenger-lab3-redis-1") +p.add_argument("--heal", default="docker network connect --alias redis messenger-lab3_backend messenger-lab3-redis-1") +args = p.parse_args() +common.BASE_URL = args.base_url.rstrip("/") +ROOT = Path(__file__).resolve().parents[1] +def run(cmd): + subprocess.run(shlex.split(cmd), cwd=ROOT, check=True) +a = actor("repro"); t = a["_token"] +for _ in range(2): request("GET","/api/v1/users/me",token=t) +run(args.partition) +try: + print("logout during partition:", request("DELETE","/api/v1/auth/sessions/current",token=t).status) +finally: + run(args.heal) +seen=set(); end=time.monotonic()+8 +while time.monotonic() healthy/UP -> graceful stop старой, и так N раз). +Проверяется: hook завершился успешно, после обновления обслуживают ТОЛЬКО новые +реплики, подтверждённые сообщения на месте и без дублей; измеряются RPS, +ошибки и задержки до/во время/после. + + python student-tests/rolling_update_load.py --output evidence/rolling_update.json +""" +import argparse +import json +import os +import shlex +import subprocess +import sys +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import common # noqa: E402 +from failover_series import observe_instances # noqa: E402 +from loadgen import Load # noqa: E402 + +ROOT = Path(__file__).resolve().parents[1] + + +def main(): + py = sys.executable or "python" + p = argparse.ArgumentParser() + p.add_argument("--base-url", default=os.environ.get("BASE_URL", "http://127.0.0.1:8080")) + p.add_argument("--stats-url", default="http://127.0.0.1:%s/stats;csv" % os.environ.get("LB_STATS_PORT", "8404")) + p.add_argument("--update-cmd", default=None, help="default: python scripts/ops.py rolling-update") + p.add_argument("--writers", type=int, default=4) + p.add_argument("--readers", type=int, default=2) + p.add_argument("--pre", type=float, default=5) + p.add_argument("--post", type=float, default=8) + p.add_argument("--output") + args = p.parse_args() + cmd = shlex.split(args.update_cmd) if args.update_cmd else [py, "scripts/ops.py", "rolling-update"] + common.BASE_URL = args.base_url.rstrip("/") + + probe = common.actor("rprobe") + before = observe_instances(probe["_token"]) + print("replicas before: %s" % before, flush=True) + load = Load(args.base_url, writers=args.writers, readers=args.readers, stats_url=args.stats_url).start() + time.sleep(args.pre) + t_upd = load.now() + proc = subprocess.run(cmd, cwd=ROOT, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, timeout=1200) + t_done = load.now() + print(proc.stdout.strip()[-3000:], flush=True) + time.sleep(args.post) + load.stop() + t_end = load.now() + after = observe_instances(probe["_token"]) + tail_instances = load.window(t_end - 3, t_end)["instances"] + errs = load.errors_between(t_upd, t_done) + report = { + "scenario": "rolling update of all API replicas under continuous load", + "update_command": " ".join(cmd[1:] if cmd[0] == py else cmd), + "update_exit_code": proc.returncode, + "update_seconds": round(t_done - t_upd, 2), + "replicas_before": before, + "replicas_after": after, + "all_replaced": not (set(before) & set(after)) and not (set(before) & set(tail_instances)), + "errors_during_update": len(errs), + "error_kinds": sorted({str(e[3]) for e in errs}), + "windows": { + "before": load.window(0, t_upd), + "during_update": load.window(t_upd, t_done), + "after": load.window(t_done, t_end), + }, + "lb_timeline": [[round(t, 2), list(up)] for t, up in load.lb], + "data": load.verify(), + "load": {"writers": args.writers, "readers": args.readers, "client_timeout_s": 2.0}, + } + report["pass"] = proc.returncode == 0 and report["all_replaced"] and report["data"]["ok"] + w = report["windows"] + print("update %.1fs rc=%d | replicas %s -> %s | errors during update %d (%s) | RPS before %.1f, during %.1f, after %.1f" + " | p95 during %s ms | data ok=%s" + % (report["update_seconds"], proc.returncode, before, after, len(errs), ",".join(report["error_kinds"]) or "-", + w["before"]["ok_rps"], w["during_update"]["ok_rps"], w["after"]["ok_rps"], + w["during_update"]["latency_ms_ok"]["p95"], report["data"]["ok"])) + 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") + print(("PASS" if report["pass"] else "FAIL") + ": rolling update under load") + sys.exit(0 if report["pass"] else 1) + + +if __name__ == "__main__": + main() diff --git a/student-tests/run_all.py b/student-tests/run_all.py new file mode 100644 index 0000000..73d832d --- /dev/null +++ b/student-tests/run_all.py @@ -0,0 +1,47 @@ +"""Запуск собственных тестов, которые идут по HTTP через балансировщик. + + python student-tests/run_all.py --base-url http://127.0.0.1:8080 + +Входит: API/auth/конкурентность (lab2), идемпотентность через реплики (lab3), +race.py. Отдельно (меняют состояние стенда или нужен доступ к БД): + python scripts/ops.py in-network storage # тесты хранилища внутри compose-сети + python scripts/ops.py in-network expiry # истечение сессии (api-short-ttl) + python student-tests/failover_series.py # остановка каждой реплики под нагрузкой + python student-tests/rolling_update_load.py # rolling update под нагрузкой + python student-tests/dependency_failure.py # отказ Redis/PostgreSQL (останавливает контейнеры) +""" +import argparse +import os +import subprocess +import sys + +parser = argparse.ArgumentParser() +parser.add_argument("--base-url", default="http://127.0.0.1:8080") +parser.add_argument("--expiry-url", default=os.environ.get("EXPIRY_BASE_URL", "")) +parser.add_argument("--with-failures", action="store_true", + help="run student-tests/dependency_failure.py (stops redis/postgres)") +parser.add_argument("--failure-args", default="", + help="extra arguments for dependency_failure.py (custom stop/start commands)") +args = parser.parse_args() + +env = os.environ.copy() +env["BASE_URL"] = args.base_url.rstrip("/") +if args.expiry_url: + env["EXPIRY_BASE_URL"] = args.expiry_url.rstrip("/") + + +def step(title, cmd): + print("\n== " + title, flush=True) + subprocess.run(cmd, env=env, check=True) + + +step("API, auth, concurrency, idempotency tests (DB/expiry tests skip without their env)", + [sys.executable, "-m", "unittest", "discover", "-s", "student-tests", "-p", "test_*.py", "-v"]) +step("Concurrent write test", [sys.executable, "student-tests/race.py", "--base-url", args.base_url]) +if args.with_failures: + import shlex + step("Dependency failure scenario", + [sys.executable, "student-tests/dependency_failure.py", "--base-url", args.base_url] + + shlex.split(args.failure_args)) + +print("\nALL STUDENT TESTS PASSED", flush=True) diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 0000000..5943901 --- /dev/null +++ b/student-tests/test_api.py @@ -0,0 +1,138 @@ +"""Поведенческие тесты API, перенесённые из lab1 и переведённые на Bearer.""" +import base64 +import json +import unittest +import uuid +from urllib.parse import urlencode + +from common import actor, create_chat, request + + +class ApiBehaviorTests(unittest.TestCase): + + def test_malformed_json_returns_400(self): + r = request("POST", "/api/v1/users", raw=b'{"username": ') + self.assertEqual(r.status, 400, r.json) + self.assertIn("request_id", r.json["error"]) + self.assertEqual(r.json["error"]["request_id"], r.headers.get("X-Request-Id")) + + def test_registration_without_password_returns_400(self): + r = request("POST", "/api/v1/users", payload={ + "username": "nopass_" + uuid.uuid4().hex[:10], + "display_name": "No password", + }) + self.assertEqual(r.status, 400, r.json) + + def test_short_password_returns_400(self): + r = request("POST", "/api/v1/users", payload={ + "username": "short_" + uuid.uuid4().hex[:10], + "display_name": "Short", + "password": "elevenchars", + }) + self.assertEqual(r.status, 400, r.json) + + def test_password_never_returned(self): + r = request("POST", "/api/v1/users", payload={ + "username": "secret_" + uuid.uuid4().hex[:10], + "display_name": "Secret", + "password": "Very-secret-password-42", + }) + self.assertEqual(r.status, 201, r.json) + self.assertEqual(set(r.json), {"id", "username", "display_name", "created_at"}) + + def test_duplicate_username_returns_409(self): + payload = { + "username": "duplicate_" + uuid.uuid4().hex[:10], + "display_name": "First User", + "password": "Duplicate-pass-123", + } + self.assertEqual(request("POST", "/api/v1/users", payload=payload).status, 201) + self.assertEqual(request("POST", "/api/v1/users", payload=payload).status, 409) + + def test_empty_message_returns_400(self): + owner = actor() + chat = create_chat(owner) + r = request("POST", "/api/v1/chats/%s/messages" % chat["id"], + token=owner["_token"], payload={"text": " "}) + self.assertEqual(r.status, 400, r.json) + + def test_sender_id_in_body_rejected(self): + owner = actor() + chat = create_chat(owner) + r = request("POST", "/api/v1/chats/%s/messages" % chat["id"], token=owner["_token"], + payload={"text": "hi", "sender_id": owner["id"]}) + self.assertEqual(r.status, 400, r.json) + + def test_outsider_cannot_access_chat(self): + owner, member, outsider = actor(), actor(), actor() + chat = create_chat(owner, member) + chat_path = "/api/v1/chats/%s" % chat["id"] + self.assertEqual(request("GET", chat_path, token=outsider["_token"]).status, 404) + self.assertEqual(request("GET", chat_path + "/messages", token=outsider["_token"]).status, 404) + r = request("POST", chat_path + "/messages", token=outsider["_token"], + payload={"text": "Unauthorized message"}) + self.assertEqual(r.status, 404) + self.assertEqual(request("GET", chat_path, token=member["_token"]).status, 200) + + def test_naive_timestamp_cursor_returns_400(self): + owner = actor() + chat = create_chat(owner) + payload = { + "resource_id": chat["id"], + "created_at": "2026-10-02T12:00:00", + "item_id": str(uuid.uuid4()), + } + encoded = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode().rstrip("=") + r = request("GET", "/api/v1/chats/%s/messages?%s" % (chat["id"], urlencode({"cursor": encoded})), + token=owner["_token"]) + self.assertEqual(r.status, 400, r.json) + + def test_cursor_from_other_chat_returns_400(self): + owner = actor() + chat_a, chat_b = create_chat(owner), create_chat(owner) + for i in range(3): + request("POST", "/api/v1/chats/%s/messages" % chat_a["id"], token=owner["_token"], + payload={"text": "m%d" % i}) + page = request("GET", "/api/v1/chats/%s/messages?limit=1" % chat_a["id"], token=owner["_token"]).json + self.assertTrue(page["next_cursor"]) + r = request("GET", "/api/v1/chats/%s/messages?%s" % (chat_b["id"], urlencode({"cursor": page["next_cursor"]})), + token=owner["_token"]) + self.assertEqual(r.status, 400, r.json) + + def test_pagination_returns_all_messages_without_duplicates(self): + owner = actor() + chat = create_chat(owner) + path = "/api/v1/chats/%s/messages" % chat["id"] + expected = [] + for index in range(8): + r = request("POST", path, token=owner["_token"], payload={"text": "page-%d" % index}) + self.assertEqual(r.status, 201, r.json) + expected.append(r.json["id"]) + received, cursor = [], None + while True: + query = {"limit": 3} + if cursor: + query["cursor"] = cursor + page = request("GET", path + "?" + urlencode(query), token=owner["_token"]).json + received.extend(m["id"] for m in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + self.assertEqual(received, expected) + + def test_chat_list_pagination(self): + owner = actor() + created = [create_chat(owner)["id"] for _ in range(5)] + got, cursor = [], None + while True: + q = "?limit=2" + ("&" + urlencode({"cursor": cursor}) if cursor else "") + page = request("GET", "/api/v1/chats" + q, token=owner["_token"]).json + got.extend(c["id"] for c in page["items"]) + cursor = page["next_cursor"] + if cursor is None: + break + self.assertEqual(got, created) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 0000000..2a7540a --- /dev/null +++ b/student-tests/test_auth.py @@ -0,0 +1,109 @@ +"""Аутентификация: Basic только для входа, Bearer для остального, logout.""" +import base64 +import unittest +import uuid + +from common import actor, basic, login, register, request + + +def assert_challenge(test, r, scheme): + test.assertEqual(r.status, 401, r.json) + test.assertTrue(r.headers.get("WWW-Authenticate", "").startswith(scheme), r.headers.get("WWW-Authenticate")) + test.assertEqual(r.json["error"]["code"], "unauthorized") + + +class AuthTests(unittest.TestCase): + + def test_wrong_password_and_unknown_user_look_the_same(self): + user = register("wp") + wrong = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic(user["username"], "Wrong-password-000")}) + unknown = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic("nouser_" + uuid.uuid4().hex[:10], "Wrong-password-000")}) + for r in (wrong, unknown): + assert_challenge(self, r, 'Basic realm="messenger"') + self.assertIn('charset="UTF-8"', r.headers.get("WWW-Authenticate")) + self.assertEqual(wrong.json["error"]["message"], unknown.json["error"]["message"]) + + def test_malformed_basic_headers(self): + for header in (None, "Basic", "Basic !!!notbase64", "Bearer abc", + "Basic " + base64.b64encode(b"no-colon-here").decode()): + headers = {"Authorization": header} if header else {} + r = request("POST", "/api/v1/auth/sessions", headers=headers) + assert_challenge(self, r, "Basic") + + def test_session_shape_and_token_entropy(self): + user = register("shape") + r = request("POST", "/api/v1/auth/sessions", + headers={"Authorization": basic(user["username"], user["_password"])}) + self.assertEqual(r.status, 201, r.json) + self.assertEqual(set(r.json), {"token", "token_type", "expires_at", "user"}) + self.assertEqual(r.json["token_type"], "Bearer") + token = r.json["token"] + # 32 случайных байта в base64url = 43 символа (256 бит) + self.assertGreaterEqual(len(token), 43) + self.assertNotIn(user["username"], token) + self.assertNotIn(user["id"], token) + self.assertTrue(r.json["expires_at"].endswith("Z")) + self.assertNotEqual(token, login(user), "each login must issue a new token") + + def test_password_with_colon_and_unicode(self): + password = "пароль:с:двоеточием-🙂" + user = register("colon", password=password) + token = login(user) + self.assertEqual(request("GET", "/api/v1/users/me", token=token).json["id"], user["id"]) + + def test_login_with_body_rejected(self): + """Контракт: вход — только заголовок Basic, без тела. Лишний ввод -> 400, сессии нет.""" + user = register("body") + auth = {"Authorization": basic(user["username"], user["_password"])} + cases = [ + dict(payload={"unexpected": True}), + dict(payload={}), + dict(raw=b"not json at all"), + dict(raw=b"username=x&password=y", headers={"Content-Type": "application/x-www-form-urlencoded"}), + ] + for case in cases: + headers = dict(auth) + headers.update(case.pop("headers", {})) + r = request("POST", "/api/v1/auth/sessions", headers=headers, **case) + self.assertEqual(r.status, 400, (case, r.json)) + self.assertEqual(r.json["error"]["code"], "invalid_request") + self.assertNotIn("token", r.json) + # Без тела тот же заголовок работает. + self.assertEqual(request("POST", "/api/v1/auth/sessions", headers=auth).status, 201) + + def test_basic_on_business_endpoint_rejected(self): + user = register("basic") + r = request("GET", "/api/v1/users/me", + headers={"Authorization": basic(user["username"], user["_password"])}) + assert_challenge(self, r, 'Bearer realm="messenger"') + + def test_x_user_id_gives_no_access(self): + user = actor("xuid") + other = actor("xuid") + assert_challenge(self, request("GET", "/api/v1/users/me", headers={"X-User-Id": user["id"]}), "Bearer") + r = request("GET", "/api/v1/users/me", token=user["_token"], headers={"X-User-Id": other["id"]}) + self.assertEqual(r.json["id"], user["id"]) + + def test_unknown_and_garbage_tokens(self): + for token in ("x" * 43, "", "a b", "z" * 1000): + r = request("GET", "/api/v1/users/me", headers={"Authorization": "Bearer " + token}) + assert_challenge(self, r, "Bearer") + + def test_logout_revokes_only_current_session(self): + user = register("logout") + t1, t2 = login(user), login(user) + # Прогреваем кэш Redis для t1, чтобы проверить инвалидацию кэша. + self.assertEqual(request("GET", "/api/v1/users/me", token=t1).status, 200) + self.assertEqual(request("GET", "/api/v1/users/me", token=t1).status, 200) + r = request("DELETE", "/api/v1/auth/sessions/current", token=t1) + self.assertEqual(r.status, 204) + self.assertIsNone(r.json) + assert_challenge(self, request("GET", "/api/v1/users/me", token=t1), "Bearer") + assert_challenge(self, request("DELETE", "/api/v1/auth/sessions/current", token=t1), "Bearer") + self.assertEqual(request("GET", "/api/v1/users/me", token=t2).status, 200) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 0000000..0411490 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -0,0 +1,80 @@ +"""Гонка регистрации одинакового username и rollback составной операции.""" +import threading +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor + +from common import actor, basic, request + +PARALLEL = 16 + + +class RegistrationRaceTests(unittest.TestCase): + + def test_same_username_parallel_registration(self): + username = "race_" + uuid.uuid4().hex[:12] + barrier = threading.Barrier(PARALLEL) + + def attempt(i): + password = "Race-password-%02d-%s" % (i, uuid.uuid4().hex[:6]) + barrier.wait() + r = request("POST", "/api/v1/users", timeout=30, payload={ + "username": username, "display_name": "Racer %d" % i, "password": password, + }) + return r.status, r.json, password + + with ThreadPoolExecutor(max_workers=PARALLEL) as pool: + results = list(pool.map(attempt, range(PARALLEL))) + + statuses = sorted(s for s, _, _ in results) + self.assertEqual(statuses.count(201), 1, statuses) + self.assertEqual(statuses.count(409), PARALLEL - 1, statuses) + for status, body, _ in results: + if status == 409: + self.assertEqual(body["error"]["code"], "conflict") + + # Победитель входит своим паролем; пароли проигравших не подходят. + winner = next(r for r in results if r[0] == 201) + loser = next(r for r in results if r[0] == 409) + ok = request("POST", "/api/v1/auth/sessions", headers={"Authorization": basic(username, winner[2])}) + self.assertEqual(ok.status, 201) + self.assertEqual(ok.json["user"]["id"], winner[1]["id"]) + bad = request("POST", "/api/v1/auth/sessions", headers={"Authorization": basic(username, loser[2])}) + self.assertEqual(bad.status, 401) + + +class ChatRollbackTests(unittest.TestCase): + + def _chat_ids(self, owner): + r = request("GET", "/api/v1/chats?limit=100", token=owner["_token"]) + self.assertEqual(r.status, 200) + return [c["id"] for c in r.json["items"]] + + def test_unknown_member_rolls_back_whole_chat(self): + """Чат вставляется первым, затем участники по порядку (сначала сам владелец). + + Неизвестный участник вызывает нарушение внешнего ключа на 2-й строке + chat_members. Без транзакции у владельца остался бы чат с одним + участником; с транзакцией не остаётся ничего. + """ + owner, member = actor("rb"), actor("rb") + before = self._chat_ids(owner) + r = request("POST", "/api/v1/chats", token=owner["_token"], payload={ + "title": "Must roll back", + "member_ids": [owner["id"], member["id"], str(uuid.uuid4())], + }) + self.assertEqual(r.status, 400, r.json) + self.assertEqual(self._chat_ids(owner), before, "partial chat is visible after failed creation") + self.assertEqual(self._chat_ids(member), [], "partial membership is visible to other member") + + def test_duplicate_and_missing_caller_rejected(self): + owner, member = actor("rb"), actor("rb") + for ids in ([owner["id"], owner["id"]], [member["id"]]): + r = request("POST", "/api/v1/chats", token=owner["_token"], + payload={"title": "bad", "member_ids": ids}) + self.assertEqual(r.status, 400, r.json) + self.assertEqual(self._chat_ids(owner), []) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_expiry.py b/student-tests/test_expiry.py new file mode 100644 index 0000000..c560140 --- /dev/null +++ b/student-tests/test_expiry.py @@ -0,0 +1,49 @@ +"""Истечение сессии при коротком SESSION_TTL_SECONDS. + +Нужен отдельный экземпляр API с коротким TTL (compose-профиль ttl, порт 8081): + docker compose --profile ttl up -d api-short-ttl + EXPIRY_BASE_URL=http://127.0.0.1:8081 python -m unittest discover -s student-tests -p test_expiry.py +Без EXPIRY_BASE_URL тест пропускается (основной стенд работает с TTL >= 300). +""" +import datetime as dt +import os +import time +import unittest + +from common import basic, register, request + +EXPIRY_BASE_URL = os.environ.get("EXPIRY_BASE_URL", "").rstrip("/") + + +@unittest.skipUnless(EXPIRY_BASE_URL, "set EXPIRY_BASE_URL to the short-TTL API instance") +class ExpiryTests(unittest.TestCase): + + def test_session_expires_even_when_cached(self): + user = register("exp", base_url=EXPIRY_BASE_URL) + r = request("POST", "/api/v1/auth/sessions", base_url=EXPIRY_BASE_URL, + headers={"Authorization": basic(user["username"], user["_password"])}) + self.assertEqual(r.status, 201, r.json) + token = r.json["token"] + expires_at = dt.datetime.fromisoformat(r.json["expires_at"].replace("Z", "+00:00")) + ttl = (expires_at - dt.datetime.now(dt.timezone.utc)).total_seconds() + self.assertLess(ttl, 30, "EXPIRY_BASE_URL must point to a short-TTL instance") + + # Два запроса подряд: первый кладёт сессию в Redis, второй читает из кэша. + for _ in range(2): + self.assertEqual(request("GET", "/api/v1/users/me", token=token, base_url=EXPIRY_BASE_URL).status, 200) + + time.sleep(max(ttl, 0) + 1.5) + r = request("GET", "/api/v1/users/me", token=token, base_url=EXPIRY_BASE_URL) + self.assertEqual(r.status, 401, r.json) + self.assertTrue(r.headers.get("WWW-Authenticate", "").startswith("Bearer")) + r = request("DELETE", "/api/v1/auth/sessions/current", token=token, base_url=EXPIRY_BASE_URL) + self.assertEqual(r.status, 401, "logout with expired token must be 401") + + # Новый вход после истечения работает. + r = request("POST", "/api/v1/auth/sessions", base_url=EXPIRY_BASE_URL, + headers={"Authorization": basic(user["username"], user["_password"])}) + self.assertEqual(r.status, 201) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_idempotency.py b/student-tests/test_idempotency.py new file mode 100644 index 0000000..0242026 --- /dev/null +++ b/student-tests/test_idempotency.py @@ -0,0 +1,172 @@ +"""Idempotency-Key через балансировщик (lab3). Только стандартная библиотека. + + BASE_URL=http://127.0.0.1:8080 python -m unittest discover -s student-tests -p test_idempotency.py -v + +Главная проверка — одновременные повторы с одним ключом, которые LB +раскладывает по РАЗНЫМ репликам (это проверяется по X-Instance-Id), +создают ровно одно сообщение. Остальное — семантика из contracts/README.md. +""" +import json +import threading +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor +from urllib.parse import quote + +from common import actor, create_chat, login, request + +PARALLEL = 24 + + +def history(token, chat_id): + items, cursor = [], None + for _ in range(100): + path = "/api/v1/chats/%s/messages?limit=100" % chat_id + if cursor: + path += "&cursor=" + quote(cursor, safe="") + page = request("GET", path, token=token).json + items.extend(page["items"]) + cursor = page["next_cursor"] + if cursor is None: + return items + raise AssertionError("pagination did not finish") + + +def post(token, chat_id, body, key, raw=None): + # None -> заголовок не отправляется (см. common.request). + headers = {"Idempotency-Key": key} + if raw is not None: + return request("POST", "/api/v1/chats/%s/messages" % chat_id, token=token, raw=raw, headers=headers) + return request("POST", "/api/v1/chats/%s/messages" % chat_id, token=token, payload=body, headers=headers) + + +def parallel(n, fn): + barrier = threading.Barrier(n) + + def run(i): + barrier.wait() + return fn(i) + + with ThreadPoolExecutor(max_workers=n) as pool: + return list(pool.map(run, range(n))) + + +class IdempotencyTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.alice = actor("ida") + cls.bob = actor("idb") + cls.eve = actor("ide") + cls.chat = create_chat(cls.alice, cls.bob) + cls.chat2 = create_chat(cls.alice, cls.bob) + + def test_concurrent_same_key_across_replicas_creates_one_message(self): + key = "par-" + uuid.uuid4().hex + text = "одновременно " + key + results = parallel(PARALLEL, lambda i: post(self.alice["_token"], self.chat["id"], {"text": text}, key)) + statuses = [r.status for r in results] + self.assertEqual(statuses, [201] * PARALLEL, statuses) + ids = {r.json["id"] for r in results} + self.assertEqual(len(ids), 1, "same key produced different messages") + bodies = {json.dumps(r.json, sort_keys=True) for r in results} + self.assertEqual(len(bodies), 1, "replays must return the identical Message") + instances = {r.headers.get("X-Instance-Id") for r in results} + self.assertGreaterEqual(len(instances), 2, "requests did not reach >= 2 replicas: %s" % instances) + stored = [m for m in history(self.bob["_token"], self.chat["id"]) if m["text"] == text] + self.assertEqual(len(stored), 1, "history must contain exactly one message") + replayed = sum(1 for r in results if r.headers.get("Idempotency-Replayed") == "true") + self.assertEqual(replayed, PARALLEL - 1) + print("\n %d parallel POSTs, one key -> 1 message; replicas: %s" % (PARALLEL, sorted(instances))) + + def test_concurrent_same_key_different_bodies_one_winner(self): + key = "race-" + uuid.uuid4().hex + results = parallel(12, lambda i: post(self.alice["_token"], self.chat["id"], {"text": "вариант %d" % i}, key)) + winners = [r for r in results if r.status == 201] + losers = [r for r in results if r.status == 409] + self.assertEqual(len(winners) + len(losers), 12, [r.status for r in results]) + self.assertGreaterEqual(len(winners), 1) + self.assertEqual(len({r.json["id"] for r in winners}), 1, "two bodies won with one key") + for r in losers: + self.assertEqual(r.json["error"]["code"], "conflict") + texts = [m["text"] for m in history(self.alice["_token"], self.chat["id"]) if m["text"].startswith("вариант ")] + self.assertEqual(len([t for t in texts if t == winners[0].json["text"]]), 1) + + def test_sequential_replay_and_conflict(self): + key = "seq-" + uuid.uuid4().hex + first = post(self.alice["_token"], self.chat["id"], {"text": "раз"}, key) + self.assertEqual(first.status, 201) + again = post(self.alice["_token"], self.chat["id"], {"text": "раз"}, key) + self.assertEqual((again.status, again.json), (201, first.json)) + other = post(self.alice["_token"], self.chat["id"], {"text": "два"}, key) + self.assertEqual(other.status, 409) + self.assertEqual(other.json["error"]["code"], "conflict") + + def test_json_formatting_and_key_order_do_not_matter(self): + key = "fmt-" + uuid.uuid4().hex + first = post(self.alice["_token"], self.chat["id"], None, key, raw=b'{"text":"format"}') + spaced = post(self.alice["_token"], self.chat["id"], None, key, raw=b'{ \n "text" : "format"\n}') + self.assertEqual(first.status, 201) + self.assertEqual((spaced.status, spaced.json), (201, first.json)) + + def test_missing_or_invalid_key_is_400(self): + token, chat_id = self.alice["_token"], self.chat["id"] + # Не-ASCII ключ передаём сырыми UTF-8 байтами (urllib пропускает только latin-1). + non_ascii = "ключ".encode("utf-8").decode("latin-1") + bad_keys = [None, "", " ", "a" * 129, non_ascii, "has space", "semi;colon", "slash/key"] + for key in bad_keys: + with self.subTest(key=key): + r = post(token, chat_id, {"text": "x"}, key) + self.assertEqual(r.status, 400, r.json) + self.assertEqual(r.json["error"]["code"], "invalid_request") + ok = post(token, chat_id, {"text": "x"}, "A" * 128) + self.assertEqual(ok.status, 201) + ok2 = post(token, chat_id, {"text": "y"}, "a.b_c:d-1") + self.assertEqual(ok2.status, 201) + + def test_auth_checked_before_key(self): + r = post(None, self.chat["id"], {"text": "x"}, None) + self.assertEqual(r.status, 401) + + def test_scope_is_user_and_chat(self): + key = "scope-" + uuid.uuid4().hex + a1 = post(self.alice["_token"], self.chat["id"], {"text": "scope"}, key) + b1 = post(self.bob["_token"], self.chat["id"], {"text": "scope"}, key) + a2 = post(self.alice["_token"], self.chat2["id"], {"text": "scope"}, key) + self.assertEqual([a1.status, b1.status, a2.status], [201, 201, 201]) + self.assertEqual(len({a1.json["id"], b1.json["id"], a2.json["id"]}), 3) + # Другое тело другим пользователем с тем же ключом — не конфликт. + b2 = post(self.bob["_token"], self.chat2["id"], {"text": "другое"}, key) + self.assertEqual(b2.status, 201) + + def test_key_survives_new_session_of_same_user(self): + key = "sess-" + uuid.uuid4().hex + first = post(self.alice["_token"], self.chat["id"], {"text": "до перелогина"}, key) + token2 = login(self.alice) + replay = post(token2, self.chat["id"], {"text": "до перелогина"}, key) + self.assertEqual((replay.status, replay.json), (201, first.json)) + + def test_failed_access_does_not_burn_key(self): + key = "burn-" + uuid.uuid4().hex + denied = post(self.eve["_token"], self.chat["id"], {"text": "чужое"}, key) + self.assertEqual(denied.status, 404) + # Тот же ключ у участника и даже у того же постороннего позже — не занят. + mine = post(self.alice["_token"], self.chat["id"], {"text": "своё"}, key) + self.assertEqual(mine.status, 201) + invalid = post(self.alice["_token"], self.chat2["id"], {"text": ""}, key) + self.assertEqual(invalid.status, 400) + valid = post(self.alice["_token"], self.chat2["id"], {"text": "после 400"}, key) + self.assertEqual(valid.status, 201) + + def test_replay_rechecks_session(self): + key = "revoked-" + uuid.uuid4().hex + token = login(self.bob) + first = post(token, self.chat["id"], {"text": "до logout"}, key) + self.assertEqual(first.status, 201) + self.assertEqual(request("DELETE", "/api/v1/auth/sessions/current", token=token).status, 204) + replay = post(token, self.chat["id"], {"text": "до logout"}, key) + self.assertEqual(replay.status, 401) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_session_cache.py b/student-tests/test_session_cache.py new file mode 100644 index 0000000..e097270 --- /dev/null +++ b/student-tests/test_session_cache.py @@ -0,0 +1,149 @@ +"""Отзыв сессии при сбое инвалидации кэша (регрессия замечания ревью №1). + +Сценарий ревью: прогретый кэш -> связь API с Redis разорвана -> logout (204) +-> связь восстановлена с ТЕМ ЖЕ Redis, без его рестарта, положительная запись +отозванного токена ещё жива. Ожидание: токен отклоняется сразу, а не через +SESSION_CACHE_TTL_SECONDS. + +Redis здесь заменён управляемой заглушкой с тем же интерфейсом, что и +SessionCache (get/put/revoke): «разрыв» = операции падают, но данные заглушки +сохраняются — ровно как у живого Redis за сетевым разрывом. PostgreSQL — +настоящая (нужен DATABASE_URL/DATABASE_URL_FILE, иначе тест пропускается): + make test-storage +""" +import os +import sys +import time +import unittest +import uuid +from datetime import datetime, timezone +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE")) + + +class PartitionableCache: + """Кэш, который «помнит» данные во время разрыва, но недоступен для API.""" + + def __init__(self): + self.data = {} + self.partitioned = False + + def get(self, digest): + from src.sessions import REVOKED + if self.partitioned: + return None + value = self.data.get(digest) + if value is None: + return None + if value == REVOKED: + return REVOKED + user, expires_at = value + return (user, expires_at) if expires_at > datetime.now(timezone.utc) else None + + def put(self, digest, user, expires_at): + if not self.partitioned: + self.data.setdefault(digest, (user, expires_at)) # SET NX + + def revoke(self, digest): + from src.sessions import REVOKED + if self.partitioned: + return False + self.data[digest] = REVOKED + return True + + +@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured") +class SessionRevocationCacheTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + from src.config import load_settings + from src.db import create_pool, wait_and_migrate + from src.security import hash_password + from src.storage import Storage + + cls.settings = load_settings() + wait_and_migrate(cls.settings) + cls.pool = create_pool(cls.settings) + cls.pool.wait(timeout=10) + cls.storage = Storage(cls.pool) + cls.user = cls.storage.create_user("rvk_" + uuid.uuid4().hex[:12], "Revoke", + hash_password("Revoke-test-password")) + + @classmethod + def tearDownClass(cls): + cls.pool.close() + + def service(self, cache): + from src.sessions import SessionService + return SessionService(self.storage, cache, self.settings) + + def pending(self, digest): + with self.pool.connection() as conn: + return conn.execute("SELECT count(*) FROM session_cache_invalidations WHERE token_hash = %s", + (digest,)).fetchone()[0] + + def warm(self, svc, cache, token): + from src.security import token_digest + self.assertEqual(svc.resolve(token).id, self.user.id) + self.assertIsInstance(cache.data.get(token_digest(token)), tuple, "cache was not warmed") + + def test_revoked_token_rejected_after_partition_heals(self): + from src.security import token_digest + cache = PartitionableCache() + svc = self.service(cache) + token, _ = svc.create(self.user) + digest = token_digest(token) + self.warm(svc, cache, token) + + cache.partitioned = True + self.assertTrue(svc.revoke(token), "logout must succeed (PostgreSQL is the source of truth)") + self.assertIsInstance(cache.data[digest], tuple, "precondition: stale positive entry survived") + self.assertEqual(self.pending(digest), 1, "invalidation debt must be committed with revoked_at") + self.assertIsNone(svc.resolve(token), "during partition") + + cache.partitioned = False # тот же «Redis», данные не потеряны + self.assertIsNone(svc.resolve(token), "immediately after partition heals") + time.sleep(svc.RECHECK_SECONDS + 0.1) + self.assertIsNone(svc.resolve(token), "after reconciliation") + self.assertEqual(cache.data[digest], "revoked", "reconciliation must write the tombstone") + self.assertEqual(self.pending(digest), 0, "debt must be cleared after the tombstone") + + # После погашения долга кэшу снова доверяют: другой токен обслуживается из кэша. + other, _ = svc.create(self.user) + self.warm(svc, cache, other) + + def test_debt_survives_api_restart(self): + """Процесс, выполнивший logout, умер до восстановления связи — новый процесс не доверяет кэшу.""" + from src.security import token_digest + cache = PartitionableCache() + svc = self.service(cache) + token, _ = svc.create(self.user) + self.warm(svc, cache, token) + cache.partitioned = True + self.assertTrue(svc.revoke(token)) + del svc # «рестарт API»: состояние процесса потеряно + + cache.partitioned = False + restarted = self.service(cache) + self.assertIsNone(restarted.resolve(token)) + self.assertEqual(cache.data[token_digest(token)], "revoked") + + def test_normal_logout_leaves_no_debt(self): + from src.security import token_digest + cache = PartitionableCache() + svc = self.service(cache) + token, _ = svc.create(self.user) + self.warm(svc, cache, token) + self.assertTrue(svc.revoke(token)) + self.assertEqual(cache.data[token_digest(token)], "revoked") + self.assertEqual(self.pending(token_digest(token)), 0) + self.assertIsNone(svc.resolve(token)) + self.assertFalse(svc.revoke(token), "second logout must fail") + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/test_storage_idempotency.py b/student-tests/test_storage_idempotency.py new file mode 100644 index 0000000..b433420 --- /dev/null +++ b/student-tests/test_storage_idempotency.py @@ -0,0 +1,144 @@ +"""Идемпотентность на уровне хранилища (нужен прямой доступ к PostgreSQL). + +* сбой ПОСЛЕ вставки ключа и сообщения внутри транзакции -> не остаётся ни ключа, + ни сообщения, и повтор с тем же ключом создаёт сообщение (5xx не фиксируется); +* 16 потоков с одним ключом -> ровно одна вставка, остальные — повтор; +* истёкший ключ можно занять заново; очистка удаляет только истёкшие строки и + выполняется одной репликой за раз (advisory lock). + +Запуск внутри compose-сети (БД наружу не публикуется): + python scripts/ops.py in-network storage +Без DATABASE_URL/DATABASE_URL_FILE тест пропускается. +""" +import hashlib +import os +import sys +import threading +import time +import unittest +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE")) +DAY = 86400 + + +class InjectedFailure(RuntimeError): + pass + + +def fp(text): + return hashlib.sha256(text.encode()).digest() + + +@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured") +class StorageIdempotencyTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + from src.config import load_settings + from src.db import create_pool, wait_and_migrate + from src.security import hash_password + from src.storage import Storage + + settings = load_settings() + wait_and_migrate(settings) + cls.pool = create_pool(settings) + cls.pool.wait(timeout=10) + cls.storage = Storage(cls.pool) + h = hash_password("Idempotency-test-password") + cls.user = cls.storage.create_user("idm_" + uuid.uuid4().hex[:12], "Idem", h) + cls.chat = cls.storage.create_chat("idem-" + uuid.uuid4().hex[:8], [cls.user.id]) + + @classmethod + def tearDownClass(cls): + cls.pool.close() + + def count(self, sql, params): + with self.pool.connection() as conn: + return conn.execute(sql, params).fetchone()[0] + + def keys(self, key): + return self.count("SELECT count(*) FROM idempotency_keys WHERE user_id = %s AND idem_key = %s", + (self.user.id, key)) + + def test_failure_inside_transaction_stores_nothing(self): + key = "fail-" + uuid.uuid4().hex + text = "сбой " + key + original = self.storage._insert_message + seen = {} + + def insert_then_fail(conn, message_id, chat_id, sender_id, body): + original(conn, message_id, chat_id, sender_id, body) + seen["keys"] = conn.execute("SELECT count(*) FROM idempotency_keys WHERE idem_key = %s", (key,)).fetchone()[0] + seen["messages"] = conn.execute("SELECT count(*) FROM messages WHERE id = %s", (message_id,)).fetchone()[0] + raise InjectedFailure("crash after both inserts, before COMMIT") + + self.storage._insert_message = insert_then_fail + try: + with self.assertRaises(InjectedFailure): + self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY) + finally: + self.storage._insert_message = original + self.assertEqual((seen["keys"], seen["messages"]), (1, 1), "inserts were visible inside the transaction") + self.assertEqual(self.keys(key), 0) + self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 0) + # Клиент повторяет неподтверждённый запрос с тем же ключом — теперь успешно. + msg, replayed = self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY) + self.assertFalse(replayed) + self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 1) + + def test_threads_same_key_single_insert(self): + key = "thr-" + uuid.uuid4().hex + text = "потоки " + key + barrier = threading.Barrier(16) + + def call(_): + barrier.wait() + return self.storage.create_message(self.chat.id, self.user.id, text, key, fp(text), DAY) + + with ThreadPoolExecutor(max_workers=16) as pool: + results = list(pool.map(call, range(16))) + self.assertEqual(sum(1 for _, replayed in results if not replayed), 1) + self.assertEqual(len({m.id for m, _ in results}), 1) + self.assertEqual(self.count("SELECT count(*) FROM messages WHERE text = %s", (text,)), 1) + + def test_conflict_on_different_body(self): + from src.storage import IdempotencyConflict + key = "cnf-" + uuid.uuid4().hex + self.storage.create_message(self.chat.id, self.user.id, "a", key, fp("a"), DAY) + with self.assertRaises(IdempotencyConflict): + self.storage.create_message(self.chat.id, self.user.id, "b", key, fp("b"), DAY) + + def test_expired_key_can_be_reused_and_is_cleaned(self): + key = "exp-" + uuid.uuid4().hex + first, _ = self.storage.create_message(self.chat.id, self.user.id, "старый", key, fp("старый"), 1) + time.sleep(1.2) + # Истёк: другое тело уже не конфликт, создаётся новое сообщение. + second, replayed = self.storage.create_message(self.chat.id, self.user.id, "новый", key, fp("новый"), DAY) + self.assertFalse(replayed) + self.assertNotEqual(first.id, second.id) + self.assertEqual(self.keys(key), 1) + # Очистка удаляет только истёкшие ключи. + k2 = "exp2-" + uuid.uuid4().hex + self.storage.create_message(self.chat.id, self.user.id, "x", k2, fp("x"), 1) + time.sleep(1.2) + while self.storage.delete_expired_idempotency_keys(): + pass + self.assertEqual(self.keys(k2), 0) + self.assertEqual(self.keys(key), 1) + + def test_cleanup_runs_on_one_replica_at_a_time(self): + from src.storage import IDEMPOTENCY_CLEANUP_LOCK_ID + with self.pool.connection() as conn: + with conn.transaction(): + conn.execute("SELECT pg_advisory_xact_lock(%s)", (IDEMPOTENCY_CLEANUP_LOCK_ID,)) + self.assertIsNone(self.storage.delete_expired_idempotency_keys()) + self.assertIsNotNone(self.storage.delete_expired_idempotency_keys()) + + +if __name__ == "__main__": + unittest.main() diff --git a/student-tests/test_storage_rollback.py b/student-tests/test_storage_rollback.py new file mode 100644 index 0000000..305f0ec --- /dev/null +++ b/student-tests/test_storage_rollback.py @@ -0,0 +1,101 @@ +"""Rollback на уровне хранилища с внедрённым сбоем (нужен прямой доступ к БД). + +Сбой вызывается ПОСЛЕ того, как строки chats и chat_members уже вставлены +внутри транзакции. Проверяем, что в БД не осталось ни чата, ни участников. + +Запуск внутри compose-сети (БД наружу не публикуется): + docker compose run --rm --no-deps -v "$PWD/student-tests:/app/student-tests:ro" \ + api python -m unittest discover -s student-tests -p test_storage_rollback.py -v +Без DATABASE_URL/DATABASE_URL_FILE тест пропускается. +""" +import os +import sys +import unittest +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) + +HAS_DB = bool(os.environ.get("DATABASE_URL") or os.environ.get("DATABASE_URL_FILE")) + + +class InjectedFailure(RuntimeError): + pass + + +@unittest.skipUnless(HAS_DB, "DATABASE_URL is not configured") +class StorageRollbackTests(unittest.TestCase): + + @classmethod + def setUpClass(cls): + from src.config import load_settings + from src.db import create_pool, wait_and_migrate + from src.security import hash_password + from src.storage import Storage + + settings = load_settings() + wait_and_migrate(settings) + cls.pool = create_pool(settings) + cls.pool.wait(timeout=10) + cls.storage = Storage(cls.pool) + h = hash_password("Rollback-test-password") + cls.users = [ + cls.storage.create_user("rbk_" + uuid.uuid4().hex[:12], "Rollback", h) + for _ in range(3) + ] + + @classmethod + def tearDownClass(cls): + cls.pool.close() + + def count(self, sql, params): + with self.pool.connection() as conn: + return conn.execute(sql, params).fetchone()[0] + + def test_failure_after_inserts_leaves_nothing(self): + title = "rollback-" + uuid.uuid4().hex + original = self.storage._insert_members + seen = {} + + def insert_then_fail(conn, chat_id, member_ids): + original(conn, chat_id, member_ids) + # Внутри транзакции строки видны — значит вставка действительно была. + seen["chats"] = conn.execute("SELECT count(*) FROM chats WHERE title = %s", (title,)).fetchone()[0] + seen["members"] = conn.execute("SELECT count(*) FROM chat_members WHERE chat_id = %s", (chat_id,)).fetchone()[0] + seen["chat_id"] = chat_id + raise InjectedFailure("simulated crash between statements") + + self.storage._insert_members = insert_then_fail + try: + with self.assertRaises(InjectedFailure): + self.storage.create_chat(title, [u.id for u in self.users]) + finally: + self.storage._insert_members = original + + self.assertEqual(seen["chats"], 1) + self.assertEqual(seen["members"], 3) + self.assertEqual(self.count("SELECT count(*) FROM chats WHERE title = %s", (title,)), 0) + self.assertEqual(self.count("SELECT count(*) FROM chat_members WHERE chat_id = %s", (seen["chat_id"],)), 0) + + def test_no_orphan_chats_in_database(self): + orphans = self.count( + "SELECT count(*) FROM chats c WHERE NOT EXISTS " + "(SELECT 1 FROM chat_members m WHERE m.chat_id = c.id)", ()) + self.assertEqual(orphans, 0) + + def test_migrations_are_idempotent(self): + from src.config import load_settings + from src.db import apply_migrations + self.assertEqual(apply_migrations(load_settings()), []) + self.assertEqual(self.count("SELECT count(*) FROM schema_migrations WHERE version = %s", ("001_init",)), 1) + + def test_passwords_stored_as_argon2id(self): + with self.pool.connection() as conn: + stored = conn.execute("SELECT password_hash FROM users WHERE id = %s", + (self.users[0].id,)).fetchone()[0] + self.assertTrue(stored.startswith("$argon2id$"), stored[:10]) + self.assertNotIn("Rollback-test-password", stored) + + +if __name__ == "__main__": + unittest.main(verbosity=2) diff --git a/student-tests/wait_url.py b/student-tests/wait_url.py new file mode 100644 index 0000000..ddf59a4 --- /dev/null +++ b/student-tests/wait_url.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python3 +"""Ждать HTTP 200 по URL (до 90 с). Используется внутри compose-сети: ops.py in-network.""" +import sys +import time +from urllib.request import urlopen + +url = sys.argv[1] +deadline = time.monotonic() + float(sys.argv[2] if len(sys.argv) > 2 else 90) +while time.monotonic() < deadline: + try: + if urlopen(url, timeout=2).status == 200: + print("ready: " + url) + sys.exit(0) + except OSError: + pass + time.sleep(0.5) +print("not ready: " + url) +sys.exit(1)