ЛР 3 — БВТ2303 — Попов — на 4 #53
+28
-3
@@ -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
|
||||
|
||||
@@ -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
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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
|
||||
@@ -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) |
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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']
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
@@ -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"}}
|
||||
@@ -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"
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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%
|
||||
|
||||
@@ -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.
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
@@ -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
|
||||
|
||||
@@ -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]
|
||||
@@ -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.
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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`.
|
||||
|
||||
@@ -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
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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
@@ -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()
|
||||
@@ -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%
|
||||
@@ -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
|
||||
@@ -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'
|
||||
@@ -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%
|
||||
@@ -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
|
||||
+122
@@ -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),
|
||||
)
|
||||
@@ -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
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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]
|
||||
@@ -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()
|
||||
@@ -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
|
||||
@@ -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
@@ -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
@@ -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
|
||||
@@ -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
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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)),
|
||||
}
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user