Author SHA1 Message Date
RainakandClaude Opus 5.5 30b61609be Исправление по замечанию PR #99: текст с U+0000 вместо 500
PostgreSQL text не хранит 0x00. Expand-миграция 0004 добавляет *_raw bytea для
messages.text, users.display_name, chats.title: точные UTF-8 байты пишутся туда,
если строка содержит U+0000, API возвращает исходную строку. Тест
test_nul_in_text_roundtrip: ответ, история, идемпотентный повтор, 409 на другой текст.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-17 12:33:28 +03:00
RainakandClaude Opus 5.5 54be66fd7b REPORT: ссылка на PR
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 17:42:55 +03:00
RainakandClaude Opus 5.5 95556845e6 ЛР3 БВТ2304 Запорожец на 4
HAProxy + 2 API-реплики, общие PostgreSQL/Valkey, обязательный Idempotency-Key,
graceful drain по SIGTERM, stop-one/restart/rolling-update, серии отказов и REPORT.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 17:36:07 +03:00
48 changed files with 4366 additions and 16 deletions
+22 -1
View File
@@ -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
+6
View File
@@ -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
+26
View File
@@ -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
View File
@@ -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"]
+150 -15
View File
@@ -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 для заявления устойчивости к потере узла.
View File
+48
View File
@@ -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()
+63
View File
@@ -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,
)
+65
View File
@@ -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
+48
View File
@@ -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,
)
+16
View File
@@ -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
View File
@@ -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)
+57
View File
@@ -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())
+22
View File
@@ -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
+47
View File
@@ -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
View File
@@ -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])
+108
View File
@@ -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
View File
@@ -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
+17
View File
@@ -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
+456
View File
@@ -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
}
]
}
]
}
+456
View File
@@ -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
}
]
}
]
}
+14
View File
@@ -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
+10
View File
@@ -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}
+8
View File
@@ -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
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.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."
}
+17
View File
@@ -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.
+8
View File
@@ -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.
+537
View File
@@ -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"
}
]
}
]
}
+23
View File
@@ -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)
+22
View File
@@ -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
+89
View File
@@ -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
+59
View File
@@ -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);
+21
View File
@@ -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);
+10
View File
@@ -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');
+7
View File
@@ -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);
+20
View File
@@ -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
+47
View File
@@ -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'
+36
View File
@@ -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)'
+14
View File
@@ -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
+13
View File
@@ -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}}'
+36
View File
@@ -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"}}'
+29
View File
@@ -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"
+12
View File
@@ -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
+312
View File
@@ -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())
+15
View File
@@ -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)))
+256
View File
@@ -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())
+306
View File
@@ -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())
+4
View File
@@ -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