Author SHA1 Message Date
scarletsky fafd1828c0 Лабораторная работа 3 2026-10-26 23:23:12 +03:00
70 changed files with 6665 additions and 25 deletions
+28 -3
View File
@@ -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
+10
View File
@@ -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
+8 -8
View File
@@ -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.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
+33
View File
@@ -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"]
+74 -1
View File
@@ -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
+207 -13
View File
@@ -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), а ключи идемпотентности — в общей БД.
+212
View File
@@ -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
+20
View File
@@ -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) |
+34
View File
@@ -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
+7
View File
@@ -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
+66
View File
@@ -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']
+294
View File
@@ -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
}
+17
View File
@@ -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
+294
View File
@@ -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
}
+22
View File
@@ -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
+17
View File
@@ -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"}}
+62
View File
@@ -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"
+17
View File
@@ -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."
}
+28
View File
@@ -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%
+26
View File
@@ -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.
+24
View File
@@ -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
+147
View File
@@ -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
}
+147
View File
@@ -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
}
+29
View File
@@ -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
+17
View File
@@ -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]
+3
View File
@@ -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.
+33
View File
@@ -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
+134
View File
@@ -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
+6
View File
@@ -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`.
+96
View File
@@ -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
+66
View File
@@ -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);
@@ -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);
+40
View File
@@ -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);
+7
View File
@@ -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
+174
View File
@@ -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/<out_file>."""
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()
+45
View File
@@ -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()
+398
View File
@@ -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=<X-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()
+9
View File
@@ -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%
+8
View File
@@ -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
+93
View File
@@ -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'
+9
View File
@@ -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%
+10
View File
@@ -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
View File
+122
View File
@@ -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),
)
+130
View File
@@ -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
+482
View File
@@ -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)
+25
View File
@@ -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()
+83
View File
@@ -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]
+39
View File
@@ -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()
+97
View File
@@ -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
+65
View File
@@ -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()
+240
View File
@@ -0,0 +1,240 @@
"""Сессии: PostgreSQL — источник истины, Redis — кэш проверок токена.
Роль Redis
----------
Каждый защищённый запрос сначала ищет `sess:<sha256(token)>` в 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:<hash> = "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
+411
View File
@@ -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
+108
View File
@@ -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
+206
View File
@@ -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()
+163
View File
@@ -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()
+169
View File
@@ -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)),
}
+202
View File
@@ -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()
+37
View File
@@ -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()<end:
seen.add(request("GET","/api/v1/users/me",token=t).status); time.sleep(0.25)
print("revoked token statuses over 8 s after heal:", sorted(seen))
ok = seen == {401}
print("PASS" if ok else "FAIL", ": revoked token never accepted after partition heals")
sys.exit(0 if ok else 1)
+95
View File
@@ -0,0 +1,95 @@
#!/usr/bin/env python3
"""Уровень 4: rolling update (поочерёдная замена всех реплик) под нагрузкой.
Нагрузка (писатели с Idempotency-Key + читатели) идёт всё время; посередине
выполняется `python scripts/ops.py rolling-update` (сборка образа, однократные
миграции, +1 новая реплика -> 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()
+47
View File
@@ -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)
+138
View File
@@ -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)
+109
View File
@@ -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)
+80
View File
@@ -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)
+49
View File
@@ -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)
+172
View File
@@ -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()
+149
View File
@@ -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)
+144
View File
@@ -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()
+101
View File
@@ -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)
+18
View File
@@ -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)