diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..213707e8 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,8 @@ +# Скрипты и конфигурации исполняются в Linux-контейнерах: всегда LF. +*.sh text eol=lf +*.cfg text eol=lf +*.sql text eol=lf +*.py text eol=lf +*.yaml text eol=lf +Dockerfile* text eol=lf +Makefile text eol=lf diff --git a/.gitignore b/.gitignore index b5a71896..2aab6771 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,5 @@ coverage/ .vscode/ # Keep small, sanitized evidence summaries in evidence/ under version control. # Inspect git diff --cached: ignore rules are not a secret scanner. +# Lab3 local secrets (scripts/init-secrets.sh) +infra/secrets/*.txt diff --git a/COURSE.md b/COURSE.md index b02172bb..0c8f108d 100644 --- a/COURSE.md +++ b/COURSE.md @@ -2,15 +2,15 @@ Семь самостоятельных репозиториев содержат задания и проверяемые контракты одной системы. Вы переносите собственную реализацию между лабораторными. Язык, фреймворк и библиотеки выбираете сами. Web UI, WebSocket, редактирование/удаление сообщений, публичный поиск пользователей и Kubernetes не входят в обязательный минимум: достаточно REST API. -| Лаба | Новая инженерная задача | Что появляется в системе | -| --- | --- | --- | -| 1 | Контракт, процессы и контейнер | In-memory API, Dockerfile, HTTP smoke | -| 2 | Сохранность и идентификация | PostgreSQL, Basic → сессия; Redis/Valkey на 4 | -| 3 | Горизонтальное масштабирование | Балансировщик, ≥2 API-реплики, общие сессии, идемпотентность | -| 4 | Бинарные данные | Приватное S3-совместимое хранилище и вложения | -| 5 | Фоновая работа | Брокер, worker, состояния вложений и преобразование изображений | -| 6 | Диагностика | OTel Collector, хранилища сигналов, Grafana | -| 7 | Защита и эксплуатация | Argon2id, TLS/mTLS, OpenBao, минимальные привилегии | +| Лаба | Новая инженерная задача | Что появляется в системе | +|--------|--------------------------------|-----------------------------------------------------------------| +| 1 | Контракт, процессы и контейнер | In-memory API, Dockerfile, HTTP smoke | +| 2 | Сохранность и идентификация | PostgreSQL, Basic → сессия; Redis/Valkey на 4 | +| 3 | Горизонтальное масштабирование | Балансировщик, ≥2 API-реплики, общие сессии, идемпотентность | +| 4 | Бинарные данные | Приватное S3-совместимое хранилище и вложения | +| 5 | Фоновая работа | Брокер, worker, состояния вложений и преобразование изображений | +| 6 | Диагностика | OTel Collector, хранилища сигналов, Grafana | +| 7 | Защита и эксплуатация | Argon2id, TLS/mTLS, OpenBao, минимальные привилегии | ## Как оценивать diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..17b9582a --- /dev/null +++ b/Dockerfile @@ -0,0 +1,24 @@ +# Messenger API (lab3). One image for the "api" and "migrate" services. +FROM python:3.12.7-slim + +WORKDIR /app + +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app ./app +COPY scripts/migrate.py ./scripts/migrate.py +COPY migrations ./migrations + +RUN useradd --create-home --uid 10001 appuser +USER appuser + +EXPOSE 8080 + +# Exec form: python is PID 1 and receives SIGTERM from "docker stop" itself. +# (lab2 used "sh -c uvicorn ...": sh stayed PID 1, uvicorn never got SIGTERM +# and was killed together with the container instead of draining.) +CMD ["python", "-m", "app.server"] diff --git a/Dockerfile.example b/Dockerfile.example deleted file mode 100644 index e333a12e..00000000 --- a/Dockerfile.example +++ /dev/null @@ -1,8 +0,0 @@ -# Teaching outline, not a runnable Dockerfile. Implement your own Dockerfile. -# 1. Choose a runtime/toolchain version and pin the base image tag/digest. -# 2. Copy dependency manifests first; install from the language lockfile. -# 3. Copy source and build. For compiled languages use a separate runtime stage. -# 4. Run the HTTP process as PID 1; listen on 0.0.0.0:8080. -# 5. Add non-root, signals and healthcheck according to the current rubric. -# 6. Pass runtime config/secrets at startup, never COPY .env or secret files. -# This file deliberately has no FROM/CMD: selecting/implementing them is the task. diff --git a/REPORT.md b/REPORT.md index c2679005..2cddede6 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,243 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +Балансировка и отказ API-реплики -## Запуск из чистого clone +- Автор, группа: Максимова Мария, БВТ2303 +- Целевая оценка: 4 +- Commit/PR: TODO после публикации (ветка `solution/maksimova_bvt2303`) +- Использованные средства: Python 3.12.7 (в Docker), FastAPI, uvicorn, SQLAlchemy 2 (async) + asyncpg, argon2-cffi, redis-py (клиент Valkey) — всё из lab2; PostgreSQL 16.4, Valkey 8.0.1, HAProxy 3.0.11, Docker Desktop 29.3.0 + Compose v5.1.0. +- Источники: документация HAProxy 3.0 (resolvers, server-template, http-check, retry-on, http-error), Docker Compose (deploy.replicas, resources, depends_on conditions, secrets), uvicorn (Server, graceful shutdown), PostgreSQL (INSERT … ON CONFLICT, advisory locks). +- Помощь ИИ: Claude Code использовался для переноса lab2 под lab3 (идемпотентность, drain при SIGTERM, X-Instance-Id), конфигурации HAProxy, операторских скриптов, собственных тестов и черновика отчёта. Все команды и измерения запущены на моём стенде 2026-10-13, сырые результаты — в `evidence/`. -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +## 0. Коротко и простыми словами -## Архитектура и решения +Раньше (lab2) был один процесс API. Если он падал — мессенджер не работал. В lab3 процессов API два, а перед ними стоит балансировщик HAProxy. Клиент всегда ходит на один адрес `localhost:8080`, а HAProxy по очереди отправляет запросы то в одну реплику, то в другую. Если одна реплика умирает, HAProxy это замечает и отправляет всё в живую. -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Чтобы такое работало, API не должен ничего важного хранить «у себя в памяти». Всё хранится в общих местах: -## Доказательства критериев +- PostgreSQL — все данные, сессии (токены входа) и ключи идемпотентности; +- Valkey — только быстрый кэш сессий (если его потерять, ничего не сломается — данные возьмутся из PostgreSQL). -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Поэтому неважно, какая реплика обработала запрос: обе видят одни и те же данные и один и тот же токен. -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Вторая проблема — повторы. Клиент отправил сообщение, реплика упала, ответа нет. Сообщение сохранилось или нет? Клиент не знает и повторяет запрос. Чтобы повтор не создал дубль, клиент передаёт заголовок `Idempotency-Key` — уникальную строку на одно сообщение. Сервер запоминает ключ в PostgreSQL вместе с сообщением. Если пришёл тот же ключ ещё раз, сервер не создаёт новое сообщение, а возвращает уже сохранённое. -## Эксперименты и отказы +Что проверено (подробности и цифры — в разделах 5–6): -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +| Что | Результат m | +|--------------------------------------------------------|----------------------------------------------------------------------------| +| Публичные тесты `make check`, `make test` | PASS | +| Запросы одного пользователя обслуживают разные реплики | да, `X-Instance-Id` чередуется, повторный вход не нужен | +| Остановка каждой реплики (`make test-failover`) | PASS для обеих, 0 ошибок, запись снова работает через 4.4–4.5 s | +| Перезапуск всего стенда (`make test-persistence`) | PASS, данные и прежний токен сохранились | +| 16 одновременных POST с одним ключом, 10 раз | каждый раз ровно 1 сообщение, запросы шли через обе реплики | +| Остановка/убийство реплик под нагрузкой (4 прогона) | 1 ошибка на ~11 600 запросов (при SIGKILL), потерь и дублей 0 | +| Rolling update (замена обеих реплик новой версией) | 70 s под нагрузкой, 0 ошибок, 4 826 записей, потерь и дублей 0 | -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +## 1. Что сделано -## Ограничения и следующие шаги +Из lab2 перенесены `app/`, миграции 001–002, `scripts/migrate.py`, `scripts/init-secrets.sh`, `requirements.txt`. Новое в lab3: -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +1. HAProxy (`infra/haproxy/haproxy.cfg`) — единственная публичная точка входа `:8080`. Сервис Compose `api` запускается в 2 экземплярах (`deploy.replicas: 2`), у него нет `ports` и нет `container_name`. +2. HAProxy сам находит реплики через встроенный DNS Docker: имя `api` возвращает IP всех работающих контейнеров сервиса (`server-template api 8 api:8080 … resolvers docker`). Каждую секунду HAProxy проверяет у каждой реплики `/health/ready`. Балансировка — обычный round-robin, без sticky session. +3. В процессе API нет локального состояния: всё в PostgreSQL и общем Valkey. +4. Каждый ответ API содержит заголовок `X-Instance-Id` = hostname контейнера (короткий Docker ID). По нему видно, какая реплика ответила. +5. `POST /chats/{id}/messages` требует `Idempotency-Key` (миграция `003_idempotency_keys.sql`, код — `app/repositories.py: create_message_idempotent`). +6. Graceful shutdown (`app/server.py`): получив SIGTERM, реплика 3 s продолжает работать, но отвечает `503` на `/health/ready`. За это время HAProxy выводит её из пула, и только потом она закрывает порт и дорабатывает начатые запросы. +7. Миграции выполняет отдельный одноразовый сервис `migrate` до старта API, а не каждая реплика сама. `pg_advisory_lock` защищает от двух одновременных запусков. +8. Операторские скрипты: `stop-one.sh` (остановить одну реплику), `kill-one.sh` (убить SIGKILL), `start-api.sh` (вернуть), `restart.sh` (перезапуск всего стенда), `rolling-update.sh` (поочерёдная замена реплик). + +Исправления в коде lab2, найденные при переносе: + +- `Dockerfile`: было `CMD ["sh","-c","uvicorn …"]`, стало `CMD ["python","-m","app.server"]`. При `sh -c` процессом №1 в контейнере был `sh`: он не передавал SIGTERM в uvicorn, и `docker stop` убивал процесс без graceful shutdown (проверено через `docker top`). +- `CreateChat.title`: максимум 255 → 100 символов, как в контракте. +- `init-secrets.sh`: файлы секретов 0644 внутри каталога 0700. На Linux пользователь контейнера `appuser` не мог прочитать файл 0600, смонтированный как secret. +- `migrate.py`: повтор подключения к БД и `pg_advisory_lock`. + +## 2. Запуск из чистого clone + +Нужно: Docker Engine/Desktop с Compose v2, `sh`, `make`, Python 3.9+ (для `make test` с хоста). Все образы закреплены версиями: + +| Роль | Service | Образ | Health/readiness | Volume | Сеть / порт | Секреты | +|------------|----------------------------|--------------------------------------------------------------------------------------------|-------------------------------------------------|-----------------|----------------------------------------------------|------------------------------------| +| LB | `lb` | `haproxy:3.0.11-alpine` | `wget /lb-health` (:8404) | — | `edge`; **8080** публично, 8404 только `127.0.0.1` | нет | +| API ×2 | `api` | `messenger-lab3-api:` (сборка из `Dockerfile`, база `python:3.12.7-slim`) | `GET /health/ready` (БД доступна и нет drain) | — | `edge` + `backend`, порт не публикуется | `database_url`, `cache_url` | +| Миграции | `migrate` | тот же образ | завершается с кодом 0 | — | `backend` | `database_url` | +| БД | `db` | `postgres:16.4-alpine` | `pg_isready` | `postgres_data` | `backend` (internal) | `postgres_password` | +| Кэш сессий | `valkey` | `valkey/valkey:8.0.1-alpine` | `valkey-cli ping` | нет (это кэш) | `backend` (internal) | `valkey_password` | +| Проверки | `tester` (profile `tools`) | сборка `student-tests/Dockerfile.tester` (`python:3.12.11-alpine3.22` + docker CLI 28.5.1) | — | — | `edge` | docker.sock (только учебный стенд) | + +Сеть `backend` — `internal: true`: у PostgreSQL и Valkey нет выхода наружу, и HAProxy к ней не подключён. Наружу опубликован только порт 8080 балансировщика. + +```sh +# 1. Секреты (создаются один раз в infra/secrets/, в Git не попадают; значения не печатаются) +sh scripts/init-secrets.sh +cp .env.example .env # необязательные параметры, секретов не содержит + +# 2. Сборка, миграции (сервис migrate) и запуск; --wait ждёт, пока все сервисы станут healthy +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait + +# 3. Проверки уровня 3 +make check +make test # на Windows: PYTHONUTF8=1 make test PYTHON=python +docker compose --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh +docker compose --profile tools run --rm tester sh scripts/start-api.sh # вернуть остановленную реплику +docker compose --profile tools run --rm tester make test-persistence ACTION_SCRIPT=scripts/restart.sh + +# 4. Проверки уровня 4 +docker compose --profile tools run --rm tester python3 student-tests/idempotency_concurrency.py +docker compose --profile tools run --rm tester sh student-tests/run-failover-series.sh +# rolling update: терминал 1 — нагрузка 70 s, терминал 2 (на хосте, сразу после старта нагрузки) — замена реплик +docker compose --profile tools run --rm tester python3 student-tests/failover_load.py --duration 70 --label rolling-update --output evidence/rolling-update-load.json +APP_VERSION=v3 sh scripts/rolling-update.sh + +# Состояние реплик в LB (UP/DOWN, счётчики): http://127.0.0.1:8404/stats +# Безопасная остановка (данные сохраняются в volume): +docker compose down +# Намеренное удаление учебных данных (удаляет volume с БД!): +docker compose down -v +``` + +Почему тесты отказа запускаются в контейнере `tester`. Публичный тест вызывает `.sh`-скрипт через `subprocess.Popen`, а Windows не умеет исполнять `.sh`. Поэтому failover/persistence запускаются в контейнере `tester`: там есть Python, make и docker CLI, а `BASE_URL = http://lb:8080` (тот же балансировщик, только изнутри Docker-сети). Сами тесты не менялись. На Linux те же команды можно запускать прямо с хоста. + +Про `APP_VERSION`. `rolling-update.sh` переводит реплики на образ `messenger-lab3-api:$APP_VERSION`. Последний прогон перевёл стенд на `v3`. Дальнейшие `docker compose up` нужно выполнять с тем же `APP_VERSION=v3`, иначе Compose пересоздаст реплики на образе `dev`. + +Переменные `.env.example` → реальная конфигурация: + +| `.env.example` | Где используется | +|---------------------------|------------------------------------------------------------------| +| `APP_HOST`, `APP_PORT` | заданы в `compose.yaml` (0.0.0.0:8080) | +| `SESSION_TTL_SECONDS` | `api` (по умолчанию 3600) | +| `DATABASE_URL_FILE` | `/run/secrets/database_url` у `api` и `migrate` | +| `SESSION_STORE` | `valkey`: сессии в PostgreSQL, cache-aside в Valkey (как в lab2) | +| `CACHE_URL_FILE` | `/run/secrets/cache_url` у `api` | +| `API_REPLICAS` | `deploy.replicas` сервиса `api` (по умолчанию 2) | +| `IDEMPOTENCY_TTL_SECONDS` | `api` (86400 = 24 ч) | +| `APP_ENV` | не используется приложением | + +## 3. Архитектура и решения + +``` +client ──HTTP:8080──► HAProxy (lb) ──round-robin, проверка /health/ready раз в 1 s──► api-1 ─┐ + │ DNS Docker 127.0.0.11: имя "api" → IP всех реплик api-2 ─┤ + └─ X-Request-Id, повтор на другую реплику при отказе ... │ + ▼ + сеть backend (internal): PostgreSQL (источник истины) + Valkey (кэш сессий) +``` + +Источник истины — PostgreSQL: пользователи, чаты, участники, сообщения, сессии (хеш токена), ключи идемпотентности. Valkey хранит только копию «хеш токена → пользователь» с TTL ≤ 60 s. Logout на одной реплике пишет в общий Valkey отметку `revoked` (tombstone), её сразу видят все реплики. Поэтому повторный вход при смене реплики не нужен: в failover-тесте 40 запросов `/users/me` одним токеном обслужили 2 разные реплики. + +Как работает идемпотентность. Таблица `idempotency_keys`: первичный ключ `(user_id, chat_id, method, key)`, `request_hash` = SHA-256 тела запроса, `message_id`. Всё делается в одной транзакции: + +1. `INSERT … ON CONFLICT DO UPDATE … WHERE created_at < now() - TTL RETURNING 1` — «занять» ключ. Если тот же ключ в этот момент занимает незавершённая транзакция на другой реплике, PostgreSQL заставляет вторую транзакцию ждать на уникальном индексе. Так одновременные повторы выстраиваются в очередь в самой БД, без блокировок в памяти API. +2. Ключ занят нами → `INSERT` сообщения, `UPDATE` ключа ссылкой на сообщение, `COMMIT`. Если что-то упало до COMMIT, откатываются обе записи: ни сообщения, ни ключа нет, и повтор выполнится заново. +3. Ключ уже был сохранён раньше → если хеш тела совпадает, возвращается `201` с тем же сообщением и заголовком `Idempotent-Replayed: true`; если тело другое — `409`. Ключ старше 24 ч можно использовать заново. + +До всего этого повтор проходит проверку токена и членства в чате (посторонний получит `404`). Область действия ключа: пользователь + метод + чат + ключ — тот же ключ у другого пользователя или в другом чате создаёт новое сообщение (проверено тестом). + +Миграции: Сервис `migrate` стартует после того, как БД стала healthy, а API — только после того, как `migrate` успешно завершился (`depends_on: service_completed_successfully`). Повторный запуск печатает `SKIP`. Миграция 003 только добавляет таблицу, поэтому её можно применить, пока работает старая версия API. Правило на будущее: удалять/переименовывать колонки — отдельным релизом, когда ни одна реплика их уже не использует (expand → deploy → contract). Автоматической проверки совместимости нет — это ограничение. + +Транзакционные границы: создание чата с участниками — одна транзакция (из lab2); сообщение + ключ идемпотентности — одна транзакция; отзыв сессии — UPDATE в PostgreSQL, затем tombstone в Valkey. + +## 4. Health, timeouts и обнаружение отказа (уровень 4) + +| Параметр | Значение | Где | +|------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------| +| `/health/live` | 200, только «процесс жив» | `app/main.py` | +| `/health/ready` | 200, если `SELECT 1` в PostgreSQL успешен и нет drain; иначе 503. Valkey не критичен: без него запросы идут в PostgreSQL | `app/main.py` | +| Активная проверка LB | `inter 1s`, `fall 2`, `rise 2`, `timeout check 1s` (раз в секунду; 2 неудачи подряд → DOWN; 2 успеха → UP) | `infra/haproxy/haproxy.cfg` | +| Пассивная проверка LB | `observe layer4 error-limit 1 on-error mark-down`: первая же ошибка соединения на реальном запросе сразу переводит сервер в DOWN | там же | +| DNS-обновление списка реплик | `hold valid 2s` (резолвер Docker 127.0.0.11) | там же | +| Таймауты LB | connect 1 s, server 10 s, http-request 10 s, keep-alive 10 s, client 30 s | там же | +| Повторы в LB | `retries 2`, `option redispatch 1`, `retry-on conn-failure empty-response 503`. Повтор уже отправленного запроса запрещён для POST (кроме POST сообщения с `Idempotency-Key`) и для DELETE | там же | +| Приложение | statement_timeout 5 s, ожидание соединения из пула 3 s, connect 3 s; uvicorn keep-alive 30 s (больше, чем 10 s у LB — соединение первым закрывает LB) | `compose.yaml`, `app/server.py` | +| SIGTERM | drain 3 s (readiness 503, `Connection: close`), затем закрытие порта и ожидание текущих запросов ≤ 8 s; `stop_grace_period: 15s` > 3 + 8 | `app/server.py`, `compose.yaml` | +| Docker healthcheck API | каждые 2 s, 2 неудачи | `compose.yaml` | + +Как таймауты согласованы между собой: `timeout server` LB (10 s) больше, чем БД может держать запрос (5 s statement + 3 s ожидание пула), поэтому LB не обрывает запрос, который приложение ещё может успешно завершить. Drain (3 s) больше, чем время, за которое LB замечает 503 (≈ 2–3 s), поэтому к моменту закрытия порта новые запросы на реплику уже не идут. + +**Максимальное время обнаружения отказа** (по конфигурации): + +- процесс упал (connection refused/reset) — на первом же реальном запросе (`observe layer4`), сам запрос тут же повторяется на другой реплике; если трафика нет — активная проверка, ≤ `inter × fall` = 2 s; +- процесс жив, но не готов (нет БД, идёт drain) — ≤ `inter × fall + timeout check` ≈ 3 s; +- процесс завис (не отвечает вовсе) — ≤ 2 × (1 s интервал + 1 s таймаут проверки) ≈ 4 s; запросы, уже отправленные на зависшую реплику, ждут до `timeout server` = 10 s. + +Что видно при `docker stop` реплики: в логе HAProxy `Server api/apiN is DOWN, reason: Layer7 wrong status, code: 503`, затем в логе API `drain finished: closing listener`, контейнер завершается с `Exited (0)`. Сам `docker stop` занимает ≈ 4 s (окно действия 4.13 и 4.04 s в `evidence/failover-stop-*.json`). При SIGKILL (`kill-one.sh`) код выхода `137`. + +## 5. Доказательства критериев + +Все прогоны — 2026-10-13, 14:49–14:58 UTC, на стенде из раздела 6. + +| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл | +|---------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------| +| Публичный smoke | `make test` (хост → `localhost:8080`) | `PASS: lab3 public API scenario` | `evidence/public-tests.txt` | +| Структура контракта | `make check` | PASS | `evidence/public-tests.txt` | +| ≥2 реплики, одна точка входа, общая БД и сессии | `docker compose ps`; 4 запроса подряд через LB; 40× `/users/me` одним токеном в failover-тесте | 2 контейнера `api`; `X-Instance-Id` чередуется `fcae2c6047af` / `1ff54c0efa0c`; `observed_instances_before: 2`, без повторного входа | `evidence/public-tests.txt` | +| Остановка любой одной реплики, восстановление ≤10 s | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` дважды — по разу для каждой реплики (в tester) | оба PASS; `failed_attempts: 0`; `first_recovery_seconds` 4.4 и 4.52; в `docker ps -a` `Exited (0)` сначала у `1ff54c0efa0c`, потом у `fcae2c6047af` — остановлен реальный контейнер | `evidence/public-tests.txt` | +| Повтор с тем же ключом без дублей, в т.ч. во время отказа | `resilience.py` повторяет неопределённый POST тем же ключом; smoke: повтор = то же сообщение, другое тело = 409 | PASS, дублей нет | `evidence/public-tests.txt` | +| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS, прежний токен действует; `StartedAt` у db, valkey, обеих api и lb — после запуска hook (14:50:49–14:51:02), volume `messenger-lab3_postgres_data` на месте | `evidence/persistence.txt` | +| 4: health/readiness/timeouts/SIGTERM согласованы, LB исключает backend | конфигурация + `docker stop` реплики | раздел 4; реплика перестаёт получать запросы через 0.87–0.99 s после начала `docker stop`; выход с кодом 0 | раздел 4, `evidence/failover-stop-*.json` | +| 4: поочерёдная остановка каждой реплики под нагрузкой: RPS, ошибки, время восстановления | `student-tests/run-failover-series.sh` (stop и kill для каждой реплики, с восстановлением предыдущей) | таблица в разделе 6; 1 ошибка на 4 прогона, потерь и дублей 0 | `evidence/failover-*.json`, `evidence/failover-series.txt` | +| 4: параллельные запросы с одним ключом | `student-tests/idempotency_concurrency.py` (10 раундов × 16 одновременных POST с одним ключом) | в каждом раунде 1 сообщение и 15 ответов-повторов; все 10 раундов прошли через 2 реплики; другое тело → 409; ключ не мешает другому пользователю/чату | `evidence/idempotency-concurrency.json` | +| 4: CPU/RAM-лимиты, нет портов API наружу, нет `container_name`, секреты только где нужны | `compose.yaml` | лимиты у всех сервисов; у `api` нет `ports`; db/valkey в `internal`-сети; у LB нет секретов (таблица в разделе 2) | `compose.yaml` | +| 4: rolling update под нагрузкой, однократные совместимые миграции | `APP_VERSION=v3 sh scripts/rolling-update.sh` + параллельно `failover_load.py` (70 s, 4 потока) | обе реплики v2 заменены на v3 (новые `a9d3dc77f288`, `ea0e32824716`); 4 826 подтверждённых записей, 0 ошибок, максимальная пауза между записями 0.054 s; миграции один раз, все `SKIP` | `evidence/rolling-update.txt`, `evidence/rolling-update-load.json` | +| Нагрузка (справочно) | `tests/load.py --duration 30 --concurrency 4`, 4 прогона | 142–154 успешных RPS (среднее ≈ 148), 0 ошибок, p50 ≈ 15 ms, p95 76–86 ms, p99 98–138 ms | `evidence/load*.json`, `evidence/load-docker-stats.txt` | + +Почему `X-Instance-Id` — не единственное доказательство: заголовок пишет само приложение. Поэтому после каждого отказа сохранён вывод `docker ps -a`: видно, что `Exited` именно тот контейнер, чей ID был в `TARGET_INSTANCE_ID`, а остальные сервисы продолжают работать. + +## 6. Эксперименты и отказы + +Стенд. Docker Desktop 29.3.0 (WSL2), хост 14 CPU / 7.4 GiB RAM. Лимиты: каждая api — 0.5 CPU / 256 MiB, db — 1 CPU / 512 MiB, valkey — 0.25 CPU / 128 MiB, lb — 0.5 CPU / 128 MiB. Генератор нагрузки — в контейнере `tester` в той же Docker-сети. Данные: синтетические, каждый прогон создаёт своих пользователей и чат. + +Профиль нагрузки (`student-tests/failover_load.py`): закрытый цикл, 4 потока, 30 s, без прогрева; 50 % — POST сообщения, 50 % — GET истории (limit 20); таймаут клиента 3 s. Клиент ведёт себя как настоящий: если результат неизвестен, повторяет POST с тем же ключом и текстом. Через 8 s запускается action-скрипт против выбранной реплики; после прогона она возвращается (`start-api.sh`), и следующий прогон бьёт по другой. В конце вся история чата читается заново и проверяется: каждое подтверждённое сообщение на месте, одинаковых текстов нет. + +Гипотеза. При `docker stop` (SIGTERM) клиенты не увидят ошибок: реплика сначала уходит из пула, потом закрывается. При SIGKILL возможны единичные ошибки: запросы, которые были внутри убитого процесса, оборвутся; большую часть из них HAProxy повторит на другой реплике. После отказа пропускная способность упадёт, потому что API упирается в CPU-лимит реплики. + +RPS ниже — все успешные запросы (чтение + запись) в секунду. «Во время» — окно, пока выполняется action-скрипт (≈ 4 s для stop, < 1 s для kill). + +| Воздействие | Что ожидаем | Что наблюдали: успешные RPS до → во время → после; p95 до → после | Восстановление / потеря данных | +|--------------------------------|------------------------------|---------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------| +| `stop-one` реплика 1 (SIGTERM) | 0 ошибок | 130.6 → 79.1 → 93.5; p95 86 → 99 ms; ошибок 0 | реплика перестала получать запросы через 0.99 s; макс. пауза между записями 0.40 s; 1 525 записей, потерь и дублей 0; `Exited (0)` | +| `stop-one` реплика 2 (SIGTERM) | 0 ошибок | 149.2 → 108.0 → 87.9; p95 81 → 100 ms; ошибок 0 | 0.87 s; пауза 0.39 s; 1 606 записей, потерь 0; `Exited (0)` | +| `kill-one` реплика 1 (SIGKILL) | единичные ошибки | 106.1 → 44.3 → 89.4; p95 99 → 100 ms; ошибок 0 | 0.06 s; пауза 0.19 s; 1 398 записей, потерь 0; `Exited (137)` | +| `kill-one` реплика 2 (SIGKILL) | единичные ошибки | 118.8 → 23.8 → 74.2; p95 94 → 104 ms; **1 ошибка** (через 0.13 s после kill) | 0.11 s; пауза 0.29 s; 1 273 записи, потерь и дублей 0; `Exited (137)` | +| Rolling update api ×2 → v3 | 0 ошибок | 137.8 RPS в среднем за 70 s, ошибок 0; по секундам не ниже 52 успешных запросов | макс. пауза между записями 0.054 s; 4 826 записей, потерь и дублей 0 | +| Restart всего стенда | данные и токен сохраняются | `make test-persistence` PASS | на время перезапуска сервис недоступен (ожидаемо: останавливаются и LB, и БД); БД поднялась в 14:50:49, LB — в 14:51:02 (≈ 13 s) | + +Реплики: 1 = `fcae2c6047af`, 2 = `1ff54c0efa0c`. + +Выводы. + +1. Graceful stop работает: 0 ошибок в обоих прогонах. Реплика ещё ≈ 1 s обслуживает запросы во время drain, потом HAProxy убирает её из пула. +2. Гипотеза про SIGKILL подтвердилась: в одном прогоне 0 ошибок, в другом 1 ошибка из ~2 500 запросов. Почти все оборванные запросы HAProxy сам повторил на другой реплике (`retry-on conn-failure empty-response`). Единственную ошибку клиент повторил с тем же ключом — сообщение не потерялось и не задвоилось. Повторять в LB можно только потому, что GET безопасен, а POST сообщения защищён `Idempotency-Key`. Для остальных POST повтор в LB отключён. +3. С одной репликой пропускная способность падает на ~30–40 % (с ~106–149 до ~74–94 RPS). `docker stats` под нагрузкой: обе api ≈ 49 % CPU при лимите 0.5 CPU, то есть упираются в свой лимит; db ≈ 34 % от 1 CPU, lb ≈ 22 %. Узкое место — CPU API, а не БД. Падение меньше двукратного, потому что часть времени запроса уходит на сеть, БД и сам генератор нагрузки на том же хосте. +4. Rolling update прошёл без ошибок: новая реплика добавляется и проходит проверки до того, как останавливается старая, поэтому в пуле всегда минимум 2 рабочие реплики. + +Ограничения измерений. Закрытый цикл (coordinated omission: пока клиент ждёт медленный ответ, он не шлёт новые, поэтому задержки занижены). Каждый сценарий отказа — один прогон по 30 s без повторов. Генератор нагрузки на том же хосте и делит с ним CPU. RPS «во время» посчитан по окну < 5 s и шумный. `first_recovery_seconds` публичного теста считается от начала hook до первой записи после его окончания, а сам `docker stop` с drain длится ≈ 4 s — реальный перерыв в записи намного меньше (макс. пауза 0.39–0.40 s). + +## 7. Ограничения и следующие шаги + +- Выдерживается отказ одной API-реплики (процесса/контейнера). Не выдерживаются: отказ PostgreSQL (один экземпляр без реплики), отказ HAProxy (единственная точка входа) и потеря Docker-хоста — всё работает на одном хосте. Отказ Valkey выдерживается: API переходит на PostgreSQL (проверялось в lab2). +- Кэш сессий очищается (`FLUSHDB`) при старте каждого процесса API — решение из lab2 против потерянной инвалидации. С несколькими репликами каждый рестарт/rolling update сбрасывает общий кэш: на корректность не влияет, но ненадолго увеличивает нагрузку на PostgreSQL. +- Время сообщения — `now()` начала транзакции PostgreSQL (одни часы для всех реплик). Транзакции могут фиксироваться не в порядке `created_at`, поэтому читатель, листающий историю во время конкурентной записи, может не увидеть сообщение, вставленное «позади» курсора. При чтении уже неизменной истории пропусков и повторов нет. +- Старые ключи идемпотентности автоматически не удаляются: через 24 ч ключ переиспользуется, индекс по `created_at` подготовлен для будущей периодической очистки. +- `X-Instance-Id` раскрывает hostname контейнера (короткий Docker ID) — по нему `stop-one.sh` находит контейнер. В lab7 его стоит заменить случайным псевдонимом. +- `rolling-update.sh` использует `docker compose --scale`, поэтому номера контейнеров растут (api-5, api-6…). Автоматического отката нет: при ошибке скрипт останавливается, старые реплики продолжают работать. +- Контейнер `tester` монтирует `docker.sock` — это полный доступ к Docker-хосту; допустимо только на учебном стенде. +- Тесты lab2 (`level4.py`, `db_checks.py`) не перенесены: они рассчитаны на топологию lab2 (API напрямую на :8080, отдельный `api_short_ttl` на :8081). + +### Вопросы из README + +Чем отказ процесса отличается от отказа узла? +Процесс — одна программа (у нас один контейнер API). Если он упал, остальные реплики на том же хосте работают, а HAProxy переключается на них — это и проверено в лабораторной. Узел — целая машина (хост Docker). Если она пропала, пропадает всё, что на ней запущено: обе реплики, HAProxy, PostgreSQL. У нас все компоненты на одном хосте, поэтому отказ узла стенд **не** выдерживает — для этого нужны несколько машин и реплицированная БД (трек 2 на «5»). + +Почему `depends_on`/healthcheck сами по себе не являются балансировщиком? +`depends_on` влияет только на порядок запуска: «не запускай API, пока БД не healthy». Docker healthcheck только ставит метку `healthy/unhealthy` на контейнер и никуда не направляет трафик. Ни то, ни другое не принимает запросы клиента, не распределяет их между репликами, не убирает упавшую реплику из маршрута и не повторяет запрос. Это делает HAProxy: он принимает запрос, выбирает живую реплику, сам проверяет её `/health/ready` и при ошибке повторяет запрос на другой. + +Какие POST можно повторять после timeout и что защищает `Idempotency-Key`? +После timeout клиент не знает, выполнился запрос или нет. Повторять безопасно только тот запрос, повтор которого не создаст второй результат. У нас это `POST /chats/{id}/messages` **с** `Idempotency-Key`: сервер хранит ключ в той же транзакции, что и сообщение, и на повтор отдаёт уже созданное сообщение (на другое тело — `409`). Ключ защищает от **дублей** при повторе — в том числе когда повтор пришёл на другую реплику или одновременно с оригиналом. Остальные POST (`/users`, `/chats`, `/auth/sessions`) ключа не имеют, их повтор может создать второй объект, поэтому HAProxy их не повторяет, если запрос уже ушёл в приложение. (Ошибку *установления* соединения можно повторять всегда — запрос до приложения не дошёл.) + +Что сломается при увеличении числа API, если сессии хранятся в локальной памяти? +Пользователь вошёл через реплику 1 — токен есть только в её памяти. Следующий запрос round-robin отправит на реплику 2, а она такого токена не знает → `401`, пользователя «выкинет». Logout на одной реплике не отзовёт токен на другой. При падении/рестарте реплики все её сессии пропадут. Sticky session лишь маскирует это (и всё равно теряет сессии при отказе), поэтому у нас сессии в PostgreSQL + общий Valkey. \ No newline at end of file diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/cache.py b/app/cache.py new file mode 100644 index 00000000..d51862a7 --- /dev/null +++ b/app/cache.py @@ -0,0 +1,179 @@ +"""Valkey session cache. + +PostgreSQL is the source of truth for sessions. Valkey only keeps a short +lived copy of "token hash -> user" to avoid a SQL lookup on every request: + +- key: messenger:session:, the raw token is never stored; +- value TTL: min(SESSION_CACHE_TTL_SECONDS, remaining session lifetime), + and expires_at is checked again on every read; +- logout writes a "revoked" tombstone (SET ... EX, overwrite), while cache + population uses SET ... NX, so a concurrent request cannot resurrect a + revoked session in the cache; +- any Valkey error or timeout is a cache miss: requests go to PostgreSQL and + the cache is skipped for CACHE_RETRY_AFTER_SECONDS. After such an error, + and on every API process start, the cache is flushed before its next use, + because an invalidation may have been lost while Valkey was unreachable + (also by a previous API process). +""" +from __future__ import annotations + +import asyncio +import json +import logging +import math +import time +from datetime import datetime, timezone +from typing import Any +from uuid import UUID + +from redis.asyncio import ConnectionPool, Redis +from redis.exceptions import RedisError + +from app.config import settings + + +logger = logging.getLogger("messenger.cache") + +KEY_PREFIX = "messenger:session:" +REVOKED = "revoked" + + +class Revoked: + """Marker returned when the cache knows the session was revoked.""" + + +REVOKED_SESSION = Revoked() + + +def _key(token_hash: str) -> str: + return KEY_PREFIX + token_hash + + +def _serialize(user: dict[str, Any], expires_at: datetime) -> str: + return json.dumps( + { + "id": str(user["id"]), + "username": user["username"], + "display_name": user["display_name"], + "created_at": user["created_at"].isoformat(), + "expires_at": expires_at.isoformat(), + }, + separators=(",", ":"), + ) + + +def _deserialize(raw: str) -> tuple[dict[str, Any], datetime]: + payload = json.loads(raw) + user = { + "id": UUID(payload["id"]), + "username": payload["username"], + "display_name": payload["display_name"], + "created_at": datetime.fromisoformat(payload["created_at"]), + } + return user, datetime.fromisoformat(payload["expires_at"]) + + +class SessionCache: + def __init__(self, url: str | None) -> None: + self._client: Redis | None = None + self._unavailable_until = 0.0 + # A process never trusts a cache it has not flushed itself: an + # earlier process may have lost an invalidation (logout while + # Valkey was unreachable) and that knowledge died with it. + # Cleared only after a successful FLUSHDB. + self._needs_flush = True + + if url: + pool = ConnectionPool.from_url( + url, + max_connections=settings.cache_max_connections, + socket_timeout=settings.cache_timeout_seconds, + socket_connect_timeout=settings.cache_timeout_seconds, + decode_responses=True, + ) + self._client = Redis(connection_pool=pool) + + @property + def enabled(self) -> bool: + return self._client is not None + + async def _run(self, operation): + """Run one cache operation; return (ok, result).""" + if self._client is None: + return False, None + + if time.monotonic() < self._unavailable_until: + return False, None + + try: + async with asyncio.timeout(settings.cache_timeout_seconds * 2): + if self._needs_flush: + await self._client.flushdb() + self._needs_flush = False + logger.warning("session cache flushed before use") + return True, await operation(self._client) + except (RedisError, OSError, TimeoutError) as exc: + self._unavailable_until = ( + time.monotonic() + settings.cache_retry_after_seconds + ) + self._needs_flush = True + logger.warning( + "session cache unavailable, falling back to PostgreSQL: %s", + type(exc).__name__, + ) + return False, None + + async def get( + self, + token_hash: str, + ) -> dict[str, Any] | Revoked | None: + ok, raw = await self._run(lambda client: client.get(_key(token_hash))) + + if not ok or raw is None: + return None + + if raw == REVOKED: + return REVOKED_SESSION + + try: + user, expires_at = _deserialize(raw) + except (ValueError, KeyError, TypeError): + return None + + if expires_at <= datetime.now(timezone.utc): + return None + + return user + + async def put( + self, + token_hash: str, + user: dict[str, Any], + expires_at: datetime, + ) -> None: + remaining = (expires_at - datetime.now(timezone.utc)).total_seconds() + ttl = min(settings.session_cache_ttl_seconds, math.floor(remaining)) + + if ttl < 1: + return + + value = _serialize(user, expires_at) + await self._run( + lambda client: client.set(_key(token_hash), value, ex=ttl, nx=True) + ) + + async def revoke(self, token_hash: str) -> None: + await self._run( + lambda client: client.set( + _key(token_hash), + REVOKED, + ex=settings.session_cache_ttl_seconds, + ) + ) + + async def close(self) -> None: + if self._client is not None: + await self._client.aclose() + + +session_cache = SessionCache(settings.cache_url) diff --git a/app/config.py b/app/config.py new file mode 100644 index 00000000..dc24312f --- /dev/null +++ b/app/config.py @@ -0,0 +1,112 @@ +from dataclasses import dataclass +from pathlib import Path +import os +import socket + + +def read_value(name: str, default: str | None = None) -> str: + file_name = os.getenv(f"{name}_FILE") + + if file_name: + return Path(file_name).read_text(encoding="utf-8").strip() + + value = os.getenv(name, default) + + if value is None: + raise RuntimeError(f"{name} is required.") + + return value + + +def read_positive_int(name: str, default: str) -> int: + value = int(os.getenv(name, default)) + + if value < 1: + raise RuntimeError(f"{name} must be positive.") + + return value + + +def read_positive_float(name: str, default: str) -> float: + value = float(os.getenv(name, default)) + + if value <= 0: + raise RuntimeError(f"{name} must be positive.") + + return value + + +@dataclass(frozen=True) +class Settings: + app_host: str + app_port: int + database_url: str + session_ttl_seconds: int + # PostgreSQL connection pool and timeouts. + db_pool_size: int + db_max_overflow: int + db_pool_timeout_seconds: float + db_connect_timeout_seconds: float + db_statement_timeout_ms: int + # Valkey is a session cache; PostgreSQL stays the source of truth. + cache_url: str | None + session_cache_ttl_seconds: int + cache_timeout_seconds: float + cache_max_connections: int + cache_retry_after_seconds: float + # Lab3: X-Instance-Id is the container hostname (short Docker ID), stable + # for the process lifetime; scripts/stop-one.sh maps it to a container. + instance_id: str + idempotency_ttl_seconds: int + # Graceful shutdown: readiness answers 503 for shutdown_drain_seconds so + # the LB drops this replica, then uvicorn closes the listener and waits + # for in-flight requests up to shutdown_timeout_seconds. + shutdown_drain_seconds: float + shutdown_timeout_seconds: int + + +def load_settings() -> Settings: + session_store = os.getenv("SESSION_STORE", "postgres").lower() + + if session_store not in {"postgres", "valkey", "redis"}: + raise RuntimeError("SESSION_STORE must be postgres, valkey or redis.") + + cache_url = None + if session_store != "postgres": + cache_url = read_value("CACHE_URL") + + return Settings( + app_host=os.getenv("APP_HOST", "0.0.0.0"), + app_port=int(os.getenv("APP_PORT", "8080")), + database_url=read_value("DATABASE_URL"), + session_ttl_seconds=read_positive_int("SESSION_TTL_SECONDS", "3600"), + db_pool_size=read_positive_int("DB_POOL_SIZE", "10"), + db_max_overflow=int(os.getenv("DB_MAX_OVERFLOW", "5")), + db_pool_timeout_seconds=read_positive_float("DB_POOL_TIMEOUT_SECONDS", "3"), + db_connect_timeout_seconds=read_positive_float( + "DB_CONNECT_TIMEOUT_SECONDS", "3" + ), + db_statement_timeout_ms=read_positive_int("DB_STATEMENT_TIMEOUT_MS", "5000"), + cache_url=cache_url, + session_cache_ttl_seconds=read_positive_int( + "SESSION_CACHE_TTL_SECONDS", "60" + ), + cache_timeout_seconds=read_positive_float("CACHE_TIMEOUT_SECONDS", "0.25"), + cache_max_connections=read_positive_int("CACHE_MAX_CONNECTIONS", "20"), + cache_retry_after_seconds=read_positive_float( + "CACHE_RETRY_AFTER_SECONDS", "5" + ), + instance_id=os.getenv("INSTANCE_ID") or socket.gethostname(), + idempotency_ttl_seconds=read_positive_int( + "IDEMPOTENCY_TTL_SECONDS", "86400" + ), + shutdown_drain_seconds=read_positive_float( + "SHUTDOWN_DRAIN_SECONDS", "3" + ), + shutdown_timeout_seconds=read_positive_int( + "SHUTDOWN_TIMEOUT_SECONDS", "8" + ), + ) + + +settings = load_settings() diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..35674fa6 --- /dev/null +++ b/app/db.py @@ -0,0 +1,57 @@ +from collections.abc import AsyncGenerator + +from sqlalchemy.ext.asyncio import ( + AsyncSession, + async_sessionmaker, + create_async_engine, +) + +from app.config import settings + + +database_url = settings.database_url.replace( + "postgresql://", + "postgresql+asyncpg://", + 1, +) + +# Bounded pool: at most db_pool_size + db_max_overflow connections per API +# process. Waiting for a free connection, connecting and every statement are +# limited, so an unavailable database produces a fast 503 instead of a hang. +engine = create_async_engine( + database_url, + pool_pre_ping=True, + pool_size=settings.db_pool_size, + max_overflow=settings.db_max_overflow, + pool_timeout=settings.db_pool_timeout_seconds, + pool_recycle=1800, + connect_args={ + "timeout": settings.db_connect_timeout_seconds, + "command_timeout": settings.db_statement_timeout_ms / 1000 + 1, + "server_settings": { + "statement_timeout": str(settings.db_statement_timeout_ms), + "idle_in_transaction_session_timeout": "10000", + "application_name": "messenger-api", + }, + }, +) + +SessionLocal = async_sessionmaker( + bind=engine, + expire_on_commit=False, + autoflush=False, +) + + +async def get_db() -> AsyncGenerator[AsyncSession, None]: + async with SessionLocal() as session: + yield session + + +async def check_database_ready() -> bool: + try: + async with engine.connect() as connection: + await connection.exec_driver_sql("SELECT 1") + return True + except Exception: + return False diff --git a/app/deps.py b/app/deps.py new file mode 100644 index 00000000..2fe50ea1 --- /dev/null +++ b/app/deps.py @@ -0,0 +1,61 @@ +""" +FastAPI dependencies for Lab2: +- Bearer authentication; +- pagination query parameters. +""" + +from typing import Optional + +from fastapi import Depends, Query, Request, Security +from fastapi.security import HTTPAuthorizationCredentials, HTTPBasic, HTTPBearer +from sqlalchemy.ext.asyncio import AsyncSession + +from app.db import get_db +from app.errors import Unauthorized +from app.services import current_user_from_bearer_token + + +# Security schemes make the "Authorize" button in /docs send real +# Authorization headers. Errors keep the contract format: auto_error=False +# and our own 401 responses. +bearer_scheme = HTTPBearer( + scheme_name="Bearer", + auto_error=False, + description="Opaque session token from POST /api/v1/auth/sessions.", +) + + +class BasicForDocs(HTTPBasic): + """Documents Basic auth; the header is parsed by app.security.""" + + async def __call__(self, request: Request) -> None: # type: ignore[override] + return None + + +basic_scheme = BasicForDocs( + scheme_name="Basic", + auto_error=False, + description="Only for POST /api/v1/auth/sessions.", +) + + +async def require_user( + credentials: Optional[HTTPAuthorizationCredentials] = Security( + bearer_scheme + ), + db: AsyncSession = Depends(get_db), +) -> dict: + if credentials is None or not credentials.credentials.strip(): + raise Unauthorized("Bearer") + + return await current_user_from_bearer_token( + db, + credentials.credentials.strip(), + ) + + +def pagination_params( + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +) -> tuple[int, Optional[str]]: + return limit, cursor \ No newline at end of file diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..171182b7 --- /dev/null +++ b/app/errors.py @@ -0,0 +1,107 @@ +import re +from fastapi import Request +from fastapi.responses import JSONResponse +from uuid import uuid4 + +from app.config import settings +from app.lifecycle import draining + + +class ApiError(Exception): + def __init__( + self, + status_code: int, + code: str, + message: str, + headers: dict[str, str] | None = None, + ) -> None: + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers or {} + + +class InvalidRequest(ApiError): + def __init__(self, message: str = "Invalid request.") -> None: + super().__init__(400, "invalid_request", message) + + +class Unauthorized(ApiError): + def __init__(self, scheme: str = "Bearer") -> None: + if scheme == "Basic": + challenge = 'Basic realm="messenger", charset="UTF-8"' + else: + challenge = 'Bearer realm="messenger"' + + super().__init__( + 401, + "unauthorized", + "Authentication is required.", + {"WWW-Authenticate": challenge}, + ) + + +class NotFound(ApiError): + def __init__(self, message: str = "Object not found.") -> None: + super().__init__(404, "not_found", message) + + +class Conflict(ApiError): + def __init__(self, message: str = "Conflict.") -> None: + super().__init__(409, "conflict", message) + + +class Unavailable(ApiError): + def __init__(self) -> None: + super().__init__(503, "unavailable", "Service is unavailable.") + +# X-Request-Id from HAProxy (or the client) is reused only if it is short and +# printable; anything else is replaced, so it cannot inject into logs. +REQUEST_ID_PATTERN = re.compile(r"[A-Za-z0-9._:-]{1,128}") + + +def incoming_request_id(request: Request) -> str: + value = request.headers.get("X-Request-Id", "") + if REQUEST_ID_PATTERN.fullmatch(value): + return value + return str(uuid4()) + + +def request_id(request: Request) -> str: + return getattr(request.state, "request_id", str(uuid4())) + + +def common_headers(request: Request) -> dict[str, str]: + """Headers of every API response, including errors (lab3: X-Instance-Id).""" + headers = { + "X-Request-Id": request_id(request), + "X-Instance-Id": settings.instance_id, + } + if draining.is_set(): + # Ask HAProxy not to reuse the connection to a replica that is stopping. + headers["Connection"] = "close" + return headers + + +async def api_error_handler( + request: Request, + exc: ApiError, +) -> JSONResponse: + rid = request_id(request) + + headers = { + **common_headers(request), + **exc.headers, + } + + return JSONResponse( + status_code=exc.status_code, + content={ + "error": { + "code": exc.code, + "message": exc.message, + "request_id": rid, + } + }, + headers=headers, + ) \ No newline at end of file diff --git a/app/lifecycle.py b/app/lifecycle.py new file mode 100644 index 00000000..87d43274 --- /dev/null +++ b/app/lifecycle.py @@ -0,0 +1,6 @@ +"""Process lifecycle state shared by the server and request handlers.""" +import threading + +# Set on the first SIGTERM/SIGINT. While draining, /health/ready answers 503 +# and responses carry "Connection: close", but requests are still served. +draining = threading.Event() diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..bcc2d0be --- /dev/null +++ b/app/main.py @@ -0,0 +1,356 @@ +from __future__ import annotations + +import logging +from collections.abc import AsyncIterator +from contextlib import asynccontextmanager +from uuid import UUID + +from fastapi import Depends, FastAPI, Header, Request, Response, Security +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from sqlalchemy import exc as sa_exc +from starlette.exceptions import HTTPException as StarletteHTTPException +from sqlalchemy.ext.asyncio import AsyncSession + +from app.cache import session_cache +from app.db import check_database_ready, engine, get_db +from app.deps import basic_scheme, pagination_params, require_user +from app.errors import ( + ApiError, + Unavailable, + api_error_handler, + common_headers, + incoming_request_id, +) +from app.lifecycle import draining +from app.models import ( + Chat, + ChatPage, + CreateChat, + CreateMessage, + CreateUser, + Health, + Message, + MessagePage, + Session, + User, +) +from app.services import ( + create_chat, + create_message, + create_user_session, + get_chat, + list_chats, + list_messages, + logout_current_session, + register_user, +) + + +@asynccontextmanager +async def lifespan(_app: FastAPI) -> AsyncIterator[None]: + yield + await session_cache.close() + await engine.dispose() + + +app = FastAPI( + title="MTUSI Messenger — лабораторная 3", + version="1.3.0", + lifespan=lifespan, +) + +@app.middleware("http") +async def add_request_id(request: Request, call_next): + request.state.request_id = incoming_request_id(request) + + response = await call_next(request) + response.headers.update(common_headers(request)) + return response + +@app.exception_handler(ApiError) +async def handle_api_error( + request: Request, + exc: Exception, +) -> JSONResponse: + if not isinstance(exc, ApiError): + raise exc + + return await api_error_handler(request, exc) + + +@app.exception_handler(StarletteHTTPException) +async def http_error_handler( + request: Request, + exc: StarletteHTTPException, +) -> JSONResponse: + # Unknown routes/methods: the contract error format instead of + # FastAPI's default {"detail": ...}. + if exc.status_code == 404: + error = ApiError(404, "not_found", "Route not found.") + else: + error = ApiError(exc.status_code, "invalid_request", "Invalid request.") + + return await api_error_handler(request, error) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler( + request: Request, + _exc: RequestValidationError, +) -> JSONResponse: + return JSONResponse( + status_code=400, + content={ + "error": { + "code": "invalid_request", + "message": "Invalid request.", + "request_id": common_headers(request)["X-Request-Id"], + } + }, + headers=common_headers(request), + ) + + +logger = logging.getLogger("messenger.api") + + +def is_dependency_failure(exc: Exception) -> bool: + """PostgreSQL is unreachable, restarting, overloaded or timed out.""" + if isinstance( + exc, + ( + sa_exc.OperationalError, + sa_exc.InterfaceError, + sa_exc.TimeoutError, # connection pool exhausted + OSError, + TimeoutError, + ), + ): + return True + + return isinstance(exc, sa_exc.DBAPIError) and exc.connection_invalidated + + +async def dependency_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + if not is_dependency_failure(exc): + return await unexpected_error_handler(request, exc) + + logger.warning("database unavailable: %s", type(exc).__name__) + return await api_error_handler(request, Unavailable()) + + +for _exc_class in (sa_exc.DBAPIError, sa_exc.TimeoutError, OSError, TimeoutError): + app.add_exception_handler(_exc_class, dependency_error_handler) + + +@app.exception_handler(Exception) +async def unexpected_error_handler( + request: Request, + exc: Exception, +) -> JSONResponse: + headers = common_headers(request) + # Only the type: SQL parameters and headers may contain secrets. + logger.error("unexpected error: %s", type(exc).__name__) + + return JSONResponse( + status_code=500, + content={ + "error": { + "code": "internal_error", + "message": "Internal server error.", + "request_id": headers["X-Request-Id"], + } + }, + headers=headers, + ) + + +@app.get( + "/health/live", + response_model=Health, +) +async def liveness() -> dict[str, str]: + return {"status": "ok"} + + +@app.get( + "/health/ready", + response_model=Health, +) +async def readiness() -> dict[str, str]: + # A draining replica reports "not ready" so HAProxy stops sending new + # requests to it before the listener is closed. + if draining.is_set() or not await check_database_ready(): + raise Unavailable() + + return {"status": "ok"} + + +@app.post( + "/api/v1/users", + status_code=201, + response_model=User, +) +async def register_user_route( + payload: CreateUser, + db: AsyncSession = Depends(get_db), +): + return await register_user( + db, + username=payload.username, + display_name=payload.display_name, + password=payload.password, + ) + + +@app.post( + "/api/v1/auth/sessions", + status_code=201, + response_model=Session, +) +async def login( + request: Request, + db: AsyncSession = Depends(get_db), + _basic: None = Security(basic_scheme), +): + return await create_user_session( + db, + request.headers.get("Authorization"), + ) + + +@app.delete( + "/api/v1/auth/sessions/current", + status_code=204, +) +async def logout( + request: Request, + db: AsyncSession = Depends(get_db), + _current_user: dict = Depends(require_user), +) -> Response: + _, _, token = request.headers["Authorization"].partition(" ") + + await logout_current_session( + db, + token.strip(), + ) + + return Response(status_code=204) + + +@app.get( + "/api/v1/users/me", + response_model=User, +) +async def current_user_route( + current_user: dict = Depends(require_user), +): + return current_user + + +@app.post( + "/api/v1/chats", + status_code=201, + response_model=Chat, +) +async def create_chat_route( + payload: CreateChat, + current_user: dict = Depends(require_user), + db: AsyncSession = Depends(get_db), +): + return await create_chat( + db, + title=payload.title, + member_ids=payload.member_ids, + current_user=current_user, + ) + + +@app.get( + "/api/v1/chats", + response_model=ChatPage, +) +async def list_chats_route( + page: tuple[int, str | None] = Depends(pagination_params), + current_user: dict = Depends(require_user), + db: AsyncSession = Depends(get_db), +): + limit, cursor = page + + return await list_chats( + db, + limit=limit, + cursor=cursor, + current_user=current_user, + ) + + +@app.get( + "/api/v1/chats/{chat_id}", + response_model=Chat, +) +async def get_chat_route( + chat_id: UUID, + current_user: dict = Depends(require_user), + db: AsyncSession = Depends(get_db), +): + return await get_chat( + db, + chat_id=chat_id, + current_user=current_user, + ) + + +@app.post( + "/api/v1/chats/{chat_id}/messages", + status_code=201, + response_model=Message, +) +async def create_message_route( + chat_id: UUID, + payload: CreateMessage, + response: Response, + idempotency_key: str | None = Header( + default=None, + alias="Idempotency-Key", + ), + current_user: dict = Depends(require_user), + db: AsyncSession = Depends(get_db), +): + message, replayed = await create_message( + db, + chat_id=chat_id, + text_value=payload.text, + idempotency_key=idempotency_key, + current_user=current_user, + ) + + if replayed: + response.headers["Idempotent-Replayed"] = "true" + + return message + + +@app.get( + "/api/v1/chats/{chat_id}/messages", + response_model=MessagePage, +) +async def list_messages_route( + chat_id: UUID, + page: tuple[int, str | None] = Depends(pagination_params), + current_user: dict = Depends(require_user), + db: AsyncSession = Depends(get_db), +): + limit, cursor = page + + return await list_messages( + db, + chat_id=chat_id, + limit=limit, + cursor=cursor, + current_user=current_user, + ) \ No newline at end of file diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..4492b0d3 --- /dev/null +++ b/app/models.py @@ -0,0 +1,149 @@ +from __future__ import annotations + +from datetime import datetime, timezone +from typing import Literal +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +class ApiModel(BaseModel): + model_config = ConfigDict(extra="forbid") + + +class CreateUser(ApiModel): + username: str = Field( + min_length=3, + max_length=32, + pattern=r"^[a-z0-9_]{3,32}$", + ) + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def username_is_not_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("username must not contain only spaces.") + return value + + @field_validator("display_name") + @classmethod + def display_name_is_not_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError( + "display_name must not contain only spaces." + ) + return value + + @field_validator("password") + @classmethod + def password_is_not_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("password must not contain only spaces.") + return value + + +class User(ApiModel): + id: UUID + username: str + display_name: str + created_at: datetime + + @field_validator("created_at") + @classmethod + def user_time_is_utc(cls, value: datetime) -> datetime: + if value.tzinfo is None: + raise ValueError("created_at must include UTC timezone.") + return value.astimezone(timezone.utc) + + +class CreateChat(ApiModel): + # Contract: 1-100 code points (lab2 allowed 255 by mistake). + title: str = Field(min_length=1, max_length=100) + member_ids: list[UUID] = Field(min_length=1) + + @field_validator("title") + @classmethod + def title_is_not_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("title must not contain only spaces.") + return value + + +class Chat(ApiModel): + id: UUID + title: str + member_ids: list[UUID] + created_at: datetime + + @field_validator("created_at") + @classmethod + def chat_time_is_utc(cls, value: datetime) -> datetime: + if value.tzinfo is None: + raise ValueError("created_at must include UTC timezone.") + return value.astimezone(timezone.utc) + + +class ChatPage(ApiModel): + items: list[Chat] + next_cursor: str | None = None + + +class CreateMessage(ApiModel): + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def text_is_not_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("text must not contain only spaces.") + return value + + +class Message(ApiModel): + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + + @field_validator("created_at") + @classmethod + def message_time_is_utc(cls, value: datetime) -> datetime: + if value.tzinfo is None: + raise ValueError("created_at must include UTC timezone.") + return value.astimezone(timezone.utc) + + +class MessagePage(ApiModel): + items: list[Message] + next_cursor: str | None = None + + +class Session(ApiModel): + token: str = Field(min_length=1) + token_type: Literal["Bearer"] + expires_at: datetime + user: User + + @field_validator("expires_at") + @classmethod + def expiry_time_is_utc(cls, value: datetime) -> datetime: + if value.tzinfo is None: + raise ValueError("expires_at must include UTC timezone.") + return value.astimezone(timezone.utc) + + +class Health(ApiModel): + status: Literal["ok"] + + +class ErrorInner(ApiModel): + code: str = Field(min_length=1) + message: str = Field(min_length=1) + request_id: str = Field(min_length=1) + + +class Error(ApiModel): + error: ErrorInner \ No newline at end of file diff --git a/app/repositories.py b/app/repositories.py new file mode 100644 index 00000000..6a5a2d17 --- /dev/null +++ b/app/repositories.py @@ -0,0 +1,446 @@ +"""PostgreSQL repository functions for MTUSI Messenger Lab3.""" +from __future__ import annotations + +from collections.abc import Iterable +from datetime import datetime +from typing import Any +from uuid import UUID, uuid4 + +from sqlalchemy import text +from sqlalchemy.exc import IntegrityError +from sqlalchemy.ext.asyncio import AsyncSession + + +async def create_user( + db: AsyncSession, + *, + username: str, + display_name: str, + password_hash: str, +) -> dict[str, Any] | None: + user_id = uuid4() + try: + result = await db.execute( + text( + """ + INSERT INTO users (id, username, display_name, password_hash) + VALUES (:id, :username, :display_name, :password_hash) + RETURNING id, username, display_name, created_at + """ + ), + { + "id": user_id, + "username": username, + "display_name": display_name, + "password_hash": password_hash, + }, + ) + await db.commit() + return dict(result.mappings().one()) + except IntegrityError: + await db.rollback() + return None + + +async def get_user_by_username( + db: AsyncSession, + username: str, +) -> dict[str, Any] | None: + result = await db.execute( + text( + """ + SELECT id, username, display_name, password_hash, created_at + FROM users + WHERE username = :username + """ + ), + {"username": username}, + ) + row = result.mappings().first() + return dict(row) if row is not None else None + + +async def get_user_by_id( + db: AsyncSession, + user_id: UUID, +) -> dict[str, Any] | None: + result = await db.execute( + text( + """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = :user_id + """ + ), + {"user_id": user_id}, + ) + row = result.mappings().first() + return dict(row) if row is not None else None + + +async def user_ids_that_exist( + db: AsyncSession, + member_ids: Iterable[UUID], +) -> set[UUID]: + values = list(member_ids) + if not values: + return set() + + result = await db.execute( + text("SELECT id FROM users WHERE id = ANY(CAST(:member_ids AS uuid[]))"), + {"member_ids": values}, + ) + return {row.id for row in result} + + +async def create_session( + db: AsyncSession, + *, + user_id: UUID, + token_hash: str, + expires_at: datetime, +) -> None: + await db.execute( + text( + """ + INSERT INTO sessions (id, user_id, token_hash, expires_at) + VALUES (:id, :user_id, :token_hash, :expires_at) + """ + ), + { + "id": uuid4(), + "user_id": user_id, + "token_hash": token_hash, + "expires_at": expires_at, + }, + ) + await db.commit() + + +async def get_active_session_user( + db: AsyncSession, + token_hash: str, +) -> dict[str, Any] | None: + result = await db.execute( + text( + """ + SELECT + s.id AS session_id, + s.token_hash, + s.expires_at, + u.id, + u.username, + u.display_name, + u.created_at + FROM sessions AS s + JOIN users AS u ON u.id = s.user_id + WHERE s.token_hash = :token_hash + AND s.revoked_at IS NULL + AND s.expires_at > now() + """ + ), + {"token_hash": token_hash}, + ) + row = result.mappings().first() + return dict(row) if row is not None else None + + +async def revoke_active_session( + db: AsyncSession, + token_hash: str, +) -> bool: + result = await db.execute( + text( + """ + UPDATE sessions + SET revoked_at = now() + WHERE token_hash = :token_hash + AND revoked_at IS NULL + AND expires_at > now() + """ + ), + {"token_hash": token_hash}, + ) + await db.commit() + return result.rowcount == 1 + + +async def create_chat_with_members( + db: AsyncSession, + *, + title: str, + member_ids: Iterable[UUID], +) -> dict[str, Any]: + chat_id = uuid4() + members = list(member_ids) + + try: + result = await db.execute( + text( + """ + INSERT INTO chats (id, title) + VALUES (:id, :title) + RETURNING id, title, created_at + """ + ), + {"id": chat_id, "title": title}, + ) + chat = dict(result.mappings().one()) + + await db.execute( + text( + """ + INSERT INTO chat_members (chat_id, user_id) + VALUES (:chat_id, :user_id) + """ + ), + [{"chat_id": chat_id, "user_id": user_id} for user_id in members], + ) + await db.commit() + except Exception: + await db.rollback() + raise + + chat["member_ids"] = members + return chat + + +async def get_accessible_chat( + db: AsyncSession, + *, + chat_id: UUID, + user_id: UUID, +) -> dict[str, Any] | None: + result = await db.execute( + text( + """ + SELECT c.id, c.title, c.created_at + FROM chats AS c + JOIN chat_members AS own_membership + ON own_membership.chat_id = c.id + AND own_membership.user_id = :user_id + WHERE c.id = :chat_id + """ + ), + {"chat_id": chat_id, "user_id": user_id}, + ) + chat_row = result.mappings().first() + if chat_row is None: + return None + + members_result = await db.execute( + text( + """ + SELECT user_id + FROM chat_members + WHERE chat_id = :chat_id + ORDER BY user_id ASC + """ + ), + {"chat_id": chat_id}, + ) + chat = dict(chat_row) + chat["member_ids"] = [row.user_id for row in members_result] + return chat + + +async def list_chats_for_user( + db: AsyncSession, + *, + user_id: UUID, + limit: int, + cursor_created_at: datetime | None, + cursor_id: UUID | None, +) -> list[dict[str, Any]]: + query = """ + SELECT c.id, c.title, c.created_at + FROM chats AS c + JOIN chat_members AS own_membership + ON own_membership.chat_id = c.id + AND own_membership.user_id = :user_id \ + """ + params: dict[str, Any] = { + "user_id": user_id, + "limit_plus_one": limit + 1, + } + + if cursor_created_at is not None and cursor_id is not None: + query += """ + WHERE (c.created_at, c.id) > (:cursor_created_at, :cursor_id) + """ + params["cursor_created_at"] = cursor_created_at + params["cursor_id"] = cursor_id + + query += " ORDER BY c.created_at ASC, c.id ASC LIMIT :limit_plus_one" + + result = await db.execute(text(query), params) + chats = [dict(row) for row in result.mappings().all()] + if not chats: + return [] + + chat_ids = [chat["id"] for chat in chats] + members_result = await db.execute( + text( + """ + SELECT chat_id, user_id + FROM chat_members + WHERE chat_id = ANY(CAST(:chat_ids AS uuid[])) + ORDER BY chat_id ASC, user_id ASC + """ + ), + {"chat_ids": chat_ids}, + ) + + members_by_chat: dict[UUID, list[UUID]] = {chat_id: [] for chat_id in chat_ids} + for row in members_result: + members_by_chat[row.chat_id].append(row.user_id) + + for chat in chats: + chat["member_ids"] = members_by_chat[chat["id"]] + + return chats + + +async def create_message_idempotent( + db: AsyncSession, + *, + chat_id: UUID, + sender_id: UUID, + text_value: str, + idempotency_key: str, + request_hash: str, + ttl_seconds: int, +) -> tuple[dict[str, Any], bool] | None: + """Insert a message at most once per idempotency key; one transaction. + + 1. INSERT the key row. Its primary key (user, chat, method, key) lives in + the shared PostgreSQL, so a concurrent request with the same key on + ANY replica blocks on this INSERT until the first transaction ends. + 2. If the key was claimed: INSERT the message, link it to the key and + COMMIT both together. A failure before COMMIT rolls back both, so a + transient error is never stored as the final answer and a retry with + the same key simply runs again. + 3. If the key already exists (committed by someone else): return the + stored message, or None when the body differs (-> 409). + + A key older than ttl_seconds is reclaimed by the ON CONFLICT ... WHERE. + Returns (message, replayed) or None on a body mismatch. + """ + key_params = { + "user_id": sender_id, + "chat_id": chat_id, + "key": idempotency_key, + } + + try: + claimed = await db.execute( + text( + """ + INSERT INTO idempotency_keys AS k + (user_id, chat_id, method, key, request_hash) + VALUES (:user_id, :chat_id, 'POST', :key, :request_hash) + ON CONFLICT (user_id, chat_id, method, key) DO UPDATE + SET request_hash = EXCLUDED.request_hash, + message_id = NULL, + created_at = now() + WHERE k.created_at < now() - make_interval(secs => :ttl) + RETURNING 1 + """ + ), + {**key_params, "request_hash": request_hash, "ttl": ttl_seconds}, + ) + + if claimed.first() is not None: + result = await db.execute( + text( + """ + INSERT INTO messages (id, chat_id, sender_id, text) + VALUES (:id, :chat_id, :sender_id, :text) + RETURNING id, chat_id, sender_id, text, created_at + """ + ), + { + "id": uuid4(), + "chat_id": chat_id, + "sender_id": sender_id, + "text": text_value, + }, + ) + message = dict(result.mappings().one()) + + await db.execute( + text( + """ + UPDATE idempotency_keys + SET message_id = :message_id + WHERE user_id = :user_id + AND chat_id = :chat_id + AND method = 'POST' + AND key = :key + """ + ), + {**key_params, "message_id": message["id"]}, + ) + await db.commit() + return message, False + + stored = await db.execute( + text( + """ + SELECT k.request_hash, + m.id, m.chat_id, m.sender_id, m.text, m.created_at + FROM idempotency_keys AS k + JOIN messages AS m ON m.id = k.message_id + WHERE k.user_id = :user_id + AND k.chat_id = :chat_id + AND k.method = 'POST' + AND k.key = :key + """ + ), + key_params, + ) + row = stored.mappings().first() + await db.commit() + except Exception: + await db.rollback() + raise + + if row is None: + # Not reachable while the key row and the message commit together. + raise RuntimeError("idempotency key without a message") + + message = dict(row) + if message.pop("request_hash") != request_hash: + return None + + return message, True + + +async def list_messages_keyset( + db: AsyncSession, + *, + chat_id: UUID, + limit: int, + cursor_created_at: datetime | None, + cursor_id: UUID | None, +) -> list[dict[str, Any]]: + query = """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = :chat_id \ + """ + params: dict[str, Any] = { + "chat_id": chat_id, + "limit_plus_one": limit + 1, + } + + if cursor_created_at is not None and cursor_id is not None: + query += """ + AND (created_at, id) > (:cursor_created_at, :cursor_id) + """ + params["cursor_created_at"] = cursor_created_at + params["cursor_id"] = cursor_id + + query += " ORDER BY created_at ASC, id ASC LIMIT :limit_plus_one" + result = await db.execute(text(query), params) + return [dict(row) for row in result.mappings().all()] diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..c7c63954 --- /dev/null +++ b/app/security.py @@ -0,0 +1,162 @@ +from __future__ import annotations + +import base64 +import binascii +import hashlib +import json +import secrets +from datetime import datetime, timezone +from uuid import UUID + +from argon2 import PasswordHasher +from argon2.exceptions import InvalidHashError, VerifyMismatchError + + +password_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return password_hasher.hash(password) + + +def verify_password(password_hash: str, password: str) -> bool: + try: + return password_hasher.verify(password_hash, password) + except (VerifyMismatchError, InvalidHashError): + return False + + +def generate_session_token() -> str: + return secrets.token_urlsafe(32) + + +def hash_session_token(token: str) -> str: + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + +def parse_basic_authorization(value: str | None) -> tuple[str, str] | None: + if value is None or not value.startswith("Basic "): + return None + + try: + encoded_credentials = value[len("Basic "):] + decoded = base64.b64decode( + encoded_credentials, + validate=True, + ).decode("utf-8") + + username, password = decoded.split(":", 1) + except ( + ValueError, + UnicodeDecodeError, + binascii.Error, + ): + return None + + if not username or not username.isascii(): + return None + + return username, password + + +def _encode_cursor_payload(payload: dict[str, str]) -> str: + raw = json.dumps( + payload, + ensure_ascii=False, + separators=(",", ":"), + sort_keys=True, + ).encode("utf-8") + + return base64.urlsafe_b64encode(raw).decode("ascii") + + +def _decode_cursor_payload(cursor: str) -> dict[str, str] | None: + try: + raw = base64.urlsafe_b64decode(cursor.encode("ascii")) + payload = json.loads(raw.decode("utf-8")) + + if not isinstance(payload, dict): + return None + + return payload + except ( + ValueError, + TypeError, + UnicodeDecodeError, + binascii.Error, + ): + return None + + +def _utc_timestamp(value: datetime) -> str: + if value.tzinfo is None: + raise ValueError("Cursor datetime must be timezone-aware.") + + return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +def encode_chat_cursor( + created_at: datetime, + chat_id: UUID, +) -> str: + return _encode_cursor_payload( + { + "kind": "chat", + "created_at": _utc_timestamp(created_at), + "id": str(chat_id), + } + ) + + +def decode_chat_cursor( + cursor: str, +) -> tuple[datetime, UUID] | None: + payload = _decode_cursor_payload(cursor) + + if payload is None or payload.get("kind") != "chat": + return None + + try: + created_at = datetime.fromisoformat( + payload["created_at"].replace("Z", "+00:00") + ) + chat_id = UUID(payload["id"]) + except (KeyError, ValueError, AttributeError): + return None + + return created_at, chat_id + + +def encode_message_cursor( + chat_id: UUID, + created_at: datetime, + message_id: UUID, +) -> str: + return _encode_cursor_payload( + { + "kind": "message", + "chat_id": str(chat_id), + "created_at": _utc_timestamp(created_at), + "id": str(message_id), + } + ) + + +def decode_message_cursor( + cursor: str, +) -> tuple[UUID, datetime, UUID] | None: + payload = _decode_cursor_payload(cursor) + + if payload is None or payload.get("kind") != "message": + return None + + try: + chat_id = UUID(payload["chat_id"]) + created_at = datetime.fromisoformat( + payload["created_at"].replace("Z", "+00:00") + ) + message_id = UUID(payload["id"]) + except (KeyError, ValueError, AttributeError): + return None + + return chat_id, created_at, message_id \ No newline at end of file diff --git a/app/server.py b/app/server.py new file mode 100644 index 00000000..5a87d3f4 --- /dev/null +++ b/app/server.py @@ -0,0 +1,70 @@ +"""Entry point: uvicorn with a drain phase before the graceful shutdown. + +Plain uvicorn stops accepting connections immediately on SIGTERM. Behind +HAProxy that turns every stop into a burst of refused connections until the +active health check notices. Instead, on the first signal: + + t = 0 readiness -> 503, keep serving (Connection: close); + t = drain (3 s) HAProxy has marked the server DOWN (inter 1 s x fall 2), + uvicorn closes the listener and waits for in-flight + requests up to SHUTDOWN_TIMEOUT_SECONDS (8 s). + +stop_grace_period in compose.yaml (15 s) is larger than 3 + 8 s. +A second signal skips the drain phase. +""" +import logging +import threading + +import uvicorn + +from app.config import settings +from app.lifecycle import draining + + +logger = logging.getLogger("messenger.server") + + +class DrainingServer(uvicorn.Server): + def handle_exit(self, sig, frame) -> None: + if draining.is_set(): + super().handle_exit(sig, frame) + return + + draining.set() + logger.warning( + "signal %s: draining for %.1f s before shutdown", + sig, + settings.shutdown_drain_seconds, + ) + # Set should_exit directly instead of super().handle_exit(): uvicorn + # would re-raise the captured SIGTERM after shutdown and the process + # would exit with 143 instead of a clean 0. + timer = threading.Timer( + settings.shutdown_drain_seconds, + self._begin_shutdown, + ) + timer.daemon = True + timer.start() + + def _begin_shutdown(self) -> None: + logger.warning("drain finished: closing listener") + self.should_exit = True + + +def main() -> None: + config = uvicorn.Config( + "app.main:app", + host=settings.app_host, + port=settings.app_port, + proxy_headers=False, + # Longer than HAProxy "timeout http-keep-alive 10s": the LB closes an + # idle connection first, so it never reuses one the API just closed. + timeout_keep_alive=30, + timeout_graceful_shutdown=settings.shutdown_timeout_seconds, + log_level="info", + ) + DrainingServer(config).run() + + +if __name__ == "__main__": + main() diff --git a/app/services.py b/app/services.py new file mode 100644 index 00000000..fec902ac --- /dev/null +++ b/app/services.py @@ -0,0 +1,415 @@ +"""Business rules for MTUSI Messenger Lab3.""" +from __future__ import annotations + +import hashlib +import json +import re + +from datetime import datetime, timedelta, timezone +from typing import Any +from uuid import UUID + +from sqlalchemy.ext.asyncio import AsyncSession + +from app import repositories +from app.cache import REVOKED_SESSION, session_cache +from app.config import settings +from app.errors import ApiError +from app.security import ( + decode_chat_cursor, + decode_message_cursor, + encode_chat_cursor, + encode_message_cursor, + generate_session_token, + hash_password, + hash_session_token, + parse_basic_authorization, + verify_password, +) + + +def _utc_now() -> datetime: + return datetime.now(timezone.utc) + + +def _to_user(row: dict[str, Any]) -> dict[str, Any]: + return { + "id": row["id"], + "username": row["username"], + "display_name": row["display_name"], + "created_at": row["created_at"], + } + + +def _to_chat(row: dict[str, Any]) -> dict[str, Any]: + return { + "id": row["id"], + "title": row["title"], + "member_ids": row["member_ids"], + "created_at": row["created_at"], + } + + +def _to_message(row: dict[str, Any]) -> dict[str, Any]: + return { + "id": row["id"], + "chat_id": row["chat_id"], + "sender_id": row["sender_id"], + "text": row["text"], + "created_at": row["created_at"], + } + + +def _bearer_unauthorized() -> ApiError: + return ApiError( + 401, + "unauthorized", + "Authentication is required.", + headers={ + "WWW-Authenticate": 'Bearer realm="messenger"', + }, + ) + + +def _basic_unauthorized() -> ApiError: + return ApiError( + 401, + "unauthorized", + "Invalid credentials.", + headers={ + "WWW-Authenticate": ( + 'Basic realm="messenger", charset="UTF-8"' + ), + }, + ) + + +# Lab3 contract: ASCII [A-Za-z0-9._:-]{1,128}. +IDEMPOTENCY_KEY_PATTERN = re.compile(r"[A-Za-z0-9._:-]{1,128}") + + +def _invalid_request(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def _not_found() -> ApiError: + return ApiError(404, "not_found", "Object not found.") + + +async def register_user( + db: AsyncSession, + *, + username: str, + display_name: str, + password: str, +) -> dict[str, Any]: + user = await repositories.create_user( + db, + username=username, + display_name=display_name, + password_hash=hash_password(password), + ) + + if user is None: + raise ApiError( + 409, + "conflict", + "Username is already taken.", + ) + + return _to_user(user) + + +async def create_user_session( + db: AsyncSession, + authorization: str | None, +) -> dict[str, Any]: + credentials = parse_basic_authorization(authorization) + + if credentials is None: + raise _basic_unauthorized() + + username, password = credentials + user = await repositories.get_user_by_username(db, username) + + if user is None or not verify_password( + user["password_hash"], + password, + ): + raise _basic_unauthorized() + + token = generate_session_token() + expires_at = _utc_now() + timedelta( + seconds=settings.session_ttl_seconds + ) + + await repositories.create_session( + db, + user_id=user["id"], + token_hash=hash_session_token(token), + expires_at=expires_at, + ) + + return { + "token": token, + "token_type": "Bearer", + "expires_at": expires_at, + "user": _to_user(user), + } + + +async def current_user_from_bearer_token( + db: AsyncSession, + token: str, +) -> dict[str, Any]: + token_hash = hash_session_token(token) + cached = await session_cache.get(token_hash) + + if cached is REVOKED_SESSION: + raise _bearer_unauthorized() + + if cached is not None: + return cached + + # Cache miss or cache unavailable: PostgreSQL decides. + session_user = await repositories.get_active_session_user(db, token_hash) + + if session_user is None: + raise _bearer_unauthorized() + + user = _to_user(session_user) + await session_cache.put(token_hash, user, session_user["expires_at"]) + return user + + +async def logout_current_session( + db: AsyncSession, + token: str, +) -> None: + token_hash = hash_session_token(token) + revoked = await repositories.revoke_active_session(db, token_hash) + + if not revoked: + raise _bearer_unauthorized() + + # Invalidate after COMMIT in the source of truth. + await session_cache.revoke(token_hash) + + +async def create_chat( + db: AsyncSession, + *, + title: str, + member_ids: list[UUID], + current_user: dict[str, Any], +) -> dict[str, Any]: + unique_member_ids = set(member_ids) + + if len(unique_member_ids) != len(member_ids): + raise _invalid_request( + "member_ids must not contain duplicates." + ) + + if current_user["id"] not in unique_member_ids: + raise _invalid_request( + "The current user must be included in member_ids." + ) + + existing_ids = await repositories.user_ids_that_exist( + db, + unique_member_ids, + ) + + if existing_ids != unique_member_ids: + raise _invalid_request( + "One or more member_ids do not exist." + ) + + chat = await repositories.create_chat_with_members( + db, + title=title, + member_ids=member_ids, + ) + + return _to_chat(chat) + + +async def get_chat( + db: AsyncSession, + *, + chat_id: UUID, + current_user: dict[str, Any], +) -> dict[str, Any]: + chat = await repositories.get_accessible_chat( + db, + chat_id=chat_id, + user_id=current_user["id"], + ) + + if chat is None: + raise _not_found() + + return _to_chat(chat) + + +async def list_chats( + db: AsyncSession, + *, + limit: int, + cursor: str | None, + current_user: dict[str, Any], +) -> dict[str, Any]: + cursor_created_at: datetime | None = None + cursor_id: UUID | None = None + + if cursor is not None: + decoded = decode_chat_cursor(cursor) + + if decoded is None: + raise _invalid_request("Invalid cursor.") + + cursor_created_at, cursor_id = decoded + + rows = await repositories.list_chats_for_user( + db, + user_id=current_user["id"], + limit=limit, + cursor_created_at=cursor_created_at, + cursor_id=cursor_id, + ) + + has_more = len(rows) > limit + page = rows[:limit] + + next_cursor = None + if has_more and page: + last = page[-1] + next_cursor = encode_chat_cursor( + last["created_at"], + last["id"], + ) + + return { + "items": [_to_chat(row) for row in page], + "next_cursor": next_cursor, + } + + +def _request_fingerprint(text_value: str) -> str: + """Hash of the validated body: key order and whitespace do not matter.""" + canonical = json.dumps( + {"text": text_value}, + ensure_ascii=False, + separators=(",", ":"), + sort_keys=True, + ) + return hashlib.sha256(canonical.encode("utf-8")).hexdigest() + + +async def create_message( + db: AsyncSession, + *, + chat_id: UUID, + text_value: str, + idempotency_key: str | None, + current_user: dict[str, Any], +) -> tuple[dict[str, Any], bool]: + """Send a message once per (user, POST, chat, Idempotency-Key). + + Returns (message, replayed). A replay re-checks the session (done by + require_user) and chat membership before returning the stored result. + """ + if idempotency_key is None or not IDEMPOTENCY_KEY_PATTERN.fullmatch( + idempotency_key + ): + raise _invalid_request( + "Idempotency-Key header is required: [A-Za-z0-9._:-]{1,128}." + ) + + chat = await repositories.get_accessible_chat( + db, + chat_id=chat_id, + user_id=current_user["id"], + ) + + if chat is None: + raise _not_found() + + result = await repositories.create_message_idempotent( + db, + chat_id=chat_id, + sender_id=current_user["id"], + text_value=text_value, + idempotency_key=idempotency_key, + request_hash=_request_fingerprint(text_value), + ttl_seconds=settings.idempotency_ttl_seconds, + ) + + if result is None: + raise ApiError( + 409, + "conflict", + "Idempotency-Key was already used with a different body.", + ) + + message, replayed = result + return _to_message(message), replayed + + +async def list_messages( + db: AsyncSession, + *, + chat_id: UUID, + limit: int, + cursor: str | None, + current_user: dict[str, Any], +) -> dict[str, Any]: + chat = await repositories.get_accessible_chat( + db, + chat_id=chat_id, + user_id=current_user["id"], + ) + + if chat is None: + raise _not_found() + + cursor_created_at: datetime | None = None + cursor_id: UUID | None = None + + if cursor is not None: + decoded = decode_message_cursor(cursor) + + if decoded is None: + raise _invalid_request("Invalid cursor.") + + cursor_chat_id, cursor_created_at, cursor_id = decoded + + if cursor_chat_id != chat_id: + raise _invalid_request( + "Cursor belongs to another chat." + ) + + rows = await repositories.list_messages_keyset( + db, + chat_id=chat_id, + limit=limit, + cursor_created_at=cursor_created_at, + cursor_id=cursor_id, + ) + + has_more = len(rows) > limit + page = rows[:limit] + + next_cursor = None + if has_more and page: + last = page[-1] + next_cursor = encode_message_cursor( + chat_id, + last["created_at"], + last["id"], + ) + + return { + "items": [_to_message(row) for row in page], + "next_cursor": next_cursor, + } \ No newline at end of file diff --git a/compose.example.yaml b/compose.example.yaml deleted file mode 100644 index dd4d3878..00000000 --- a/compose.example.yaml +++ /dev/null @@ -1,11 +0,0 @@ -# Topology worksheet, deliberately NOT a runnable stack (no application supplied). -# Implement compose.yaml or stack.yaml; do not submit this empty file as deployment. -# Service names below are logical roles, not imposed container names. -x-lab-number: 3 -x-required-roles: - - api - - postgres - - load_balancer -# TODO: implement real images/builds, network wiring, volumes, healthchecks, -# credentials and bootstrap. Details: contracts/infrastructure.json and README.md. -services: {} diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..6c722210 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,182 @@ +# Lab3: client -> HAProxy -> API x N -> PostgreSQL (source of truth: data, +# sessions, idempotency keys) + Valkey (shared session cache from lab2). +# Start: see REPORT.md, "Запуск из чистого clone". +name: messenger-lab3 + +x-api-env: &api-env + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + DATABASE_URL_FILE: /run/secrets/database_url + SESSION_TTL_SECONDS: "${SESSION_TTL_SECONDS:-3600}" + SESSION_STORE: valkey + CACHE_URL_FILE: /run/secrets/cache_url + SESSION_CACHE_TTL_SECONDS: "60" + CACHE_TIMEOUT_SECONDS: "0.25" + CACHE_MAX_CONNECTIONS: "20" + CACHE_RETRY_AFTER_SECONDS: "5" + DB_POOL_SIZE: "10" + DB_MAX_OVERFLOW: "5" + DB_POOL_TIMEOUT_SECONDS: "3" + DB_CONNECT_TIMEOUT_SECONDS: "3" + DB_STATEMENT_TIMEOUT_MS: "5000" + IDEMPOTENCY_TTL_SECONDS: "${IDEMPOTENCY_TTL_SECONDS:-86400}" + SHUTDOWN_DRAIN_SECONDS: "3" + SHUTDOWN_TIMEOUT_SECONDS: "8" + +services: + db: + image: postgres:16.4-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: [postgres_password] + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 2s + timeout: 3s + retries: 20 + start_period: 5s + networks: [backend] + stop_grace_period: 30s + restart: unless-stopped + deploy: + resources: + limits: { cpus: "1.0", memory: 512M } + + # Session cache only (lab2). PostgreSQL stays the source of truth, so the + # cache is intentionally not persisted. It is shared by all API replicas: + # a logout on one replica writes the "revoked" tombstone seen by all. + valkey: + image: valkey/valkey:8.0.1-alpine + command: + - sh + - -c + - >- + exec valkey-server + --requirepass "$$(cat /run/secrets/valkey_password)" + --save "" + --appendonly no + --maxmemory 64mb + --maxmemory-policy allkeys-lru + secrets: [valkey_password] + healthcheck: + test: + - CMD-SHELL + - valkey-cli -a "$$(cat /run/secrets/valkey_password)" --no-auth-warning ping | grep -q PONG + interval: 2s + timeout: 3s + retries: 20 + networks: [backend] + restart: unless-stopped + deploy: + resources: + limits: { cpus: "0.25", memory: 128M } + + # Runs the migrations once, before any API replica starts (no race of + # replicas). A repeated run only prints SKIP. + migrate: + build: . + image: messenger-lab3-api:${APP_VERSION:-dev} + command: ["python", "scripts/migrate.py"] + environment: + DATABASE_URL_FILE: /run/secrets/database_url + secrets: [database_url] + depends_on: + db: { condition: service_healthy } + networks: [backend] + restart: "no" + deploy: + resources: + limits: { cpus: "0.5", memory: 128M } + + api: + build: . + image: messenger-lab3-api:${APP_VERSION:-dev} + environment: *api-env + secrets: [database_url, cache_url] + # No "ports": replicas are reachable only through the LB. + # No "container_name": the service is scaled by deploy.replicas / --scale. + networks: [edge, backend] + depends_on: + db: { condition: service_healthy } + valkey: { condition: service_healthy } + migrate: { condition: service_completed_successfully } + healthcheck: + test: + - 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)" + interval: 2s + timeout: 3s + retries: 2 + start_period: 5s + stop_signal: SIGTERM + # > SHUTDOWN_DRAIN_SECONDS + SHUTDOWN_TIMEOUT_SECONDS (3 + 8 s). + stop_grace_period: 15s + restart: unless-stopped + deploy: + replicas: ${API_REPLICAS:-2} + resources: + limits: { cpus: "0.5", memory: 256M } + + lb: + image: haproxy:3.0.11-alpine + volumes: + - ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + ports: + - "${LB_PORT:-8080}:8080" + # Backend state page for the operator, only on the host loopback. + - "127.0.0.1:${LB_STATS_PORT:-8404}:8404" + networks: [edge] + depends_on: + api: { condition: service_healthy } + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/lb-health"] + interval: 5s + timeout: 2s + retries: 3 + restart: unless-stopped + deploy: + resources: + limits: { cpus: "0.5", memory: 128M } + + # Runs the public and own checks in Linux (needed on Windows: the hooks are + # POSIX .sh scripts that call the docker CLI). Profile "tools": not started + # by a plain "up". The Docker socket grants control over the Docker host — + # use it only on the lab stand. + tester: + profiles: [tools] + build: + context: . + dockerfile: student-tests/Dockerfile.tester + working_dir: /work + environment: + BASE_URL: http://lb:8080 + COMPOSE_PROJECT: messenger-lab3 + volumes: + - ./:/work + - /var/run/docker.sock:/var/run/docker.sock + networks: [edge] + +networks: + edge: {} + # PostgreSQL and Valkey: no route outside, the LB is not attached. + backend: + internal: true + +volumes: + postgres_data: {} + +secrets: + postgres_password: + file: ./infra/secrets/postgres_password.txt + database_url: + file: ./infra/secrets/database_url.txt + valkey_password: + file: ./infra/secrets/valkey_password.txt + cache_url: + file: ./infra/secrets/cache_url.txt diff --git a/evidence/environment.txt b/evidence/environment.txt new file mode 100644 index 00000000..3b4ce704 --- /dev/null +++ b/evidence/environment.txt @@ -0,0 +1 @@ +host: 14 CPU, 7965708288 bytes RAM, Docker Desktop, docker 29.3.0 diff --git a/evidence/failover-kill-1.json b/evidence/failover-kill-1.json new file mode 100644 index 00000000..f3db7dad --- /dev/null +++ b/evidence/failover-kill-1.json @@ -0,0 +1,211 @@ +{ + "label": "kill-1", + "action_script": "scripts/kill-one.sh", + "target_instance": "fcae2c6047af", + "replicas_observed_before": 2, + "concurrency": 4, + "workload": "closed loop, 50% POST message (retry same key on failure) / 50% GET history, timeout 3 s", + "started_at_utc": "14:52:42", + "duration_seconds": 30.02, + "action_window_seconds": [ + 8.0, + 8.54 + ], + "action_stdout": [ + "killed api container fcae2c6047af at 14:52:50" + ], + "before": { + "seconds": 8.0, + "successful_rps": 106.1, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 15.25, + "p95_ms": 99.41, + "p99_ms": 181.16 + }, + "during_action": { + "seconds": 0.54, + "successful_rps": 44.3, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 89.69, + "p95_ms": 102.09, + "p99_ms": 183.92 + }, + "after_action": { + "seconds": 21.48, + "successful_rps": 89.4, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 19.64, + "p95_ms": 100.06, + "p99_ms": 169.12 + }, + "total_errors": 0, + "last_error_after_action_start_s": 0.0, + "max_gap_between_successful_writes_s": 0.194, + "target_last_served_after_action_start_s": 0.06, + "instances_after_action": { + "1ff54c0efa0c": 1921 + }, + "confirmed_writes": 1398, + "lost_confirmed": 0, + "duplicates": 0, + "per_second": [ + { + "t": 0, + "ok": 96, + "err": 0 + }, + { + "t": 1, + "ok": 97, + "err": 0 + }, + { + "t": 2, + "ok": 173, + "err": 0 + }, + { + "t": 3, + "ok": 80, + "err": 0 + }, + { + "t": 4, + "ok": 89, + "err": 0 + }, + { + "t": 5, + "ok": 145, + "err": 0 + }, + { + "t": 6, + "ok": 82, + "err": 0 + }, + { + "t": 7, + "ok": 87, + "err": 0 + }, + { + "t": 8, + "ok": 42, + "err": 0 + }, + { + "t": 9, + "ok": 82, + "err": 0 + }, + { + "t": 10, + "ok": 73, + "err": 0 + }, + { + "t": 11, + "ok": 44, + "err": 0 + }, + { + "t": 12, + "ok": 97, + "err": 0 + }, + { + "t": 13, + "ok": 117, + "err": 0 + }, + { + "t": 14, + "ok": 56, + "err": 0 + }, + { + "t": 15, + "ok": 98, + "err": 0 + }, + { + "t": 16, + "ok": 119, + "err": 0 + }, + { + "t": 17, + "ok": 75, + "err": 0 + }, + { + "t": 18, + "ok": 92, + "err": 0 + }, + { + "t": 19, + "ok": 129, + "err": 0 + }, + { + "t": 20, + "ok": 65, + "err": 0 + }, + { + "t": 21, + "ok": 60, + "err": 0 + }, + { + "t": 22, + "ok": 121, + "err": 0 + }, + { + "t": 23, + "ok": 99, + "err": 0 + }, + { + "t": 24, + "ok": 55, + "err": 0 + }, + { + "t": 25, + "ok": 121, + "err": 0 + }, + { + "t": 26, + "ok": 112, + "err": 0 + }, + { + "t": 27, + "ok": 52, + "err": 0 + }, + { + "t": 28, + "ok": 107, + "err": 0 + }, + { + "t": 29, + "ok": 125, + "err": 0 + }, + { + "t": 30, + "ok": 4, + "err": 0 + } + ] +} diff --git a/evidence/failover-kill-2.json b/evidence/failover-kill-2.json new file mode 100644 index 00000000..46fc2cdd --- /dev/null +++ b/evidence/failover-kill-2.json @@ -0,0 +1,211 @@ +{ + "label": "kill-2", + "action_script": "scripts/kill-one.sh", + "target_instance": "1ff54c0efa0c", + "replicas_observed_before": 2, + "concurrency": 4, + "workload": "closed loop, 50% POST message (retry same key on failure) / 50% GET history, timeout 3 s", + "started_at_utc": "14:53:22", + "duration_seconds": 30.06, + "action_window_seconds": [ + 8.0, + 8.88 + ], + "action_stdout": [ + "killed api container 1ff54c0efa0c at 14:53:31" + ], + "before": { + "seconds": 8.0, + "successful_rps": 118.8, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 16.36, + "p95_ms": 94.03, + "p99_ms": 162.45 + }, + "during_action": { + "seconds": 0.88, + "successful_rps": 23.8, + "errors": 1, + "error_ratio": 0.0455, + "p50_ms": 135.56, + "p95_ms": 192.0, + "p99_ms": 198.94 + }, + "after_action": { + "seconds": 21.18, + "successful_rps": 74.2, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 63.46, + "p95_ms": 104.13, + "p99_ms": 193.24 + }, + "total_errors": 1, + "last_error_after_action_start_s": 0.13, + "max_gap_between_successful_writes_s": 0.289, + "target_last_served_after_action_start_s": 0.11, + "instances_after_action": { + "fcae2c6047af": 1571 + }, + "confirmed_writes": 1273, + "lost_confirmed": 0, + "duplicates": 0, + "per_second": [ + { + "t": 0, + "ok": 122, + "err": 0 + }, + { + "t": 1, + "ok": 64, + "err": 0 + }, + { + "t": 2, + "ok": 165, + "err": 0 + }, + { + "t": 3, + "ok": 153, + "err": 0 + }, + { + "t": 4, + "ok": 80, + "err": 0 + }, + { + "t": 5, + "ok": 141, + "err": 0 + }, + { + "t": 6, + "ok": 163, + "err": 0 + }, + { + "t": 7, + "ok": 63, + "err": 0 + }, + { + "t": 8, + "ok": 24, + "err": 1 + }, + { + "t": 9, + "ok": 67, + "err": 0 + }, + { + "t": 10, + "ok": 69, + "err": 0 + }, + { + "t": 11, + "ok": 33, + "err": 0 + }, + { + "t": 12, + "ok": 22, + "err": 0 + }, + { + "t": 13, + "ok": 57, + "err": 0 + }, + { + "t": 14, + "ok": 62, + "err": 0 + }, + { + "t": 15, + "ok": 34, + "err": 0 + }, + { + "t": 16, + "ok": 73, + "err": 0 + }, + { + "t": 17, + "ok": 113, + "err": 0 + }, + { + "t": 18, + "ok": 85, + "err": 0 + }, + { + "t": 19, + "ok": 66, + "err": 0 + }, + { + "t": 20, + "ok": 112, + "err": 0 + }, + { + "t": 21, + "ok": 87, + "err": 0 + }, + { + "t": 22, + "ok": 50, + "err": 0 + }, + { + "t": 23, + "ok": 120, + "err": 0 + }, + { + "t": 24, + "ok": 110, + "err": 0 + }, + { + "t": 25, + "ok": 47, + "err": 0 + }, + { + "t": 26, + "ok": 102, + "err": 0 + }, + { + "t": 27, + "ok": 113, + "err": 0 + }, + { + "t": 28, + "ok": 58, + "err": 0 + }, + { + "t": 29, + "ok": 84, + "err": 0 + }, + { + "t": 30, + "ok": 4, + "err": 0 + } + ] +} diff --git a/evidence/failover-series.txt b/evidence/failover-series.txt new file mode 100644 index 00000000..4f421184 --- /dev/null +++ b/evidence/failover-series.txt @@ -0,0 +1,59 @@ +started api container fcae2c6047af +started api container 1ff54c0efa0c +running api replicas: 2 +=== stop replica 1: fcae2c6047af === +messenger-lab3-api-3 1ff54c0efa0c Up 21 seconds (healthy) +messenger-lab3-api-4 fcae2c6047af Up 21 seconds (healthy) +messenger-lab3-db-1 9d8a07ddc444 Up 27 seconds (healthy) +messenger-lab3-lb-1 087c5c4c9b74 Up 15 seconds (healthy) +messenger-lab3-tester-run-213ac4df887e 9f01cbcb4c8d Up 1 second +messenger-lab3-valkey-1 0f4951a33b71 Up 27 seconds (healthy) +{"label": "stop-1", "target_instance": "fcae2c6047af", "before": {"seconds": 8.0, "successful_rps": 130.6, "errors": 0, "error_ratio": 0.0, "p50_ms": 16.95, "p95_ms": 86.35, "p99_ms": 202.12}, "during_action": {"seconds": 4.13, "successful_rps": 79.1, "errors": 0, "error_ratio": 0.0, "p50_ms": 33.06, "p95_ms": 100.93, "p99_ms": 304.83}, "after_action": {"seconds": 17.92, "successful_rps": 93.5, "errors": 0, "error_ratio": 0.0, "p50_ms": 19.79, "p95_ms": 98.76, "p99_ms": 108.11}, "total_errors": 0, "last_error_after_action_start_s": 0.0, "max_gap_between_successful_writes_s": 0.401, "target_last_served_after_action_start_s": 0.99, "instances_after_action": {"1ff54c0efa0c": 1676}, "confirmed_writes": 1525} +PASS: no confirmed message lost, no duplicates +--- containers after action: +messenger-lab3-api-3 1ff54c0efa0c Up 56 seconds (healthy) +messenger-lab3-api-4 fcae2c6047af Exited (0) 19 seconds ago +started api container fcae2c6047af +running api replicas: 2 +=== stop replica 2: 1ff54c0efa0c === +messenger-lab3-api-3 1ff54c0efa0c Up About a minute (healthy) +messenger-lab3-api-4 fcae2c6047af Up 7 seconds (healthy) +messenger-lab3-db-1 9d8a07ddc444 Up About a minute (healthy) +messenger-lab3-lb-1 087c5c4c9b74 Up 57 seconds (healthy) +messenger-lab3-tester-run-213ac4df887e 9f01cbcb4c8d Up 43 seconds +messenger-lab3-valkey-1 0f4951a33b71 Up About a minute (healthy) +{"label": "stop-2", "target_instance": "1ff54c0efa0c", "before": {"seconds": 8.0, "successful_rps": 149.2, "errors": 0, "error_ratio": 0.0, "p50_ms": 14.55, "p95_ms": 80.93, "p99_ms": 92.48}, "during_action": {"seconds": 4.04, "successful_rps": 108.0, "errors": 0, "error_ratio": 0.0, "p50_ms": 17.34, "p95_ms": 96.15, "p99_ms": 105.53}, "after_action": {"seconds": 17.98, "successful_rps": 87.9, "errors": 0, "error_ratio": 0.0, "p50_ms": 21.55, "p95_ms": 100.26, "p99_ms": 112.06}, "total_errors": 0, "last_error_after_action_start_s": 0.0, "max_gap_between_successful_writes_s": 0.389, "target_last_served_after_action_start_s": 0.87, "instances_after_action": {"fcae2c6047af": 1581}, "confirmed_writes": 1606} +PASS: no confirmed message lost, no duplicates +--- containers after action: +messenger-lab3-api-3 1ff54c0efa0c Exited (0) 18 seconds ago +messenger-lab3-api-4 fcae2c6047af Up 40 seconds (healthy) +started api container 1ff54c0efa0c +running api replicas: 2 +=== kill replica 1: fcae2c6047af === +messenger-lab3-api-3 1ff54c0efa0c Up 6 seconds (healthy) +messenger-lab3-api-4 fcae2c6047af Up 46 seconds (healthy) +messenger-lab3-db-1 9d8a07ddc444 Up About a minute (healthy) +messenger-lab3-lb-1 087c5c4c9b74 Up About a minute (healthy) +messenger-lab3-tester-run-213ac4df887e 9f01cbcb4c8d Up About a minute +messenger-lab3-valkey-1 0f4951a33b71 Up About a minute (healthy) +{"label": "kill-1", "target_instance": "fcae2c6047af", "before": {"seconds": 8.0, "successful_rps": 106.1, "errors": 0, "error_ratio": 0.0, "p50_ms": 15.25, "p95_ms": 99.41, "p99_ms": 181.16}, "during_action": {"seconds": 0.54, "successful_rps": 44.3, "errors": 0, "error_ratio": 0.0, "p50_ms": 89.69, "p95_ms": 102.09, "p99_ms": 183.92}, "after_action": {"seconds": 21.48, "successful_rps": 89.4, "errors": 0, "error_ratio": 0.0, "p50_ms": 19.64, "p95_ms": 100.06, "p99_ms": 169.12}, "total_errors": 0, "last_error_after_action_start_s": 0.0, "max_gap_between_successful_writes_s": 0.194, "target_last_served_after_action_start_s": 0.06, "instances_after_action": {"1ff54c0efa0c": 1921}, "confirmed_writes": 1398} +PASS: no confirmed message lost, no duplicates +--- containers after action: +messenger-lab3-api-3 1ff54c0efa0c Up 40 seconds (healthy) +messenger-lab3-api-4 fcae2c6047af Exited (137) 22 seconds ago +started api container fcae2c6047af +running api replicas: 2 +=== kill replica 2: 1ff54c0efa0c === +messenger-lab3-api-3 1ff54c0efa0c Up 46 seconds (healthy) +messenger-lab3-api-4 fcae2c6047af Up 6 seconds (healthy) +messenger-lab3-db-1 9d8a07ddc444 Up 2 minutes (healthy) +messenger-lab3-lb-1 087c5c4c9b74 Up 2 minutes (healthy) +messenger-lab3-tester-run-213ac4df887e 9f01cbcb4c8d Up 2 minutes +messenger-lab3-valkey-1 0f4951a33b71 Up 2 minutes (healthy) +{"label": "kill-2", "target_instance": "1ff54c0efa0c", "before": {"seconds": 8.0, "successful_rps": 118.8, "errors": 0, "error_ratio": 0.0, "p50_ms": 16.36, "p95_ms": 94.03, "p99_ms": 162.45}, "during_action": {"seconds": 0.88, "successful_rps": 23.8, "errors": 1, "error_ratio": 0.0455, "p50_ms": 135.56, "p95_ms": 192.0, "p99_ms": 198.94}, "after_action": {"seconds": 21.18, "successful_rps": 74.2, "errors": 0, "error_ratio": 0.0, "p50_ms": 63.46, "p95_ms": 104.13, "p99_ms": 193.24}, "total_errors": 1, "last_error_after_action_start_s": 0.13, "max_gap_between_successful_writes_s": 0.289, "target_last_served_after_action_start_s": 0.11, "instances_after_action": {"fcae2c6047af": 1571}, "confirmed_writes": 1273} +PASS: no confirmed message lost, no duplicates +--- containers after action: +messenger-lab3-api-3 1ff54c0efa0c Exited (137) 22 seconds ago +messenger-lab3-api-4 fcae2c6047af Up 39 seconds (healthy) +started api container 1ff54c0efa0c +running api replicas: 2 diff --git a/evidence/failover-stop-1.json b/evidence/failover-stop-1.json new file mode 100644 index 00000000..500f1c15 --- /dev/null +++ b/evidence/failover-stop-1.json @@ -0,0 +1,211 @@ +{ + "label": "stop-1", + "action_script": "scripts/stop-one.sh", + "target_instance": "fcae2c6047af", + "replicas_observed_before": 2, + "concurrency": 4, + "workload": "closed loop, 50% POST message (retry same key on failure) / 50% GET history, timeout 3 s", + "started_at_utc": "14:51:21", + "duration_seconds": 30.05, + "action_window_seconds": [ + 8.0, + 12.13 + ], + "action_stdout": [ + "stopped api container fcae2c6047af at 14:51:33" + ], + "before": { + "seconds": 8.0, + "successful_rps": 130.6, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 16.95, + "p95_ms": 86.35, + "p99_ms": 202.12 + }, + "during_action": { + "seconds": 4.13, + "successful_rps": 79.1, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 33.06, + "p95_ms": 100.93, + "p99_ms": 304.83 + }, + "after_action": { + "seconds": 17.92, + "successful_rps": 93.5, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 19.79, + "p95_ms": 98.76, + "p99_ms": 108.11 + }, + "total_errors": 0, + "last_error_after_action_start_s": 0.0, + "max_gap_between_successful_writes_s": 0.401, + "target_last_served_after_action_start_s": 0.99, + "instances_after_action": { + "1ff54c0efa0c": 1676 + }, + "confirmed_writes": 1525, + "lost_confirmed": 0, + "duplicates": 0, + "per_second": [ + { + "t": 0, + "ok": 146, + "err": 0 + }, + { + "t": 1, + "ok": 36, + "err": 0 + }, + { + "t": 2, + "ok": 164, + "err": 0 + }, + { + "t": 3, + "ok": 181, + "err": 0 + }, + { + "t": 4, + "ok": 82, + "err": 0 + }, + { + "t": 5, + "ok": 153, + "err": 0 + }, + { + "t": 6, + "ok": 170, + "err": 0 + }, + { + "t": 7, + "ok": 112, + "err": 0 + }, + { + "t": 8, + "ok": 104, + "err": 0 + }, + { + "t": 9, + "ok": 93, + "err": 0 + }, + { + "t": 10, + "ok": 79, + "err": 0 + }, + { + "t": 11, + "ok": 41, + "err": 0 + }, + { + "t": 12, + "ok": 111, + "err": 0 + }, + { + "t": 13, + "ok": 106, + "err": 0 + }, + { + "t": 14, + "ok": 49, + "err": 0 + }, + { + "t": 15, + "ok": 115, + "err": 0 + }, + { + "t": 16, + "ok": 129, + "err": 0 + }, + { + "t": 17, + "ok": 66, + "err": 0 + }, + { + "t": 18, + "ok": 96, + "err": 0 + }, + { + "t": 19, + "ok": 129, + "err": 0 + }, + { + "t": 20, + "ok": 82, + "err": 0 + }, + { + "t": 21, + "ok": 81, + "err": 0 + }, + { + "t": 22, + "ok": 123, + "err": 0 + }, + { + "t": 23, + "ok": 86, + "err": 0 + }, + { + "t": 24, + "ok": 77, + "err": 0 + }, + { + "t": 25, + "ok": 126, + "err": 0 + }, + { + "t": 26, + "ok": 80, + "err": 0 + }, + { + "t": 27, + "ok": 45, + "err": 0 + }, + { + "t": 28, + "ok": 94, + "err": 0 + }, + { + "t": 29, + "ok": 88, + "err": 0 + }, + { + "t": 30, + "ok": 4, + "err": 0 + } + ] +} diff --git a/evidence/failover-stop-2.json b/evidence/failover-stop-2.json new file mode 100644 index 00000000..aef6a8fc --- /dev/null +++ b/evidence/failover-stop-2.json @@ -0,0 +1,211 @@ +{ + "label": "stop-2", + "action_script": "scripts/stop-one.sh", + "target_instance": "1ff54c0efa0c", + "replicas_observed_before": 2, + "concurrency": 4, + "workload": "closed loop, 50% POST message (retry same key on failure) / 50% GET history, timeout 3 s", + "started_at_utc": "14:52:02", + "duration_seconds": 30.02, + "action_window_seconds": [ + 8.0, + 12.04 + ], + "action_stdout": [ + "stopped api container 1ff54c0efa0c at 14:52:14" + ], + "before": { + "seconds": 8.0, + "successful_rps": 149.2, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 14.55, + "p95_ms": 80.93, + "p99_ms": 92.48 + }, + "during_action": { + "seconds": 4.04, + "successful_rps": 108.0, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 17.34, + "p95_ms": 96.15, + "p99_ms": 105.53 + }, + "after_action": { + "seconds": 17.98, + "successful_rps": 87.9, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 21.55, + "p95_ms": 100.26, + "p99_ms": 112.06 + }, + "total_errors": 0, + "last_error_after_action_start_s": 0.0, + "max_gap_between_successful_writes_s": 0.389, + "target_last_served_after_action_start_s": 0.87, + "instances_after_action": { + "fcae2c6047af": 1581 + }, + "confirmed_writes": 1606, + "lost_confirmed": 0, + "duplicates": 0, + "per_second": [ + { + "t": 0, + "ok": 191, + "err": 0 + }, + { + "t": 1, + "ok": 60, + "err": 0 + }, + { + "t": 2, + "ok": 182, + "err": 0 + }, + { + "t": 3, + "ok": 190, + "err": 0 + }, + { + "t": 4, + "ok": 85, + "err": 0 + }, + { + "t": 5, + "ok": 198, + "err": 0 + }, + { + "t": 6, + "ok": 202, + "err": 0 + }, + { + "t": 7, + "ok": 86, + "err": 0 + }, + { + "t": 8, + "ok": 182, + "err": 0 + }, + { + "t": 9, + "ok": 122, + "err": 0 + }, + { + "t": 10, + "ok": 40, + "err": 0 + }, + { + "t": 11, + "ok": 88, + "err": 0 + }, + { + "t": 12, + "ok": 103, + "err": 0 + }, + { + "t": 13, + "ok": 68, + "err": 0 + }, + { + "t": 14, + "ok": 68, + "err": 0 + }, + { + "t": 15, + "ok": 122, + "err": 0 + }, + { + "t": 16, + "ok": 94, + "err": 0 + }, + { + "t": 17, + "ok": 67, + "err": 0 + }, + { + "t": 18, + "ok": 112, + "err": 0 + }, + { + "t": 19, + "ok": 92, + "err": 0 + }, + { + "t": 20, + "ok": 42, + "err": 0 + }, + { + "t": 21, + "ok": 115, + "err": 0 + }, + { + "t": 22, + "ok": 104, + "err": 0 + }, + { + "t": 23, + "ok": 53, + "err": 0 + }, + { + "t": 24, + "ok": 102, + "err": 0 + }, + { + "t": 25, + "ok": 121, + "err": 0 + }, + { + "t": 26, + "ok": 57, + "err": 0 + }, + { + "t": 27, + "ok": 86, + "err": 0 + }, + { + "t": 28, + "ok": 94, + "err": 0 + }, + { + "t": 29, + "ok": 81, + "err": 0 + }, + { + "t": 30, + "ok": 4, + "err": 0 + } + ] +} diff --git a/evidence/idempotency-concurrency.json b/evidence/idempotency-concurrency.json new file mode 100644 index 00000000..8b435d1a --- /dev/null +++ b/evidence/idempotency-concurrency.json @@ -0,0 +1,79 @@ +{ + "test": "concurrent idempotency through LB", + "parallel_requests_per_round": 16, + "rounds": 10, + "rounds_spanning_two_or_more_replicas": 10, + "duplicates_created": 0, + "per_round": [ + { + "round": 0, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 1, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 2, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 3, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 4, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 5, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 6, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 7, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 8, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + }, + { + "round": 9, + "parallel": 16, + "distinct_messages": 1, + "instances": 2, + "replayed_responses": 15 + } + ] +} diff --git a/evidence/load-docker-stats.txt b/evidence/load-docker-stats.txt new file mode 100644 index 00000000..bcf8c4a5 --- /dev/null +++ b/evidence/load-docker-stats.txt @@ -0,0 +1,6 @@ +messenger-lab3-tester-run-c6658c5e7ad7 cpu=27.40% mem=19.58MiB / 7.419GiB +messenger-lab3-api-4 cpu=48.76% mem=79.75MiB / 256MiB +messenger-lab3-api-3 cpu=49.33% mem=71.11MiB / 256MiB +messenger-lab3-lb-1 cpu=21.96% mem=18.42MiB / 128MiB +messenger-lab3-db-1 cpu=33.73% mem=53.23MiB / 512MiB +messenger-lab3-valkey-1 cpu=4.30% mem=3.574MiB / 128MiB diff --git a/evidence/load-run1.json b/evidence/load-run1.json new file mode 100644 index 00000000..1fe86a47 --- /dev/null +++ b/evidence/load-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.137, + "concurrency": 4, + "successful_requests": 4638, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 153.898, + "successful_latency_ms": { + "p50": 14.336, + "p95": 81.554, + "p99": 100.194 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-run2.json b/evidence/load-run2.json new file mode 100644 index 00000000..6afa9a73 --- /dev/null +++ b/evidence/load-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.162, + "concurrency": 4, + "successful_requests": 4376, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 145.082, + "successful_latency_ms": { + "p50": 15.089, + "p95": 83.347, + "p99": 102.424 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-run3.json b/evidence/load-run3.json new file mode 100644 index 00000000..195dc653 --- /dev/null +++ b/evidence/load-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.078, + "concurrency": 4, + "successful_requests": 4593, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 152.705, + "successful_latency_ms": { + "p50": 15.075, + "p95": 76.466, + "p99": 98.019 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..acdf67a6 --- /dev/null +++ b/evidence/load.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.065, + "concurrency": 4, + "successful_requests": 4277, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 142.257, + "successful_latency_ms": { + "p50": 15.402, + "p95": 85.901, + "p99": 138.316 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..15365e46 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,17 @@ +### 2026-10-13T14:50:40Z до restart: +messenger-lab3-api-3 1ff54c0efa0c Up 51 seconds (healthy) +messenger-lab3-api-4 fcae2c6047af Up 22 seconds (healthy) +messenger-lab3-db-1 9d8a07ddc444 Up 2 hours (healthy) +messenger-lab3-lb-1 087c5c4c9b74 Up 2 hours (healthy) +messenger-lab3-valkey-1 0f4951a33b71 Up 2 hours (healthy) +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. +### после (StartedAt — реально перезапущены): +/messenger-lab3-api-3 StartedAt=2026-10-13T14:50:55.574609688Z +/messenger-lab3-api-4 StartedAt=2026-10-13T14:50:55.279589647Z +/messenger-lab3-db-1 StartedAt=2026-10-13T14:50:49.636908343Z +/messenger-lab3-lb-1 StartedAt=2026-10-13T14:51:02.112231194Z +/messenger-lab3-valkey-1 StartedAt=2026-10-13T14:50:49.863592805Z +DRIVER VOLUME NAME +local messenger-lab3_postgres_data diff --git a/evidence/public-tests.txt b/evidence/public-tests.txt new file mode 100644 index 00000000..b5dded51 --- /dev/null +++ b/evidence/public-tests.txt @@ -0,0 +1,43 @@ +### 2026-10-13T14:49:21Z финальный код (образ messenger-lab3-api:v2) +### docker compose ps +messenger-lab3-api-3 1ff54c0efa0c messenger-lab3-api:v2 Up About an hour (healthy) +messenger-lab3-api-4 fcae2c6047af messenger-lab3-api:v2 Up About an hour (healthy) +messenger-lab3-db-1 9d8a07ddc444 postgres:16.4-alpine Up 2 hours (healthy) +messenger-lab3-lb-1 087c5c4c9b74 haproxy:3.0.11-alpine Up 2 hours (healthy) +messenger-lab3-valkey-1 0f4951a33b71 valkey/valkey:8.0.1-alpine Up 2 hours (healthy) +### make check +python scripts/check_contract.py +PASS: offline skeleton structure, local refs and Python syntax; application NOT tested. +### make test (хост -> LB localhost:8080) +python tests/smoke.py --base-url "http://localhost:8080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. +### X-Instance-Id через LB (4 запроса подряд) +x-instance-id: fcae2c6047af +x-instance-id: 1ff54c0efa0c +x-instance-id: fcae2c6047af +x-instance-id: 1ff54c0efa0c +### make test-failover #1; реплики до: +messenger-lab3-api-4 fcae2c6047af Up About an hour (healthy) +messenger-lab3-api-3 1ff54c0efa0c Up About an hour (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": 129, "failed_attempts": 0, "first_recovery_seconds": 4.4} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +### реплики после (остановленный контейнер): +messenger-lab3-api-4 fcae2c6047af Up About an hour (healthy) +messenger-lab3-api-3 1ff54c0efa0c Exited (0) 11 seconds ago +started api container 1ff54c0efa0c +running api replicas: 2 +(перед вторым прогоном 1 лишний запрос через LB сдвигает round-robin, чтобы тест выбрал другую реплику) +### make test-failover #2; реплики до: +messenger-lab3-api-4 fcae2c6047af Up About an hour (healthy) +messenger-lab3-api-3 1ff54c0efa0c Up 7 seconds (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": 122, "failed_attempts": 0, "first_recovery_seconds": 4.52} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. +### реплики после (остановленный контейнер): +messenger-lab3-api-4 fcae2c6047af Exited (0) 11 seconds ago +messenger-lab3-api-3 1ff54c0efa0c Up 28 seconds (healthy) +started api container fcae2c6047af +running api replicas: 2 diff --git a/evidence/rolling-update-load.json b/evidence/rolling-update-load.json new file mode 100644 index 00000000..7e21a5e5 --- /dev/null +++ b/evidence/rolling-update-load.json @@ -0,0 +1,407 @@ +{ + "label": "rolling-update", + "action_script": null, + "target_instance": "1ff54c0efa0c", + "replicas_observed_before": 2, + "concurrency": 4, + "workload": "closed loop, 50% POST message (retry same key on failure) / 50% GET history, timeout 3 s", + "started_at_utc": "14:56:44", + "duration_seconds": 70.05, + "action_window_seconds": [ + 70.05, + 70.05 + ], + "action_stdout": null, + "before": { + "seconds": 70.05, + "successful_rps": 137.8, + "errors": 0, + "error_ratio": 0.0, + "p50_ms": 14.88, + "p95_ms": 89.12, + "p99_ms": 143.83 + }, + "during_action": { + "seconds": 0.0, + "successful_rps": 0.0, + "errors": 0, + "error_ratio": null, + "p50_ms": null, + "p95_ms": null, + "p99_ms": null + }, + "after_action": { + "seconds": 0.0, + "successful_rps": 0.0, + "errors": 0, + "error_ratio": null, + "p50_ms": null, + "p95_ms": null, + "p99_ms": null + }, + "total_errors": 0, + "last_error_after_action_start_s": 0.0, + "max_gap_between_successful_writes_s": 0.054, + "target_last_served_after_action_start_s": null, + "instances_after_action": {}, + "confirmed_writes": 4826, + "lost_confirmed": 0, + "duplicates": 0, + "per_second": [ + { + "t": 0, + "ok": 106, + "err": 0 + }, + { + "t": 1, + "ok": 192, + "err": 0 + }, + { + "t": 2, + "ok": 232, + "err": 0 + }, + { + "t": 3, + "ok": 121, + "err": 0 + }, + { + "t": 4, + "ok": 214, + "err": 0 + }, + { + "t": 5, + "ok": 226, + "err": 0 + }, + { + "t": 6, + "ok": 99, + "err": 0 + }, + { + "t": 7, + "ok": 183, + "err": 0 + }, + { + "t": 8, + "ok": 146, + "err": 0 + }, + { + "t": 9, + "ok": 64, + "err": 0 + }, + { + "t": 10, + "ok": 109, + "err": 0 + }, + { + "t": 11, + "ok": 166, + "err": 0 + }, + { + "t": 12, + "ok": 95, + "err": 0 + }, + { + "t": 13, + "ok": 145, + "err": 0 + }, + { + "t": 14, + "ok": 163, + "err": 0 + }, + { + "t": 15, + "ok": 97, + "err": 0 + }, + { + "t": 16, + "ok": 191, + "err": 0 + }, + { + "t": 17, + "ok": 218, + "err": 0 + }, + { + "t": 18, + "ok": 81, + "err": 0 + }, + { + "t": 19, + "ok": 193, + "err": 0 + }, + { + "t": 20, + "ok": 115, + "err": 0 + }, + { + "t": 21, + "ok": 61, + "err": 0 + }, + { + "t": 22, + "ok": 102, + "err": 0 + }, + { + "t": 23, + "ok": 126, + "err": 0 + }, + { + "t": 24, + "ok": 97, + "err": 0 + }, + { + "t": 25, + "ok": 56, + "err": 0 + }, + { + "t": 26, + "ok": 116, + "err": 0 + }, + { + "t": 27, + "ok": 169, + "err": 0 + }, + { + "t": 28, + "ok": 83, + "err": 0 + }, + { + "t": 29, + "ok": 161, + "err": 0 + }, + { + "t": 30, + "ok": 125, + "err": 0 + }, + { + "t": 31, + "ok": 109, + "err": 0 + }, + { + "t": 32, + "ok": 180, + "err": 0 + }, + { + "t": 33, + "ok": 191, + "err": 0 + }, + { + "t": 34, + "ok": 127, + "err": 0 + }, + { + "t": 35, + "ok": 180, + "err": 0 + }, + { + "t": 36, + "ok": 218, + "err": 0 + }, + { + "t": 37, + "ok": 88, + "err": 0 + }, + { + "t": 38, + "ok": 106, + "err": 0 + }, + { + "t": 39, + "ok": 165, + "err": 0 + }, + { + "t": 40, + "ok": 59, + "err": 0 + }, + { + "t": 41, + "ok": 62, + "err": 0 + }, + { + "t": 42, + "ok": 126, + "err": 0 + }, + { + "t": 43, + "ok": 113, + "err": 0 + }, + { + "t": 44, + "ok": 83, + "err": 0 + }, + { + "t": 45, + "ok": 125, + "err": 0 + }, + { + "t": 46, + "ok": 122, + "err": 0 + }, + { + "t": 47, + "ok": 92, + "err": 0 + }, + { + "t": 48, + "ok": 92, + "err": 0 + }, + { + "t": 49, + "ok": 200, + "err": 0 + }, + { + "t": 50, + "ok": 103, + "err": 0 + }, + { + "t": 51, + "ok": 133, + "err": 0 + }, + { + "t": 52, + "ok": 223, + "err": 0 + }, + { + "t": 53, + "ok": 104, + "err": 0 + }, + { + "t": 54, + "ok": 194, + "err": 0 + }, + { + "t": 55, + "ok": 157, + "err": 0 + }, + { + "t": 56, + "ok": 52, + "err": 0 + }, + { + "t": 57, + "ok": 151, + "err": 0 + }, + { + "t": 58, + "ok": 155, + "err": 0 + }, + { + "t": 59, + "ok": 97, + "err": 0 + }, + { + "t": 60, + "ok": 166, + "err": 0 + }, + { + "t": 61, + "ok": 189, + "err": 0 + }, + { + "t": 62, + "ok": 90, + "err": 0 + }, + { + "t": 63, + "ok": 218, + "err": 0 + }, + { + "t": 64, + "ok": 193, + "err": 0 + }, + { + "t": 65, + "ok": 91, + "err": 0 + }, + { + "t": 66, + "ok": 202, + "err": 0 + }, + { + "t": 67, + "ok": 168, + "err": 0 + }, + { + "t": 68, + "ok": 69, + "err": 0 + }, + { + "t": 69, + "ok": 202, + "err": 0 + }, + { + "t": 70, + "ok": 4, + "err": 0 + } + ] +} diff --git a/evidence/rolling-update-load.txt b/evidence/rolling-update-load.txt new file mode 100644 index 00000000..59dd5930 --- /dev/null +++ b/evidence/rolling-update-load.txt @@ -0,0 +1,2 @@ +{"label": "rolling-update", "target_instance": "1ff54c0efa0c", "before": {"seconds": 70.05, "successful_rps": 137.8, "errors": 0, "error_ratio": 0.0, "p50_ms": 14.88, "p95_ms": 89.12, "p99_ms": 143.83}, "during_action": {"seconds": 0.0, "successful_rps": 0.0, "errors": 0, "error_ratio": null, "p50_ms": null, "p95_ms": null, "p99_ms": null}, "after_action": {"seconds": 0.0, "successful_rps": 0.0, "errors": 0, "error_ratio": null, "p50_ms": null, "p95_ms": null, "p99_ms": null}, "total_errors": 0, "last_error_after_action_start_s": 0.0, "max_gap_between_successful_writes_s": 0.054, "target_last_served_after_action_start_s": null, "instances_after_action": {}, "confirmed_writes": 4826} +PASS: no confirmed message lost, no duplicates diff --git a/evidence/rolling-update.txt b/evidence/rolling-update.txt new file mode 100644 index 00000000..3474ea34 --- /dev/null +++ b/evidence/rolling-update.txt @@ -0,0 +1,18 @@ +### 2026-10-13T14:56:53Z api до: +messenger-lab3-api-4 fcae2c6047af messenger-lab3-api:v2 Up 3 minutes (healthy) +messenger-lab3-api-3 1ff54c0efa0c messenger-lab3-api:v2 Up 3 minutes (healthy) +[14:56:53] build image messenger-lab3-api:v3 +[14:57:05] run migrations once +SKIP 001_initial_schema.sql +SKIP 002_indexes.sql +SKIP 003_idempotency_keys.sql +PASS: migrations applied +[14:57:08] scale api to 3 (new replica for fcae2c6047af) +[14:57:20] new a9d3dc77f288 healthy; stop old fcae2c6047af +[14:57:25] scale api to 3 (new replica for 1ff54c0efa0c) +[14:57:36] new ea0e32824716 healthy; stop old 1ff54c0efa0c +[14:57:40] rolling update complete: 2 replicas +all api replicas run messenger-lab3-api:v3 +### api после: +messenger-lab3-api-6 ea0e32824716 messenger-lab3-api:v3 Up 16 seconds (healthy) +messenger-lab3-api-5 a9d3dc77f288 messenger-lab3-api:v3 Up 32 seconds (healthy) diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..971d1e87 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -0,0 +1,96 @@ +# HAProxy 3.0 — единственная публичная точка входа (порт 8080). +# Backend-адреса берутся из встроенного DNS Docker: имя сервиса `api` возвращает A-запись +# каждого работающего контейнера-реплики. Реплики не публикуют порты наружу. + +global + log stdout format raw local0 info + maxconn 2048 + +# Встроенный DNS Docker. hold valid 2s — как часто перечитывается список реплик +# (новые контейнеры при scale/rolling update появляются в пуле за ≤ 2–3 s). +resolvers docker + nameserver dns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 2s + hold other 2s + hold refused 2s + hold nx 2s + hold timeout 2s + hold obsolete 2s + accepted_payload_size 8192 + +defaults + mode http + log global + option httplog + option dontlognull + # Таймауты согласованы с приложением: + # connect 1s — недоступная реплика быстро даёт ошибку соединения -> retry на другую; + # server 10s — больше statement_timeout БД (5 s) + ожидания пула (3 s); + # http-keep-alive 10s < timeout_keep_alive uvicorn (30 s): LB закрывает простой первым. + timeout connect 1s + timeout client 30s + timeout server 10s + timeout http-request 10s + timeout http-keep-alive 10s + timeout queue 5s + retries 2 + option redispatch 1 + +frontend http_in + bind :8080 + # X-Request-Id создаётся на входе (если клиент не прислал корректный), передаётся в API + # и попадает в лог LB — один ID в логах LB и реплики. + unique-id-format %{+X}o\ %ci:%cp_%fi:%fp_%Ts_%rt:%pid + acl has_valid_rid req.hdr(X-Request-Id) -m reg ^[A-Za-z0-9._:-]{1,128}$ + http-request set-header X-Request-Id %[unique-id] unless has_valid_rid + http-request set-var(txn.rid) req.hdr(X-Request-Id) + log-format "%ci:%cp [%tr] %ft %b/%s %TR/%Tw/%Tc/%Tr/%Ta %ST %B %tsc %ac/%fc/%bc/%sc/%rc %sq/%bq rid=%[var(txn.rid)] \"%HM %HPO\"" + default_backend api + + # Ошибки, созданные самим LB (нет живых реплик / timeout), — в формате контракта. + http-error status 502 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Нет доступных реплик API\",\"request_id\":\"%[var(txn.rid)]\"}}" hdr X-Request-Id "%[var(txn.rid)]" + http-error status 503 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Нет доступных реплик API\",\"request_id\":\"%[var(txn.rid)]\"}}" hdr X-Request-Id "%[var(txn.rid)]" + http-error status 504 content-type application/json lf-string "{\"error\":{\"code\":\"unavailable\",\"message\":\"Реплика API не ответила вовремя\",\"request_id\":\"%[var(txn.rid)]\"}}" hdr X-Request-Id "%[var(txn.rid)]" + +backend api + # Обычный round-robin без sticky session: корректность обеспечивает общее состояние в PostgreSQL. + balance roundrobin + + # Активная проверка готовности каждые 1 s; 2 неудачи подряд -> DOWN, 2 успеха -> UP. + # Максимальное время обнаружения отказа «процесс жив, но не готов»: + # inter × fall + timeout check = 1 s × 2 + 1 s ≈ 3 s. + # Упавший процесс (connection refused) обнаруживается быстрее: observe layer4 + error-limit 1 + # переводит сервер в DOWN по первой реальной ошибке соединения, а запрос уходит на другую реплику. + option httpchk + http-check send meth GET uri /health/ready + http-check expect status 200 + default-server inter 1s fastinter 500ms downinter 1s fall 2 rise 2 observe layer4 error-limit 1 on-error mark-down resolvers docker init-addr none resolve-prefer ipv4 check + timeout check 1s + + # Повторы на другую реплику: + # - ошибка установления соединения повторяется всегда (запрос не дошёл до приложения); + # - L7-повторы (пустой ответ / 503 от дренирующейся реплики) разрешены только для + # безопасных GET и для POST сообщения С Idempotency-Key — его повтор не создаст дубль. + # POST /users, /chats, /auth/sessions после отправки не повторяются (нет ключа идемпотентности). + retry-on conn-failure empty-response 503 + acl is_message_post path_reg ^/api/v1/chats/[^/]+/messages$ + acl has_idem_key req.hdr(Idempotency-Key) -m found + http-request disable-l7-retry if METH_POST !is_message_post + http-request disable-l7-retry if METH_POST !has_idem_key + http-request disable-l7-retry if METH_DELETE + + # До 8 реплик (scale/rolling update); пустые слоты остаются в MAINT, пока DNS не вернёт адрес. + server-template api 8 api:8080 + +# Служебная страница состояния backend-ов (UP/DOWN, счётчики ошибок/повторов). +# В compose.yaml публикуется только на 127.0.0.1 хоста — не часть публичного API. +frontend stats + bind :8404 + http-request return status 200 content-type text/plain string "ok" if { path /lb-health } + stats enable + stats uri /stats + stats refresh 2s + stats show-legends diff --git a/migrations/001_initial_schema.sql b/migrations/001_initial_schema.sql new file mode 100644 index 00000000..64418088 --- /dev/null +++ b/migrations/001_initial_schema.sql @@ -0,0 +1,48 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + CONSTRAINT users_username_format_check + CHECK (username ~ '^[a-z0-9_]{3,32}$'), + + CONSTRAINT users_display_name_nonblank_check + CHECK (char_length(btrim(display_name)) >= 1) + ); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title VARCHAR(255) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + CONSTRAINT chats_title_nonblank_check + CHECK (char_length(btrim(title)) >= 1) + ); + +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT, + PRIMARY KEY (chat_id, user_id) + ); + +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE RESTRICT, + text VARCHAR(4000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + CONSTRAINT messages_text_nonblank_check + CHECK (char_length(btrim(text)) >= 1) + ); + +CREATE TABLE IF NOT EXISTS sessions ( + id UUID PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + token_hash CHAR(64) NOT NULL UNIQUE, + expires_at TIMESTAMPTZ NOT NULL, + revoked_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() + ); \ No newline at end of file diff --git a/migrations/002_indexes.sql b/migrations/002_indexes.sql new file mode 100644 index 00000000..af47095f --- /dev/null +++ b/migrations/002_indexes.sql @@ -0,0 +1,12 @@ +CREATE INDEX IF NOT EXISTS messages_keyset_idx + ON messages (chat_id, created_at ASC, id ASC); + +CREATE INDEX IF NOT EXISTS chats_keyset_idx + ON chats (created_at ASC, id ASC); + +CREATE INDEX IF NOT EXISTS chat_members_user_chat_idx + ON chat_members (user_id, chat_id); + +CREATE INDEX IF NOT EXISTS sessions_active_token_idx + ON sessions (token_hash, expires_at) + WHERE revoked_at IS NULL; \ No newline at end of file diff --git a/migrations/003_idempotency_keys.sql b/migrations/003_idempotency_keys.sql new file mode 100644 index 00000000..eacde91d --- /dev/null +++ b/migrations/003_idempotency_keys.sql @@ -0,0 +1,18 @@ +-- Lab3: shared idempotency of POST /chats/{chat_id}/messages. +-- Scope: user + method + chat path + key. The key row and the message are +-- written in one transaction, so either both exist or neither does. +-- Expand-only change: the running lab2/lab3 API keeps working with it. +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + method VARCHAR(8) NOT NULL, + key VARCHAR(128) NOT NULL, + request_hash CHAR(64) NOT NULL, + message_id UUID REFERENCES messages(id) ON DELETE CASCADE, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, chat_id, method, key) +); + +-- For a periodic cleanup of keys older than IDEMPOTENCY_TTL_SECONDS. +CREATE INDEX IF NOT EXISTS idempotency_keys_created_idx + ON idempotency_keys (created_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..9e3cb890 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +fastapi==0.115.0 +uvicorn[standard]==0.30.6 +pydantic==2.9.2 +SQLAlchemy==2.0.36 +asyncpg==0.30.0 +argon2-cffi==23.1.0 +redis==5.0.8 diff --git a/scripts/init-secrets.sh b/scripts/init-secrets.sh new file mode 100644 index 00000000..42e3c0fd --- /dev/null +++ b/scripts/init-secrets.sh @@ -0,0 +1,36 @@ +#!/bin/sh +# Creates local Docker secrets for a synthetic lab stand. +# Existing files are never overwritten; values are never printed. +set -eu + +dir="$(cd "$(dirname "$0")/.." && pwd)/infra/secrets" +mkdir -p "$dir" +# Host access is limited by the directory mode; the files themselves must stay +# readable by the non-root users inside containers (bind-mounted secrets). +chmod 700 "$dir" 2>/dev/null || true + +random() { + od -An -tx1 -N24 /dev/urandom | tr -d ' \n' +} + +write_new() { + if [ -f "$dir/$1" ]; then + echo "keep infra/secrets/$1" + else + printf '%s' "$2" > "$dir/$1" + chmod 644 "$dir/$1" 2>/dev/null || true + echo "create infra/secrets/$1" + fi +} + +if [ ! -f "$dir/postgres_password.txt" ]; then + write_new postgres_password.txt "$(random)" +fi +pg_password="$(cat "$dir/postgres_password.txt")" +write_new database_url.txt "postgresql://messenger:${pg_password}@db:5432/messenger" + +if [ ! -f "$dir/valkey_password.txt" ]; then + write_new valkey_password.txt "$(random)" +fi +valkey_password="$(cat "$dir/valkey_password.txt")" +write_new cache_url.txt "redis://:${valkey_password}@valkey:6379/0" diff --git a/scripts/kill-one.sh b/scripts/kill-one.sh new file mode 100644 index 00000000..bd30ddc0 --- /dev/null +++ b/scripts/kill-one.sh @@ -0,0 +1,18 @@ +#!/bin/sh +# Вариант жёсткого отказа (для сравнения): SIGKILL без graceful shutdown. +# Используется в собственных экспериментах; публичный тест запускается со stop-one.sh. +set -eu +: "${TARGET_INSTANCE_ID:?target API instance alias required}" +. "$(dirname "$0")/lib.sh" +case "$TARGET_INSTANCE_ID" in + *[!0-9a-f]* | "") echo "unexpected instance id format" >&2; exit 2 ;; +esac +for id in $(service_ids api); do + case "$id" in "$TARGET_INSTANCE_ID"*) + docker kill --signal KILL "$id" >/dev/null + echo "killed api container $(short "$id") at $(date -u +%H:%M:%S)" + exit 0 ;; + esac +done +echo "instance $TARGET_INSTANCE_ID is not a running api container" >&2 +exit 3 diff --git a/scripts/lib.sh b/scripts/lib.sh new file mode 100644 index 00000000..688836b6 --- /dev/null +++ b/scripts/lib.sh @@ -0,0 +1,33 @@ +#!/bin/sh +# Общие функции операторских скриптов. Используют только docker CLI и метки Compose, +# поэтому работают и на хосте, и в контейнере tester (docker.sock). +PROJECT="${COMPOSE_PROJECT:-messenger-lab3}" + +# ID контейнеров сервиса (по умолчанию только работающих); -a — включая остановленные. +service_ids() { + # $1 — сервис, $2 — необязательный флаг -a + docker ps ${2:-} -q --no-trunc \ + --filter "label=com.docker.compose.project=$PROJECT" \ + --filter "label=com.docker.compose.service=$1" +} + +# Ждать, пока все переданные контейнеры станут healthy (timeout в секундах первым аргументом). +# В POSIX sh переменные функций глобальны: имена с префиксом _wh_, чтобы не затереть +# переменные вызывающего цикла. +wait_healthy() { + _wh_timeout="$1"; shift + _wh_deadline=$(( $(date +%s) + _wh_timeout )) + for _wh_id in "$@"; do + while :; do + _wh_state=$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$_wh_id" 2>/dev/null || echo missing) + case "$_wh_state" in healthy|running) break ;; esac + if [ "$(date +%s)" -ge "$_wh_deadline" ]; then + echo "container $(echo "$_wh_id" | cut -c1-12) not healthy (state=$_wh_state)" >&2 + return 1 + fi + sleep 1 + done + done +} + +short() { echo "$1" | cut -c1-12; } diff --git a/scripts/migrate.py b/scripts/migrate.py new file mode 100644 index 00000000..252d602d --- /dev/null +++ b/scripts/migrate.py @@ -0,0 +1,99 @@ +from __future__ import annotations + +import asyncio +import os +from pathlib import Path + +import asyncpg + + +ROOT = Path(__file__).resolve().parents[1] +MIGRATIONS_DIR = ROOT / "migrations" +# Lab3: migrations run once in the "migrate" service before the API replicas +# start. The advisory lock still serialises two accidental parallel runs +# (e.g. a manual run during a rolling update); the second one then sees all +# versions in schema_migrations and only prints SKIP. +MIGRATION_LOCK_ID = 727003 + + +def read_database_url() -> str: + file_name = os.getenv("DATABASE_URL_FILE") + + if file_name: + return Path(file_name).read_text(encoding="utf-8").strip() + + value = os.getenv("DATABASE_URL") + + if not value: + raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required.") + + return value + + +def plain_postgres_url(url: str) -> str: + if url.startswith("postgresql+asyncpg://"): + return url.replace("postgresql+asyncpg://", "postgresql://", 1) + + return url + + +async def connect_with_retry(url: str, attempts: int = 30): + for attempt in range(1, attempts + 1): + try: + return await asyncpg.connect(url, timeout=3) + except (OSError, asyncpg.PostgresError) as exc: + if attempt == attempts: + raise + print(f"WAIT database ({type(exc).__name__}), retry {attempt}") + await asyncio.sleep(1) + + +async def migrate() -> None: + connection = await connect_with_retry( + plain_postgres_url(read_database_url()) + ) + + try: + await connection.execute( + "SELECT pg_advisory_lock($1)", + MIGRATION_LOCK_ID, + ) + await connection.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """ + ) + + applied_rows = await connection.fetch( + "SELECT version FROM schema_migrations" + ) + applied = {row["version"] for row in applied_rows} + + for migration_file in sorted(MIGRATIONS_DIR.glob("*.sql")): + version = migration_file.name + + if version in applied: + print(f"SKIP {version}") + continue + + sql = migration_file.read_text(encoding="utf-8") + + print(f"APPLY {version}") + + async with connection.transaction(): + await connection.execute(sql) + await connection.execute( + "INSERT INTO schema_migrations (version) VALUES ($1)", + version, + ) + + print("PASS: migrations applied") + finally: + await connection.close() + + +if __name__ == "__main__": + asyncio.run(migrate()) \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..3492ae6f --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,19 @@ +#!/bin/sh +# Persistence hook: restarts the LB, every API replica and both stores +# (PostgreSQL with its volume, Valkey cache). No "down -v", no re-seed. +# Uses only the docker CLI and Compose labels, so it also runs in "tester". +set -eu +. "$(dirname "$0")/lib.sh" +api=$(service_ids api); lb=$(service_ids lb); db=$(service_ids db); valkey=$(service_ids valkey) +[ -n "$api" ] && [ -n "$db" ] && [ -n "$lb" ] && [ -n "$valkey" ] || { echo "stack is not running" >&2; exit 2; } +echo "stopping lb + api, then db + valkey" +docker stop --time 15 $lb $api >/dev/null +docker stop --time 30 $db $valkey >/dev/null +echo "starting db + valkey" +docker start $db $valkey >/dev/null +wait_healthy 60 $db $valkey +echo "starting api" +docker start $api >/dev/null +wait_healthy 60 $api +docker start $lb >/dev/null +echo "restart complete: db=$(short $db) valkey=$(short $valkey) api=$(for i in $api; do short $i; done | tr '\n' ' ')" diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100644 index 00000000..c4f7aa64 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,40 @@ +#!/bin/sh +# Поочерёдная замена API-реплик на новую сборку без остановки сервиса (запуск на хосте, +# нужен docker compose). Для каждой старой реплики: +# 1) запустить +1 новую реплику (--no-recreate не трогает старые), дождаться healthy; +# 2) HAProxy находит её через DNS (≤ 2 s) и включает после 2 успешных проверок; +# 3) остановить старую (SIGTERM -> drain) и удалить её контейнер. +# Миграции выполняются один раз ДО замены и должны быть совместимы со старой версией (expand). +set -eu +cd "$(dirname "$0")/.." +. scripts/lib.sh +export APP_VERSION="${APP_VERSION:-dev}" +echo "[$(date -u +%H:%M:%S)] build image messenger-lab3-api:$APP_VERSION" +docker compose build api migrate >/dev/null +echo "[$(date -u +%H:%M:%S)] run migrations once" +docker compose run --rm --no-deps migrate +old=$(service_ids api) +[ -n "$old" ] || { echo "no running api replicas" >&2; exit 2; } +for id in $old; do + before=$(service_ids api | tr '\n' ' ') + count=$(echo "$before" | wc -w | tr -d ' ') + echo "[$(date -u +%H:%M:%S)] scale api to $((count + 1)) (new replica for $(short "$id"))" + docker compose up -d --no-deps --no-recreate --scale "api=$((count + 1))" api >/dev/null 2>&1 + new="" + for c in $(service_ids api); do + case " $before " in *" $c "*) ;; *) new="$new $c" ;; esac + done + [ -n "$new" ] || { echo "new replica was not created" >&2; exit 3; } + wait_healthy 60 $new + sleep 3 # DNS hold (2 s) + rise 2 × inter 1 s: новая реплика уже в пуле LB + echo "[$(date -u +%H:%M:%S)] new $(for c in $new; do short "$c"; done | tr '\n' ' ')healthy; stop old $(short "$id")" + docker stop --time 15 "$id" >/dev/null + docker rm "$id" >/dev/null +done +echo "[$(date -u +%H:%M:%S)] rolling update complete: $(service_ids api | wc -l | tr -d ' ') replicas" +# Проверка результата: все работающие реплики запущены из нового образа. +for c in $(service_ids api); do + image=$(docker inspect -f '{{.Config.Image}}' "$c") + [ "$image" = "messenger-lab3-api:$APP_VERSION" ] || { echo "replica $(short "$c") runs $image" >&2; exit 4; } +done +echo "all api replicas run messenger-lab3-api:$APP_VERSION" diff --git a/scripts/start-api.sh b/scripts/start-api.sh new file mode 100644 index 00000000..10bee72c --- /dev/null +++ b/scripts/start-api.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# Восстановление после stop-one.sh: запускает остановленные API-реплики и ждёт healthy. +set -eu +. "$(dirname "$0")/lib.sh" +all=$(service_ids api -a) +running=$(service_ids api) +started="" +for id in $all; do + case " $running " in *" $id "*) continue ;; esac + docker start "$id" >/dev/null + started="$started $id" + echo "started api container $(short "$id")" +done +[ -z "$started" ] || wait_healthy 60 $started +echo "running api replicas: $(service_ids api | wc -l | tr -d ' ')" diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..533d1e6c --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,21 @@ +#!/bin/sh +# Failover hook: останавливает ОДНУ API-реплику, обслужившую тест, и оставляет её остановленной. +# TARGET_INSTANCE_ID = X-Instance-Id = hostname контейнера = префикс его Docker ID. +# БД, LB и volumes не затрагиваются. Восстановление: scripts/start-api.sh. +set -eu +: "${TARGET_INSTANCE_ID:?test provides target API instance alias}" +. "$(dirname "$0")/lib.sh" +case "$TARGET_INSTANCE_ID" in + *[!0-9a-f]* | "") echo "unexpected instance id format" >&2; exit 2 ;; +esac +target="" +for id in $(service_ids api); do + case "$id" in "$TARGET_INSTANCE_ID"*) target="$id" ;; esac +done +if [ -z "$target" ]; then + echo "instance $TARGET_INSTANCE_ID is not a running api container of project $PROJECT" >&2 + exit 3 +fi +# docker stop = SIGTERM -> graceful drain (~3 s) -> выход; SIGKILL только после 15 s. +docker stop --time 15 "$target" >/dev/null +echo "stopped api container $(short "$target") at $(date -u +%H:%M:%S)" diff --git a/student-tests/Dockerfile.tester b/student-tests/Dockerfile.tester new file mode 100644 index 00000000..9d9d000f --- /dev/null +++ b/student-tests/Dockerfile.tester @@ -0,0 +1,6 @@ +# Окружение для запуска проверок: Python 3.12 (stdlib-тесты), make, docker CLI (action-скрипты). +FROM docker:28.5.1-cli AS docker-cli +FROM python:3.12.11-alpine3.22 +RUN apk add --no-cache make +COPY --from=docker-cli /usr/local/bin/docker /usr/local/bin/docker +WORKDIR /work diff --git a/student-tests/failover_load.py b/student-tests/failover_load.py new file mode 100644 index 00000000..9a722dcc --- /dev/null +++ b/student-tests/failover_load.py @@ -0,0 +1,188 @@ +#!/usr/bin/env python3 +"""Нагрузка во время отказа/замены реплики с метриками по времени. + +Потоки непрерывно пишут сообщения (как настоящий клиент: при неопределённом результате +повторяют POST с ТЕМ ЖЕ Idempotency-Key) и читают историю. Через --action-after секунд +запускается action-скрипт (stop-one.sh / kill-one.sh / rolling-update.sh) с TARGET_INSTANCE_ID. + +Отчёт: успешные RPS до/во время/после, ошибки, p50/p95/p99, время до последней ошибки, +максимальный разрыв между успешными записями, распределение по репликам, проверка +сохранности подтверждённых сообщений и отсутствия дублей. +""" +from concurrent.futures import ThreadPoolExecutor +import json +import math +import os +from pathlib import Path +import subprocess +import sys +import threading +import time +import uuid +from urllib.parse import quote + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, Failure, arguments, check, run # noqa: E402 + + +def pct(values, p): + if not values: + return None + values = sorted(values) + return round(1000 * values[max(0, math.ceil(p * len(values)) - 1)], 2) + + +def history(c, actor, chat): + path = '/api/v1/chats/' + chat['id'] + '/messages?limit=100' + items = [] + while True: + page = c.call('GET', path, actor=actor, schema='MessagePage')['json'] + items.extend(page['items']) + if page['next_cursor'] is None: + return items + path = '/api/v1/chats/' + chat['id'] + '/messages?limit=100&cursor=' + quote(page['next_cursor'], safe='') + + +def main(): + def configure(p): + p.add_argument('--duration', type=float, default=30) + p.add_argument('--concurrency', type=int, default=4) + p.add_argument('--action-after', type=float, default=8) + p.add_argument('--action-script', default=None) + p.add_argument('--target', default='auto', + help='X-Instance-Id реплики для TARGET_INSTANCE_ID; auto = первая наблюдённая') + p.add_argument('--label', default='') + p.add_argument('--output', default=None) + args = arguments('Load during API replica failure; creates synthetic data', configure) + c = Client(args.base_url, args.ca_file, timeout=5) + alice, bob, _eve, chat = c.bootstrap() + + observed = {} + for _ in range(40): + inst = c.call('GET', '/api/v1/users/me', actor=alice)['headers']['X-Instance-Id'] + observed[inst] = observed.get(inst, 0) + 1 + target = args.target if args.target != 'auto' else sorted(observed)[0] + check(len(observed) >= 2, 'less than two replicas observed before the experiment') + + events = [] # (t, op, ok, latency, instance) + confirmed = [] + lock = threading.Lock() + start = time.monotonic() + started_wall = time.time() + stop_at = start + args.duration + + def record(op, ok, latency, instance): + with lock: + events.append((time.monotonic() - start, op, ok, latency, instance)) + + def worker(wid): + local = Client(args.base_url, args.ca_file, timeout=3) + n = 0 + key, text = uuid.uuid4().hex, None + while time.monotonic() < stop_at: + if text is None: + text = 'fo-%s-%d-%d' % (args.label or 'x', wid, n) + t0 = time.monotonic() + try: + if n % 2 == 0: + r = local.message(alice, chat, text, key=key) + record('write', True, time.monotonic() - t0, r['headers']['X-Instance-Id']) + with lock: + confirmed.append(r['json']) + key, text = uuid.uuid4().hex, None # следующий запрос — новое сообщение + else: + r = local.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=20', actor=bob) + record('read', True, time.monotonic() - t0, r['headers']['X-Instance-Id']) + n += 1 + except Failure: + # Неопределённый результат: повторяем ТОТ ЖЕ key+text (запись) после паузы. + record('write' if n % 2 == 0 else 'read', False, time.monotonic() - t0, None) + if n % 2 == 1: + n += 1 + time.sleep(0.05) + + action = {} + + def run_action(): + if not args.action_script: + return + time.sleep(args.action_after) + env = dict(os.environ, TARGET_INSTANCE_ID=target) + action['start'] = time.monotonic() - start + proc = subprocess.run([args.action_script], env=env, capture_output=True, text=True) + action['end'] = time.monotonic() - start + action['exit_code'] = proc.returncode + action['stdout_tail'] = proc.stdout.strip().splitlines()[-6:] + + with ThreadPoolExecutor(max_workers=args.concurrency + 1) as pool: + futures = [pool.submit(worker, i) for i in range(args.concurrency)] + act = pool.submit(run_action) + for f in futures + [act]: + f.result() + elapsed = time.monotonic() - start + check(action.get('exit_code', 0) == 0, 'action script failed: %s' % action.get('stdout_tail')) + + a0 = action.get('start', elapsed) + a1 = action.get('end', a0) + + def phase(lo, hi): + ev = [e for e in events if lo <= e[0] < hi] + ok = [e for e in ev if e[2]] + dur = max(hi - lo, 1e-9) + return {'seconds': round(dur, 2), 'successful_rps': round(len(ok) / dur, 1), + 'errors': len(ev) - len(ok), 'error_ratio': round((len(ev) - len(ok)) / len(ev), 4) if ev else None, + 'p50_ms': pct([e[3] for e in ok], .5), 'p95_ms': pct([e[3] for e in ok], .95), + 'p99_ms': pct([e[3] for e in ok], .99)} + + errors = [e for e in events if not e[2]] + writes_ok = sorted(e[0] for e in events if e[1] == 'write' and e[2]) + gaps = [b - a for a, b in zip(writes_ok, writes_ok[1:]) if b >= a0 - 1] + from_target_after = [e[0] for e in events if e[2] and e[4] == target and e[0] >= a0] + per_second = [] + for s in range(int(math.ceil(elapsed))): + ev = [e for e in events if s <= e[0] < s + 1] + per_second.append({'t': s, 'ok': sum(1 for e in ev if e[2]), 'err': sum(1 for e in ev if not e[2])}) + instances_after = {} + for e in events: + if e[2] and e[0] >= a1: + instances_after[e[4]] = instances_after.get(e[4], 0) + 1 + + # Сохранность: каждое подтверждённое сообщение есть в истории, дублей текстов нет. + msgs = history(c, bob, chat) + ids = [m['id'] for m in msgs] + texts = [m['text'] for m in msgs] + check(len(ids) == len(set(ids)), 'duplicate message ids') + check(len(texts) == len(set(texts)), 'retry with the same key created a duplicate message') + by_id = {m['id']: m for m in msgs} + lost = [m for m in confirmed if by_id.get(m['id']) != m] + check(not lost, '%d confirmed messages lost/changed' % len(lost)) + + report = { + 'label': args.label, 'action_script': args.action_script, 'target_instance': target, + 'replicas_observed_before': len(observed), 'concurrency': args.concurrency, + 'workload': 'closed loop, 50% POST message (retry same key on failure) / 50% GET history, timeout 3 s', + 'started_at_utc': time.strftime('%H:%M:%S', time.gmtime(started_wall)), + 'duration_seconds': round(elapsed, 2), + 'action_window_seconds': [round(a0, 2), round(a1, 2)], 'action_stdout': action.get('stdout_tail'), + 'before': phase(0, a0), 'during_action': phase(a0, a1), 'after_action': phase(a1, elapsed), + 'total_errors': len(errors), + 'last_error_after_action_start_s': round(max(e[0] for e in errors) - a0, 2) if errors else 0.0, + 'max_gap_between_successful_writes_s': round(max(gaps), 3) if gaps else None, + 'target_last_served_after_action_start_s': round(max(from_target_after) - a0, 2) if from_target_after else None, + 'instances_after_action': instances_after, + 'confirmed_writes': len(confirmed), 'lost_confirmed': 0, 'duplicates': 0, + 'per_second': per_second, + } + out = json.dumps(report, ensure_ascii=False, indent=2) + if args.output: + Path(args.output).write_text(out + '\n', encoding='utf-8') + brief = {k: report[k] for k in ('label', 'target_instance', 'before', 'during_action', 'after_action', + 'total_errors', 'last_error_after_action_start_s', + 'max_gap_between_successful_writes_s', 'target_last_served_after_action_start_s', + 'instances_after_action', 'confirmed_writes')} + print(json.dumps(brief, ensure_ascii=False)) + print('PASS: no confirmed message lost, no duplicates') + + +if __name__ == '__main__': + run(main) diff --git a/student-tests/idempotency_concurrency.py b/student-tests/idempotency_concurrency.py new file mode 100644 index 00000000..1c4cb959 --- /dev/null +++ b/student-tests/idempotency_concurrency.py @@ -0,0 +1,78 @@ +#!/usr/bin/env python3 +"""Конкурентная идемпотентность через LB: N параллельных POST с ОДНИМ Idempotency-Key. + +Ожидание: все ответы 201 с одним и тем же Message; запросы обслужили >= 2 разные реплики; +в истории ровно одно сообщение. Затем тот же ключ с другим телом -> 409, а одинаковый ключ +у другого пользователя/чата независим. Повторяется --rounds раз с новыми ключами. +""" +from concurrent.futures import ThreadPoolExecutor +import json +from pathlib import Path +import sys +import threading +import uuid + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +from client import Client, Failure, arguments, check, run # noqa: E402 + + +def history(c, actor, chat): + return c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100', actor=actor, + schema='MessagePage')['json']['items'] + + +def main(): + def configure(p): + p.add_argument('--parallel', type=int, default=16) + p.add_argument('--rounds', type=int, default=10) + p.add_argument('--output', default=None) + args = arguments('Concurrent Idempotency-Key check through the load balancer', configure) + c = Client(args.base_url, args.ca_file) + alice, bob, _eve, chat = c.bootstrap() + other_chat = c.call('POST', '/api/v1/chats', 201, actor=alice, + body={'title': 'Второй чат', 'member_ids': [alice['id']]}, schema='Chat')['json'] + rounds = [] + for r in range(args.rounds): + key = 'race-' + uuid.uuid4().hex + text = 'Гонка %d %s' % (r, key) + barrier = threading.Barrier(args.parallel) + + def send(_): + local = Client(args.base_url, args.ca_file) + barrier.wait() + resp = local.message(alice, chat, text, key=key) + return resp['json'], resp['headers']['X-Instance-Id'], resp['headers'].get('Idempotent-Replayed') + + with ThreadPoolExecutor(max_workers=args.parallel) as pool: + results = list(pool.map(send, range(args.parallel))) + ids = {msg['id'] for msg, _, _ in results} + instances = {inst for _, inst, _ in results} + replays = sum(1 for _, _, rep in results if rep == 'true') + check(len(ids) == 1, 'round %d: concurrent requests created %d different messages' % (r, len(ids))) + check(all(msg == results[0][0] for msg, _, _ in results), 'round %d: responses differ' % r) + check(replays == args.parallel - 1, 'round %d: expected exactly one original response' % r) + same_text = [m for m in history(c, bob, chat) if m['text'] == text] + check(len(same_text) == 1, 'round %d: history has %d copies' % (r, len(same_text))) + # Тот же ключ с другим телом — конфликт; тот же ключ у Боба и в другом чате — независимы. + c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 409, actor=alice, + body={'text': 'другое тело'}, headers={'Idempotency-Key': key}) + bob_msg = c.message(bob, chat, text, key=key)['json'] + check(bob_msg['id'] not in ids and bob_msg['sender_id'] == bob['id'], 'key scope must include user') + other = c.message(alice, other_chat, text, key=key)['json'] + check(other['id'] not in ids, 'key scope must include chat') + rounds.append({'round': r, 'parallel': args.parallel, 'distinct_messages': len(ids), + 'instances': len(instances), 'replayed_responses': replays}) + multi = sum(1 for x in rounds if x['instances'] >= 2) + check(multi > 0, 'concurrent requests never reached two replicas; check LB') + report = {'test': 'concurrent idempotency through LB', 'parallel_requests_per_round': args.parallel, + 'rounds': args.rounds, 'rounds_spanning_two_or_more_replicas': multi, + 'duplicates_created': 0, 'per_round': rounds} + text = json.dumps(report, ensure_ascii=False, indent=2) + if args.output: + Path(args.output).write_text(text + '\n', encoding='utf-8') + print(text) + print('PASS: %d rounds × %d parallel requests with one key -> exactly one message each' % (args.rounds, args.parallel)) + + +if __name__ == '__main__': + run(main) diff --git a/student-tests/run-failover-series.sh b/student-tests/run-failover-series.sh new file mode 100644 index 00000000..fdf48642 --- /dev/null +++ b/student-tests/run-failover-series.sh @@ -0,0 +1,27 @@ +#!/bin/sh +# Уровень 4: поочерёдно останавливает КАЖДУЮ API-реплику под нагрузкой (восстанавливая +# предыдущую), затем то же для жёсткого отказа (SIGKILL). Результаты: evidence/failover-*.json. +# Запуск (Windows/Linux): docker compose --profile tools run --rm tester sh student-tests/run-failover-series.sh +set -eu +cd "$(dirname "$0")/.." +. scripts/lib.sh +DURATION="${DURATION:-30}" +CONCURRENCY="${CONCURRENCY:-4}" +mkdir -p evidence +sh scripts/start-api.sh +ids=$(service_ids api) +for mode in stop kill; do + i=0 + for id in $ids; do + i=$((i + 1)) + echo "=== $mode replica $i: $(short "$id") ===" + docker ps --filter "label=com.docker.compose.project=$PROJECT" --format '{{.Names}} {{.ID}} {{.Status}}' | sort + python3 student-tests/failover_load.py --duration "$DURATION" --concurrency "$CONCURRENCY" \ + --action-after 8 --action-script "scripts/$mode-one.sh" --target "$(short "$id")" \ + --label "$mode-$i" --output "evidence/failover-$mode-$i.json" + echo "--- containers after action:" + docker ps -a --filter "label=com.docker.compose.project=$PROJECT" --filter "label=com.docker.compose.service=api" \ + --format '{{.Names}} {{.ID}} {{.Status}}' | sort + sh scripts/start-api.sh + done +done