This commit is contained in:
2026-10-13 19:11:11 +03:00
parent 0ab3a341aa
commit 4d877e0120
55 changed files with 4879 additions and 51 deletions
+8
View File
@@ -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
+2
View File
@@ -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
+9 -9
View File
@@ -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, минимальные привилегии |
## Как оценивать
+24
View File
@@ -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"]
-8
View File
@@ -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.
+229 -23
View File
@@ -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:<APP_VERSION>` (сборка из `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.
View File
+179
View File
@@ -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:<sha256(token)>, 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)
+112
View File
@@ -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()
+57
View File
@@ -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
+61
View File
@@ -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
+107
View File
@@ -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,
)
+6
View File
@@ -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()
+356
View File
@@ -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,
)
+149
View File
@@ -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
+446
View File
@@ -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()]
+162
View File
@@ -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
+70
View File
@@ -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()
+415
View File
@@ -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,
}
-11
View File
@@ -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: {}
+182
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
host: 14 CPU, 7965708288 bytes RAM, Docker Desktop, docker 29.3.0
+211
View File
@@ -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
}
]
}
+211
View File
@@ -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
}
]
}
+59
View File
@@ -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
+211
View File
@@ -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
}
]
}
+211
View File
@@ -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
}
]
}
+79
View File
@@ -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
}
]
}
+6
View File
@@ -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
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.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."
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.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."
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.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."
}
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.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."
}
+17
View File
@@ -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
+43
View File
@@ -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
+407
View File
@@ -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
}
]
}
+2
View File
@@ -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
+18
View File
@@ -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)
+96
View File
@@ -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
+48
View File
@@ -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()
);
+12
View File
@@ -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;
+18
View File
@@ -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);
+7
View File
@@ -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
+36
View File
@@ -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"
+18
View File
@@ -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
+33
View File
@@ -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; }
+99
View File
@@ -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())
+19
View File
@@ -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' ' ')"
+40
View File
@@ -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"
+15
View File
@@ -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 ' ')"
+21
View File
@@ -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)"
+6
View File
@@ -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
+188
View File
@@ -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)
+78
View File
@@ -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)
+27
View File
@@ -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