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