ЛР3 - Максимова Мария - БВТ2303 - на 4 #24
+5
-1
@@ -7,7 +7,11 @@ SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
SESSION_STORE=valkey
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
# Public LB port on the host. If 8080 is busy, set e.g. 8081 and run make test with BASE_URL=http://localhost:8081
|
||||
LB_PORT=8080
|
||||
# Image tag of the api/migrate services (scripts/rolling-update.sh switches it)
|
||||
APP_VERSION=dev
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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.
|
||||
+9
-9
@@ -13,15 +13,15 @@
|
||||
|
||||
## Что проверять
|
||||
|
||||
| Проверка | Что подтверждает | Чего не подтверждает |
|
||||
| --- | --- | --- |
|
||||
| make check | Структура файлов, JSON, локальные refs, синтаксис Python | Реализация/запуск API |
|
||||
| make validate | Полная OpenAPI 3.1, JSON Schema и примеры | Поведение сервера |
|
||||
| make test | Один сквозной контрактный сценарий текущей лабы | Все ошибки, persistence, HA, security |
|
||||
| test-persistence (lab2+) | Данные/прежний токен после вызова restart hook | Реальный перезапуск, если hook — no-op |
|
||||
| test-failover (lab3+) | Смена обслуживающей реплики, сохранность, retry без дубля | Несколько физических узлов, HA DB/LB |
|
||||
| test-security (lab7) | Доверенный HTTPS и отказ недоверенного CA | Внутреннее mTLS/identity/ACL/OpenBao |
|
||||
| Защита и тесты студента | Реальность инфраструктуры и критерии выбранного уровня | Неограниченная промышленная безопасность |
|
||||
| Проверка | Что подтверждает | Чего не подтверждает |
|
||||
|--------------------------|-----------------------------------------------------------|------------------------------------------|
|
||||
| make check | Структура файлов, JSON, локальные refs, синтаксис Python | Реализация/запуск API |
|
||||
| make validate | Полная OpenAPI 3.1, JSON Schema и примеры | Поведение сервера |
|
||||
| make test | Один сквозной контрактный сценарий текущей лабы | Все ошибки, persistence, HA, security |
|
||||
| test-persistence (lab2+) | Данные/прежний токен после вызова restart hook | Реальный перезапуск, если hook — no-op |
|
||||
| test-failover (lab3+) | Смена обслуживающей реплики, сохранность, retry без дубля | Несколько физических узлов, HA DB/LB |
|
||||
| test-security (lab7) | Доверенный HTTPS и отказ недоверенного CA | Внутреннее mTLS/identity/ACL/OpenBao |
|
||||
| Защита и тесты студента | Реальность инфраструктуры и критерии выбранного уровня | Неограниченная промышленная безопасность |
|
||||
|
||||
Проверяйте реальные контейнеры/логи процессов и данные до/после отказа: одного X-Instance-Id недостаточно. Для 4 требуются все пункты 3+4, для 5 — все пункты 3+4 и один **завершённый** трек 5. Сравнивайте подтверждённые результаты со сформулированными критериями, а не количество установленных сервисов.
|
||||
|
||||
|
||||
@@ -1,37 +1,459 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
Балансировка и отказ API-реплики
|
||||
|
||||
## Запуск из чистого clone
|
||||
- Автор, группа: Максимова Мария, БВТ2303
|
||||
- Целевая оценка: 4
|
||||
- Commit/PR: ветка `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/`), все команды раздела 3 повторно проверены 2026-10-20.
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
## 1. Коротко и простыми словами
|
||||
|
||||
## Архитектура и решения
|
||||
Раньше (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 вместе с сообщением. Если пришёл тот же ключ ещё раз, сервер не создаёт новое сообщение, а возвращает уже сохранённое.
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
| Что | Результат |
|
||||
|------------------------------------------------------------|-------------------------------------------------------------------|
|
||||
| Публичные тесты `make check`, `make validate`, `make test` | PASS |
|
||||
| Запросы одного пользователя обслуживают разные реплики | да, `X-Instance-Id` чередуется, повторный вход не нужен |
|
||||
| Остановка каждой реплики (`make test-failover`) | PASS для обеих, 0 ошибок, запись снова работает через 4.3–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.1 О чём лаба?
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
В прошлой лабе у меня был один сервер API. Если он падал — падал весь мессенджер.
|
||||
В этой лабе я запустила два одинаковых сервера API (реплики), а перед ними поставила балансировщик HAProxy.
|
||||
Пользователь всегда отправляет запросы на один адрес. HAProxy по очереди отдаёт их то первой реплике, то второй.
|
||||
Если одна реплика ломается, HAProxy это замечает и отправляет всё на вторую — пользователь ничего не замечает.
|
||||
Чтобы это работало, реплики ничего не хранят у себя: все данные, сессии и ключи лежат в общей базе PostgreSQL. Поэтому неважно, какая реплика ответила.
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Какая реплика ответила — видно по заголовку `X-Instance-Id` (это имя контейнера).
|
||||
|
||||
Схема: Клиент → HAProxy (:8080) → api × 2 → PostgreSQL + Valkey.
|
||||
|
||||
### 1.2 Как сделана отказоустойчивость?
|
||||
|
||||
1. Балансировка round-robin. В конфиге HAProxy `balance roundrobin` — запросы раздаются по кругу: 1-й на первую реплику, 2-й на вторую, 3-й снова на первую. Это встроенный алгоритм HAProxy. Sticky session (привязки клиента к одной реплике) нет — она не нужна, потому что всё состояние общее.
|
||||
2. Проверка здоровья (health check). HAProxy каждую секунду сам спрашивает у каждой реплики `/health/ready` — «ты готова?». 2 неудачи подряд — реплика считается мёртвой, запросы ей больше не идут. 2 успеха подряд — возвращается обратно. В конфиге это `inter 1s fall 2 rise 2`.
|
||||
3. Повтор на другую реплику. Если запрос не дошёл до реплики (она упала), HAProxy сам повторяет его на другой реплике (`retries 2`, `option redispatch`, `retry-on`). Пользователь ошибки не видит. Повтор уже отправленного запроса разрешён только для GET и для отправки сообщения с `Idempotency-Key` — чтобы не создать дубль.
|
||||
4. Реплики находятся сами через DNS Docker. IP-адреса не прописаны вручную. HAProxy спрашивает у DNS Docker «какие адреса у сервиса `api`?» и получает адреса всех живых реплик (`server-template api 8 api:8080` + `resolvers docker`). Новая реплика попадает в пул сама.
|
||||
5. Мягкое выключение (graceful shutdown). При остановке реплика не выключается сразу: 3 секунды продолжает работать, но на проверку здоровья отвечает «я не готова» (503). За это время HAProxy убирает её из пула, и только потом она закрывается. Поэтому при остановке реплики у пользователей 0 ошибок.
|
||||
|
||||
Итог с цифрами: остановка каждой реплики под нагрузкой — 0 ошибок; жёсткое убийство (`kill -9`) — 1 ошибка на ~11 600 запросов; сообщения не потерялись и не задвоились.
|
||||
|
||||
Время обнаружения отказа: упавшая реплика — на первом же запросе (или ≤ 2 s по проверкам); «жива, но не готова» — ≤ 3 s; зависла — ≈ 4 s.
|
||||
|
||||
### 1.3 Почему HAProxy, а не nginx? Какие альтернативы?
|
||||
|
||||
Я выбрала HAProxy, потому что это специализированный балансировщик, и бесплатно в нём есть:
|
||||
1. Активная проверка здоровья — он сам опрашивает реплики. В бесплатном nginx такой проверки нет (только в платном NGINX Plus), есть только пассивная — по ошибкам реальных запросов.
|
||||
2. Сам находит новые реплики через DNS Docker. Бесплатный nginx узнаёт адреса один раз при запуске и после пересоздания контейнера продолжает слать запросы на старый адрес.
|
||||
3. Гибкая настройка повторов (какие запросы можно повторять, какие нельзя).
|
||||
4. Страница статистики `/stats` — видно, какая реплика живая (UP), а какая нет (DOWN).
|
||||
|
||||
Альтернативы:
|
||||
|
||||
| Что | Что это |
|
||||
|---------------------------|---------------------------------------------------------------------------------|
|
||||
| Nginx | веб-сервер, который тоже умеет балансировать (round-robin, least_conn, ip_hash) |
|
||||
| Traefik | сам находит контейнеры в Docker/Kubernetes по меткам |
|
||||
| Envoy | мощный современный прокси, на нём работает Istio |
|
||||
| Caddy | простой конфиг, сам делает HTTPS |
|
||||
| Docker Swarm / Kubernetes | встроенная балансировка оркестратора |
|
||||
| Облачные | AWS ALB/NLB, Yandex Application Load Balancer |
|
||||
|
||||
Другие алгоритмы балансировки: `leastconn` (на сервер с наименьшим числом соединений), `source` (по IP клиента — фактически sticky), `random`, веса `weight`.
|
||||
|
||||
### 1.4 Что такое Idempotency-Key?
|
||||
|
||||
Пользователь отправил сообщение, реплика упала, ответа нет. Он не знает, сохранилось ли сообщение, и отправляет ещё раз. Без защиты будет два одинаковых сообщения.
|
||||
Поэтому клиент шлёт заголовок `Idempotency-Key` — уникальную строку на каждое сообщение.
|
||||
Сервер сохраняет ключ в базе вместе с сообщением, в одной транзакции.
|
||||
Пришёл тот же ключ ещё раз — сервер не создаёт новое, а возвращает старое сообщение (заголовок `Idempotent-Replayed: true`).
|
||||
Тот же ключ, но другой текст — ошибка 409.
|
||||
Ключ хранится в общей базе, поэтому защита работает, даже если повтор пришёл на другую реплику. Если два одинаковых запроса пришли одновременно на разные реплики, второй ждёт в PostgreSQL (на уникальном ключе), пока первый закончит.
|
||||
Проверено: 16 одновременных запросов с одним ключом — каждый раз ровно 1 сообщение.
|
||||
|
||||
### 1.5 Вопросы-ответы
|
||||
|
||||
Чем отказ процесса отличается от отказа узла?
|
||||
Процесс — одна программа (у меня один контейнер API). Упал — вторая реплика работает.
|
||||
Узел — целый компьютер: выключился — выключилось всё. У меня всё на одном компьютере, поэтому отказ узла стенд не переживёт (для этого нужны несколько машин и копия базы).
|
||||
|
||||
Почему `depends_on` и healthcheck — не балансировщик?
|
||||
`depends_on` задаёт только порядок запуска (сначала база, потом API). Healthcheck только ставит метку healthy/unhealthy. Ни то, ни другое не принимает запросы, не распределяет их и не переключает на живую реплику. Это делает только балансировщик.
|
||||
|
||||
Какие POST можно повторять после timeout?
|
||||
Только те, повтор которых не создаст дубль: у меня это отправка сообщения с `Idempotency-Key`. Создание пользователя, чата, входа — повторять нельзя, создастся второй объект. (Если запрос даже не дошёл до сервера — ошибка соединения, — повторять можно любой.)
|
||||
|
||||
Что сломается, если сессии хранить в памяти реплики?
|
||||
Вошёл через первую реплику — сессия есть только у неё. Следующий запрос уйдёт на вторую — она пользователя не знает → 401, «выкинет». Выход на одной реплике не сработает на другой. При перезапуске реплики все её сессии пропадут. Поэтому сессии у меня в общей базе.
|
||||
|
||||
- Миграции — выполняет отдельный контейнер `migrate` один раз перед запуском API, чтобы реплики не делали это одновременно.
|
||||
- Почему у `api` нет `ports` — чтобы к репликам нельзя было обратиться в обход балансировщика.
|
||||
- Почему нет `container_name` — имя контейнера должно быть уникальным, с ним нельзя запустить 2 копии.
|
||||
- Rolling update — по очереди заменяю старые реплики новыми: запускаю новую, жду, пока она здорова, потом останавливаю старую. Получилось 0 ошибок.
|
||||
- `docker stop` и `docker kill` — `stop` шлёт SIGTERM, и приложение успевает аккуратно закрыться; `kill -9` (SIGKILL) убивает мгновенно, начатые запросы обрываются.
|
||||
- Почему был важен Dockerfile — в lab2 был `CMD ["sh","-c","uvicorn …"]`: главным процессом был `sh`, он не передавал SIGTERM, и мягкое выключение не работало. Стало `CMD ["python","-m","app.server"]`.
|
||||
- Слабые места (SPOF) — балансировщик один, база одна, компьютер один. Как исправить: два HAProxy + keepalived (общий IP), репликация PostgreSQL (Patroni), несколько узлов.
|
||||
- Почему `X-Instance-Id` — не доказательство — заголовок пишет само приложение; поэтому после остановки показываю `docker ps -a`: у нужного контейнера статус `Exited`.
|
||||
|
||||
### 1.6 Защита
|
||||
|
||||
1. Поднять стенд, `docker compose ps` — 2 контейнера `api`.
|
||||
2. Показать, что `X-Instance-Id` чередуется (раздел 3.4).
|
||||
3. `make test-failover` → `docker ps -a` (остановлен реальный контейнер) → `start-api.sh` → то же для второй реплики.
|
||||
4. `make test-persistence`.
|
||||
5. Для «4»: тест идемпотентности, серия отказов, страница `http://127.0.0.1:8404/stats`, результаты rolling update.
|
||||
|
||||
## 2. Что сделано
|
||||
|
||||
Из lab2 перенесены `app/`, миграции 001–002, `scripts/migrate.py`, `scripts/init-secrets.sh`, `requirements.txt`. Новое в lab3:
|
||||
|
||||
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` (поочерёдная замена реплик).
|
||||
9. Argon2 (хеширование пароля, ~0.5–1 s CPU) выполняется в отдельном потоке (`asyncio.to_thread`), чтобы регистрация/вход не блокировали event loop и `/health/ready` реплики продолжал отвечать.
|
||||
|
||||
Исправления в коде 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`.
|
||||
|
||||
Исправления по замечаниям ревью:
|
||||
|
||||
- `POST /auth/sessions` принимает только `Authorization: Basic` без тела (`contracts/README.md`). Раньше тело игнорировалось: `{bad` или `{}` с действительным Basic давали `201`. Теперь любое непустое тело → `400 invalid_request` до проверки пароля (`app/main.py`, `login`). Без тела (в т.ч. с `Content-Type: application/json`) — по-прежнему `201`.
|
||||
- `CreateChat.member_ids`: добавлен максимум 100 элементов, как `maxItems: 100` в `contracts/openapi.json` (`app/models.py`). 101 участник → `400 invalid_request`, ровно 100 → `201`.
|
||||
- Проверка обоих сценариев: `docker compose --profile tools run --rm tester python3 student-tests/contract_edge_cases.py` (6 проверок, `PASS: тело при входе и лимит участников соответствуют контракту`).
|
||||
- Проверено 2026-10-20 на пересобранном стенде: оба сценария ревью, `make check`/`validate`/`test` — PASS, `make test-failover` — PASS (`failed_attempts: 0`), идемпотентность — PASS.
|
||||
|
||||
## 3. Все команды
|
||||
|
||||
Все образы закреплены версиями:
|
||||
|
||||
| Роль | Service | Образ | Health/readiness | Volume | Сеть / порт | Секреты |
|
||||
|------------|----------------------------|--------------------------------------------------------------------------------------------|-----------------------------------------------|-----------------|------------------------------------------------------------|------------------------------------|
|
||||
| LB | `lb` | `haproxy:3.0.11-alpine` | `wget /lb-health` (:8404) | — | `edge`; `LB_PORT` (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 к ней не подключён. Наружу опубликован только порт балансировщика.
|
||||
|
||||
Команды ниже — для Windows PowerShell (мой стенд). Отличия для Linux/macOS — в разделе 3.8.
|
||||
|
||||
### 3.1 Что нужно установить
|
||||
|
||||
- Docker Desktop (Compose v2);
|
||||
- Git for Windows — даёт команду `sh` для скриптов `*.sh`;
|
||||
- make: `winget install ezwinports.make`;
|
||||
- Python 3.11 или 3.12 (на 3.14 не ставятся закреплённые `pydantic-core`/`asyncpg` — для них нет готовых wheel).
|
||||
|
||||
### 3.2 Первый запуск из чистого clone
|
||||
|
||||
```powershell
|
||||
git clone https://gitea.privcloud.tech/Mariia_Maksimova/mtusi2026lab3.git
|
||||
cd mtusi2026lab3
|
||||
git checkout solution/maksimova_bvt2303
|
||||
|
||||
# Секреты: создаются один раз в infra/secrets/, в Git не попадают, значения не печатаются
|
||||
sh scripts/init-secrets.sh
|
||||
|
||||
# Параметры стенда (секретов не содержит)
|
||||
Copy-Item .env.example .env
|
||||
# Если порт 8080 занят (у меня его держит служба Windows AgentService.exe) —
|
||||
# в .env поставить LB_PORT=8081
|
||||
|
||||
# Проверка конфигурации, сборка, миграции (сервис migrate) и запуск;
|
||||
# --wait ждёт, пока все сервисы станут healthy
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
docker compose ps
|
||||
```
|
||||
|
||||
В `docker compose ps` должно быть: `api` ×2, `db`, `valkey`, `lb` — `healthy`; `migrate` — `Exited (0)`.
|
||||
|
||||
### 3.3 Настройка окна PowerShell для проверок
|
||||
|
||||
```powershell
|
||||
# Один раз: виртуальное окружение (нужно для make validate; make check/test используют только stdlib)
|
||||
py -3.11 -m venv .venv
|
||||
.venv/Scripts/python.exe -m pip install -r requirements-dev.txt
|
||||
|
||||
# В КАЖДОМ новом окне PowerShell — до любых make (без этого будет "Error 9009")
|
||||
$env:PYTHONUTF8 = "1" # иначе Python читает openapi.json в cp1251 -> UnicodeDecodeError
|
||||
$env:PYTHON = ".venv/Scripts/python.exe" # в Windows нет python3, который Makefile вызывает по умолчанию
|
||||
$env:BASE_URL = "http://localhost:8080" # или http://localhost:8081, если в .env LB_PORT=8081
|
||||
```
|
||||
|
||||
Makefile берёт `PYTHON` и `BASE_URL` из окружения (`PYTHON ?= python3`, `BASE_URL ?= http://localhost:8080`), поэтому после этих трёх строк `make check`/`validate`/`test` запускаются без дополнительных параметров. На контейнер `tester` эти переменные не влияют: у него свои `BASE_URL=http://lb:8080` и `python3`.
|
||||
|
||||
### 3.4 Проверки уровня 3
|
||||
|
||||
```powershell
|
||||
# Публичные проверки с хоста
|
||||
make check
|
||||
make validate
|
||||
make test
|
||||
|
||||
# Разные реплики через один LB: X-Instance-Id чередуется
|
||||
1..4 | ForEach-Object { curl.exe -s -D - -o NUL "$env:BASE_URL/health/live" | findstr /i "x-instance-id" }
|
||||
|
||||
# Отказ реплики №1: тест сам выбирает реплику и вызывает scripts/stop-one.sh
|
||||
docker compose --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
|
||||
# Доказательство: какой контейнер реально остановлен (Exited (0))
|
||||
docker ps -a --filter "label=com.docker.compose.project=messenger-lab3" --filter "label=com.docker.compose.service=api" --format "table {{.Names}}\t{{.ID}}\t{{.Status}}"
|
||||
|
||||
# Вернуть остановленную реплику
|
||||
docker compose --profile tools run --rm tester sh scripts/start-api.sh
|
||||
|
||||
# Отказ реплики №2: один лишний запрос сдвигает round-robin, тест выберет другую реплику
|
||||
curl.exe -s -o NUL "$env:BASE_URL/health/live"
|
||||
docker compose --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||||
docker ps -a --filter "label=com.docker.compose.project=messenger-lab3" --filter "label=com.docker.compose.service=api" --format "table {{.Names}}\t{{.ID}}\t{{.Status}}"
|
||||
docker compose --profile tools run --rm tester sh scripts/start-api.sh
|
||||
|
||||
# Перезапуск всего стенда с сохранением volume и прежнего токена
|
||||
docker compose --profile tools run --rm tester make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||||
```
|
||||
|
||||
Почему failover/persistence запускаются в контейнере `tester`: публичный тест вызывает `.sh`-скрипт через `subprocess.Popen`, а Windows не умеет исполнять `.sh` напрямую. В `tester` есть Python, make и docker CLI, а `BASE_URL = http://lb:8080` — тот же балансировщик, только изнутри Docker-сети (поэтому `LB_PORT` хоста здесь не важен). Сами тесты не менялись.
|
||||
|
||||
### 3.5 Проверки уровня 4
|
||||
|
||||
```powershell
|
||||
# Идемпотентность: 10 раундов × 16 одновременных POST с одним ключом -> ровно 1 сообщение
|
||||
docker compose --profile tools run --rm tester python3 student-tests/idempotency_concurrency.py --output evidence/idempotency-concurrency.json
|
||||
|
||||
# Серия отказов под нагрузкой: stop и kill каждой реплики по очереди, с восстановлением
|
||||
# (результаты: evidence/failover-stop-*.json, evidence/failover-kill-*.json)
|
||||
docker compose --profile tools run --rm tester sh student-tests/run-failover-series.sh
|
||||
|
||||
# Жёсткий отказ одной реплики вручную (ID взять из docker ps), потом вернуть
|
||||
docker compose --profile tools run --rm -e TARGET_INSTANCE_ID=<12 символов ID> tester sh scripts/kill-one.sh
|
||||
docker compose --profile tools run --rm tester sh scripts/start-api.sh
|
||||
|
||||
|
||||
# Нагрузка (справочно) и потребление ресурсов
|
||||
docker compose --profile tools run --rm tester make load
|
||||
docker stats --no-stream
|
||||
```
|
||||
|
||||
Rolling update под нагрузкой — два окна PowerShell:
|
||||
|
||||
```powershell
|
||||
# Окно 1: нагрузка 70 s
|
||||
docker compose --profile tools run --rm tester python3 student-tests/failover_load.py --duration 70 --label rolling-update --output evidence/rolling-update-load.json
|
||||
|
||||
# Окно 2 (сразу после старта нагрузки): сборка новой версии, миграции один раз, поочерёдная замена реплик
|
||||
$env:APP_VERSION = "v3"
|
||||
sh scripts/rolling-update.sh
|
||||
```
|
||||
|
||||
После rolling update реплики работают на образе `messenger-lab3-api:v3`. Все дальнейшие `docker compose up` нужно выполнять с тем же `APP_VERSION` (`$env:APP_VERSION = "v3"` или строка `APP_VERSION=v3` в `.env`), иначе Compose пересоздаст реплики на образе `dev`.
|
||||
|
||||
### 3.6 Наблюдение и логи
|
||||
|
||||
```powershell
|
||||
# Состояние реплик в LB (UP/DOWN, счётчики ошибок и повторов) — открыть в браузере:
|
||||
# http://127.0.0.1:8404/stats
|
||||
docker compose logs lb --tail 30 # строки "Server api/apiN is DOWN/UP"
|
||||
docker compose logs api --tail 30 # "draining for 3.0 s", "drain finished: closing listener"
|
||||
docker compose ps
|
||||
```
|
||||
|
||||
### 3.7 Остановка стенда
|
||||
|
||||
```powershell
|
||||
docker compose down # безопасно: данные остаются в volume postgres_data
|
||||
docker compose down -v # ОСТОРОЖНО: удаляет volume с базой
|
||||
```
|
||||
|
||||
### 3.8 Linux/macOS
|
||||
|
||||
Всё то же, но: `cp .env.example .env`; `python3 -m venv .venv && .venv/bin/python -m pip install -r requirements-dev.txt`; `export PYTHON=.venv/bin/python` (или по умолчанию `python3`); `PYTHONUTF8` не нужен; `curl -s -D - -o /dev/null "$BASE_URL/health/live" | grep -i x-instance-id`. Failover/persistence можно запускать прямо с хоста: `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. Rolling update: `APP_VERSION=v3 sh scripts/rolling-update.sh`.
|
||||
|
||||
### 3.9 Частые ошибки
|
||||
|
||||
| Ошибка | Причина | Что сделать |
|
||||
|-----------------------------------------------------------------------------------|----------------------------------------------------------------|------------------------------------------------------------------------------------|
|
||||
| `Python make: *** [Makefile:13: check] Error 9009` (то же для `validate`, `test`) | в Windows нет команды `python3`; не задан `$env:PYTHON` | `$env:PYTHON = ".venv/Scripts/python.exe"` (раздел 3.3) |
|
||||
| `UnicodeDecodeError: 'charmap' codec …` | Python на Windows читает файлы в cp1251 | `$env:PYTHONUTF8 = "1"` |
|
||||
| `FAIL: GET /health/live: connection/TLS failure (TimeoutError)` | тест идёт на 8080, а LB на другом порту (или стенд не запущен) | `$env:BASE_URL = "http://localhost:8081"` (порт из `LB_PORT`); `docker compose ps` |
|
||||
| `Failed building wheel for pydantic-core` / `asyncpg` | venv на Python 3.14 | пересоздать: `@py -3.11 -m venv .venv` |
|
||||
| `secret ... file not found` при `up` | не созданы секреты | `sh scripts/init-secrets.sh` |
|
||||
| failover-тест на Windows с хоста не запускает `.sh` | Windows не исполняет `.sh` | запускать через `tester` (раздел 3.4) |
|
||||
|
||||
Переменные `.env.example` → реальная конфигурация:
|
||||
|
||||
| `.env.example` | Где используется |
|
||||
|---------------------------|------------------------------------------------------------------|
|
||||
| `LB_PORT` | публичный порт HAProxy на хосте (по умолчанию 8080) |
|
||||
| `APP_VERSION` | тег образа `api`/`migrate` (по умолчанию `dev`) |
|
||||
| `API_REPLICAS` | `deploy.replicas` сервиса `api` (по умолчанию 2) |
|
||||
| `SESSION_TTL_SECONDS` | `api` (по умолчанию 3600) |
|
||||
| `IDEMPOTENCY_TTL_SECONDS` | `api` (86400 = 24 ч) |
|
||||
| `APP_HOST`, `APP_PORT` | заданы в `compose.yaml` (0.0.0.0:8080 внутри контейнера) |
|
||||
| `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` |
|
||||
| `APP_ENV` | не используется приложением |
|
||||
|
||||
## 4. Архитектура и решения
|
||||
|
||||
```
|
||||
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 (кэш сессий)
|
||||
```
|
||||
|
||||
|
||||
1. `client ──HTTP:8080──► HAProxy` — клиент (пользователь, тест, curl) отправляет все запросы на один адрес: порт 8080. Там стоит HAProxy. Это единственная открытая наружу дверь, к репликам напрямую не попасть.
|
||||
|
||||
2. `──round-robin──► api-1, api-2` — HAProxy раздаёт запросы репликам по кругу: первый на api-1, второй на api-2, третий снова на api-1.
|
||||
|
||||
3. `проверка /health/ready раз в 1 s` — каждую секунду HAProxy спрашивает у каждой реплики «ты готова?». Если реплика 2 раза подряд не ответила «да», HAProxy перестаёт слать ей запросы.
|
||||
|
||||
4. `DNS Docker 127.0.0.11: имя "api" → IP всех реплик` — 127.0.0.11 — это адрес встроенного DNS-сервера Docker, он есть внутри каждого контейнера. HAProxy спрашивает у него: «какие адреса у имени `api`?» — и получает IP всех работающих реплик. Поэтому адреса не прописаны вручную, и новая реплика попадает в список сама (список обновляется каждые 2 секунды).
|
||||
|
||||
5. `X-Request-Id` — HAProxy даёт каждому запросу уникальный номер и передаёт его в API. Этот номер попадает в лог HAProxy, в лог реплики и в ответ. По нему можно найти один и тот же запрос во всех логах.
|
||||
|
||||
6. `повтор на другую реплику при отказе` — если реплика не ответила (упала), HAProxy сам отправляет тот же запрос на другую реплику. Пользователь ошибку не видит. Повторяются только безопасные запросы: GET и отправка сообщения с Idempotency-Key.
|
||||
|
||||
7. `...` под api-2 — реплик может быть больше двух. В конфиге заготовлено до 8 мест (`server-template api 8`).
|
||||
|
||||
8. `▼ сеть backend (internal)` — все реплики ходят в одну и ту же базу. Сеть `backend` внутренняя: из неё нет выхода наружу, и HAProxy к ней не подключён. До базы можно добраться только через API.
|
||||
|
||||
9. `PostgreSQL (источник истины)` — «источник истины» значит, что настоящие данные хранятся только здесь: пользователи, чаты, сообщения, сессии, ключи идемпотентности. Если где-то ещё есть копия, правильной считается та, что в PostgreSQL.
|
||||
|
||||
10. `Valkey (кэш сессий)` — Valkey (аналог Redis) хранит быструю копию «токен → пользователь», чтобы не ходить в базу на каждый запрос. Если Valkey пропадёт, ничего не сломается: данные возьмутся из PostgreSQL.
|
||||
|
||||
Коротко одной фразой: клиент ходит в один HAProxy, HAProxy по кругу раздаёт запросы живым репликам, а все реплики работают с одной общей базой — поэтому любая реплика может обработать любой запрос.
|
||||
|
||||
Источник истины — 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.
|
||||
|
||||
## 5. 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`.
|
||||
|
||||
## 6. Доказательства критериев
|
||||
|
||||
Прогоны с измерениями — 2026-10-13, 14:49–14:58 UTC, на стенде из раздела 7. Повторная проверка команд 2026-10-20: `make check`/`validate`/`test` — PASS; `make test-failover` — PASS (`observed_instances_before: 2`, `failed_attempts: 0`, `first_recovery_seconds: 4.262`, у остановленного контейнера `Exited (0)`); `make test-persistence` — PASS; идемпотентность — PASS.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
|
||||
|------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------|
|
||||
| Публичный smoke | `make test` (хост → LB) | `PASS: lab3 public API scenario` | `evidence/public-tests.txt` |
|
||||
| Структура контракта | `make check`, `make validate` | 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` реплики | раздел 5; реплика перестаёт получать запросы через 0.87–0.99 s после начала `docker stop`; выход с кодом 0 | раздел 5, `evidence/failover-stop-*.json` |
|
||||
| 4: поочерёдная остановка каждой реплики под нагрузкой: RPS, ошибки, время восстановления | `student-tests/run-failover-series.sh` (stop и kill для каждой реплики, с восстановлением предыдущей) | таблица в разделе 7; 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 нет секретов (таблица в разделе 3) | `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`, а остальные сервисы продолжают работать.
|
||||
|
||||
## 7. Эксперименты и отказы
|
||||
|
||||
Стенд. 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).
|
||||
|
||||
## 8. Ограничения и следующие шаги
|
||||
|
||||
- Выдерживается отказ одной 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).
|
||||
|
||||
+179
@@ -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
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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,
|
||||
)
|
||||
@@ -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()
|
||||
+362
@@ -0,0 +1,362 @@
|
||||
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,
|
||||
InvalidRequest,
|
||||
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),
|
||||
):
|
||||
# Contract: login takes only "Authorization: Basic", no request body.
|
||||
# Any body (malformed JSON, "{}", ...) is rejected before the password check.
|
||||
if await request.body():
|
||||
raise InvalidRequest("POST /auth/sessions does not accept a request body.")
|
||||
|
||||
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,
|
||||
)
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
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)
|
||||
# Contract: 1-100 members (minItems/maxItems in openapi.json).
|
||||
member_ids: list[UUID] = Field(min_length=1, max_length=100)
|
||||
|
||||
@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
|
||||
@@ -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
@@ -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
|
||||
@@ -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()
|
||||
+419
@@ -0,0 +1,419 @@
|
||||
"""Business rules for MTUSI Messenger Lab3."""
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
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]:
|
||||
# Argon2 is CPU-bound (~0.5-1 s); off the event loop so /health/ready keeps answering.
|
||||
password_hash = await asyncio.to_thread(hash_password, password)
|
||||
user = await repositories.create_user(
|
||||
db,
|
||||
username=username,
|
||||
display_name=display_name,
|
||||
password_hash=password_hash,
|
||||
)
|
||||
|
||||
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 await asyncio.to_thread(
|
||||
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,
|
||||
}
|
||||
@@ -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: {}
|
||||
+183
@@ -0,0 +1,183 @@
|
||||
#file: noinspection ComposeUnknownValues
|
||||
# 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
|
||||
@@ -0,0 +1 @@
|
||||
host: 14 CPU, 7965708288 bytes RAM, Docker Desktop, docker 29.3.0
|
||||
@@ -0,0 +1,211 @@
|
||||
{
|
||||
"label": "kill-1",
|
||||
"action_script": "scripts/kill-one.sh",
|
||||
"target_instance": "50bf23d8d45c",
|
||||
"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": "13:08:03",
|
||||
"duration_seconds": 30.06,
|
||||
"action_window_seconds": [
|
||||
8.01,
|
||||
8.76
|
||||
],
|
||||
"action_stdout": [
|
||||
"killed api container 50bf23d8d45c at 13:08:12"
|
||||
],
|
||||
"before": {
|
||||
"seconds": 8.01,
|
||||
"successful_rps": 41.1,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 76.66,
|
||||
"p95_ms": 219.09,
|
||||
"p99_ms": 621.22
|
||||
},
|
||||
"during_action": {
|
||||
"seconds": 0.75,
|
||||
"successful_rps": 49.1,
|
||||
"errors": 1,
|
||||
"error_ratio": 0.0263,
|
||||
"p50_ms": 61.57,
|
||||
"p95_ms": 101.94,
|
||||
"p99_ms": 129.19
|
||||
},
|
||||
"after_action": {
|
||||
"seconds": 21.3,
|
||||
"successful_rps": 69.0,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 66.17,
|
||||
"p95_ms": 113.69,
|
||||
"p99_ms": 196.83
|
||||
},
|
||||
"total_errors": 1,
|
||||
"last_error_after_action_start_s": 0.21,
|
||||
"max_gap_between_successful_writes_s": 0.295,
|
||||
"target_last_served_after_action_start_s": 0.14,
|
||||
"instances_after_action": {
|
||||
"907fb352c5ff": 1470
|
||||
},
|
||||
"confirmed_writes": 919,
|
||||
"lost_confirmed": 0,
|
||||
"duplicates": 0,
|
||||
"per_second": [
|
||||
{
|
||||
"t": 0,
|
||||
"ok": 57,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 1,
|
||||
"ok": 46,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 2,
|
||||
"ok": 35,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 3,
|
||||
"ok": 51,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 4,
|
||||
"ok": 19,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 5,
|
||||
"ok": 22,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 6,
|
||||
"ok": 35,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 7,
|
||||
"ok": 64,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 8,
|
||||
"ok": 52,
|
||||
"err": 1
|
||||
},
|
||||
{
|
||||
"t": 9,
|
||||
"ok": 32,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 10,
|
||||
"ok": 32,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 11,
|
||||
"ok": 91,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 12,
|
||||
"ok": 98,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 13,
|
||||
"ok": 54,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 14,
|
||||
"ok": 65,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 15,
|
||||
"ok": 104,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 16,
|
||||
"ok": 64,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 17,
|
||||
"ok": 61,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 18,
|
||||
"ok": 119,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 19,
|
||||
"ok": 64,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 20,
|
||||
"ok": 26,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 21,
|
||||
"ok": 53,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 22,
|
||||
"ok": 99,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 23,
|
||||
"ok": 66,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 24,
|
||||
"ok": 41,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 25,
|
||||
"ok": 84,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 26,
|
||||
"ok": 80,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 27,
|
||||
"ok": 52,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 28,
|
||||
"ok": 66,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 29,
|
||||
"ok": 100,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 30,
|
||||
"ok": 4,
|
||||
"err": 0
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
{
|
||||
"label": "kill-2",
|
||||
"action_script": "scripts/kill-one.sh",
|
||||
"target_instance": "907fb352c5ff",
|
||||
"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": "13:08:44",
|
||||
"duration_seconds": 30.07,
|
||||
"action_window_seconds": [
|
||||
8.0,
|
||||
8.61
|
||||
],
|
||||
"action_stdout": [
|
||||
"killed api container 907fb352c5ff at 13:08:53"
|
||||
],
|
||||
"before": {
|
||||
"seconds": 8.0,
|
||||
"successful_rps": 111.6,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 20.77,
|
||||
"p95_ms": 91.77,
|
||||
"p99_ms": 128.68
|
||||
},
|
||||
"during_action": {
|
||||
"seconds": 0.6,
|
||||
"successful_rps": 52.9,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 68.94,
|
||||
"p95_ms": 129.28,
|
||||
"p99_ms": 131.72
|
||||
},
|
||||
"after_action": {
|
||||
"seconds": 21.46,
|
||||
"successful_rps": 78.2,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 37.23,
|
||||
"p95_ms": 101.67,
|
||||
"p99_ms": 167.24
|
||||
},
|
||||
"total_errors": 0,
|
||||
"last_error_after_action_start_s": 0.0,
|
||||
"max_gap_between_successful_writes_s": 0.195,
|
||||
"target_last_served_after_action_start_s": 0.12,
|
||||
"instances_after_action": {
|
||||
"50bf23d8d45c": 1679
|
||||
},
|
||||
"confirmed_writes": 1304,
|
||||
"lost_confirmed": 0,
|
||||
"duplicates": 0,
|
||||
"per_second": [
|
||||
{
|
||||
"t": 0,
|
||||
"ok": 101,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 1,
|
||||
"ok": 99,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 2,
|
||||
"ok": 156,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 3,
|
||||
"ok": 113,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 4,
|
||||
"ok": 64,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 5,
|
||||
"ok": 137,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 6,
|
||||
"ok": 150,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 7,
|
||||
"ok": 73,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 8,
|
||||
"ok": 71,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 9,
|
||||
"ok": 90,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 10,
|
||||
"ok": 66,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 11,
|
||||
"ok": 60,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 12,
|
||||
"ok": 99,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 13,
|
||||
"ok": 93,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 14,
|
||||
"ok": 42,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 15,
|
||||
"ok": 91,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 16,
|
||||
"ok": 105,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 17,
|
||||
"ok": 54,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 18,
|
||||
"ok": 82,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 19,
|
||||
"ok": 103,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 20,
|
||||
"ok": 72,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 21,
|
||||
"ok": 61,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 22,
|
||||
"ok": 88,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 23,
|
||||
"ok": 78,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 24,
|
||||
"ok": 43,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 25,
|
||||
"ok": 97,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 26,
|
||||
"ok": 111,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 27,
|
||||
"ok": 55,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 28,
|
||||
"ok": 74,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 29,
|
||||
"ok": 72,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 30,
|
||||
"ok": 4,
|
||||
"err": 0
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -0,0 +1,211 @@
|
||||
{
|
||||
"label": "stop-1",
|
||||
"action_script": "scripts/stop-one.sh",
|
||||
"target_instance": "50bf23d8d45c",
|
||||
"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": "13:06:39",
|
||||
"duration_seconds": 30.08,
|
||||
"action_window_seconds": [
|
||||
8.0,
|
||||
12.03
|
||||
],
|
||||
"action_stdout": [
|
||||
"stopped api container 50bf23d8d45c at 13:06:51"
|
||||
],
|
||||
"before": {
|
||||
"seconds": 8.0,
|
||||
"successful_rps": 125.8,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 20.79,
|
||||
"p95_ms": 86.47,
|
||||
"p99_ms": 97.44
|
||||
},
|
||||
"during_action": {
|
||||
"seconds": 4.03,
|
||||
"successful_rps": 64.2,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 50.03,
|
||||
"p95_ms": 180.99,
|
||||
"p99_ms": 193.96
|
||||
},
|
||||
"after_action": {
|
||||
"seconds": 18.05,
|
||||
"successful_rps": 74.0,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 55.45,
|
||||
"p95_ms": 104.68,
|
||||
"p99_ms": 184.58
|
||||
},
|
||||
"total_errors": 0,
|
||||
"last_error_after_action_start_s": 0.0,
|
||||
"max_gap_between_successful_writes_s": 0.277,
|
||||
"target_last_served_after_action_start_s": 1.34,
|
||||
"instances_after_action": {
|
||||
"907fb352c5ff": 1335
|
||||
},
|
||||
"confirmed_writes": 1301,
|
||||
"lost_confirmed": 0,
|
||||
"duplicates": 0,
|
||||
"per_second": [
|
||||
{
|
||||
"t": 0,
|
||||
"ok": 170,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 1,
|
||||
"ok": 146,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 2,
|
||||
"ok": 70,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 3,
|
||||
"ok": 140,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 4,
|
||||
"ok": 157,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 5,
|
||||
"ok": 76,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 6,
|
||||
"ok": 100,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 7,
|
||||
"ok": 147,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 8,
|
||||
"ok": 109,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 9,
|
||||
"ok": 37,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 10,
|
||||
"ok": 44,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 11,
|
||||
"ok": 66,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 12,
|
||||
"ok": 64,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 13,
|
||||
"ok": 38,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 14,
|
||||
"ok": 105,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 15,
|
||||
"ok": 88,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 16,
|
||||
"ok": 43,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 17,
|
||||
"ok": 71,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 18,
|
||||
"ok": 90,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 19,
|
||||
"ok": 68,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 20,
|
||||
"ok": 49,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 21,
|
||||
"ok": 89,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 22,
|
||||
"ok": 92,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 23,
|
||||
"ok": 43,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 24,
|
||||
"ok": 104,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 25,
|
||||
"ok": 111,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 26,
|
||||
"ok": 43,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 27,
|
||||
"ok": 46,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 28,
|
||||
"ok": 100,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 29,
|
||||
"ok": 91,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 30,
|
||||
"ok": 4,
|
||||
"err": 0
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
{
|
||||
"label": "stop-2",
|
||||
"action_script": "scripts/stop-one.sh",
|
||||
"target_instance": "907fb352c5ff",
|
||||
"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": "13:07:21",
|
||||
"duration_seconds": 30.02,
|
||||
"action_window_seconds": [
|
||||
8.0,
|
||||
12.11
|
||||
],
|
||||
"action_stdout": [
|
||||
"stopped api container 907fb352c5ff at 13:07:33"
|
||||
],
|
||||
"before": {
|
||||
"seconds": 8.0,
|
||||
"successful_rps": 57.5,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 37.56,
|
||||
"p95_ms": 184.85,
|
||||
"p99_ms": 281.42
|
||||
},
|
||||
"during_action": {
|
||||
"seconds": 4.11,
|
||||
"successful_rps": 73.2,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 40.14,
|
||||
"p95_ms": 112.8,
|
||||
"p99_ms": 183.93
|
||||
},
|
||||
"after_action": {
|
||||
"seconds": 17.9,
|
||||
"successful_rps": 67.1,
|
||||
"errors": 0,
|
||||
"error_ratio": 0.0,
|
||||
"p50_ms": 67.58,
|
||||
"p95_ms": 108.51,
|
||||
"p99_ms": 204.16
|
||||
},
|
||||
"total_errors": 0,
|
||||
"last_error_after_action_start_s": 0.0,
|
||||
"max_gap_between_successful_writes_s": 0.28,
|
||||
"target_last_served_after_action_start_s": 0.75,
|
||||
"instances_after_action": {
|
||||
"50bf23d8d45c": 1201
|
||||
},
|
||||
"confirmed_writes": 982,
|
||||
"lost_confirmed": 0,
|
||||
"duplicates": 0,
|
||||
"per_second": [
|
||||
{
|
||||
"t": 0,
|
||||
"ok": 81,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 1,
|
||||
"ok": 50,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 2,
|
||||
"ok": 29,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 3,
|
||||
"ok": 38,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 4,
|
||||
"ok": 69,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 5,
|
||||
"ok": 59,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 6,
|
||||
"ok": 60,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 7,
|
||||
"ok": 74,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 8,
|
||||
"ok": 105,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 9,
|
||||
"ok": 36,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 10,
|
||||
"ok": 61,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 11,
|
||||
"ok": 88,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 12,
|
||||
"ok": 65,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 13,
|
||||
"ok": 44,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 14,
|
||||
"ok": 95,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 15,
|
||||
"ok": 98,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 16,
|
||||
"ok": 40,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 17,
|
||||
"ok": 86,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 18,
|
||||
"ok": 105,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 19,
|
||||
"ok": 71,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 20,
|
||||
"ok": 51,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 21,
|
||||
"ok": 105,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 22,
|
||||
"ok": 85,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 23,
|
||||
"ok": 44,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 24,
|
||||
"ok": 69,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 25,
|
||||
"ok": 46,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 26,
|
||||
"ok": 29,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 27,
|
||||
"ok": 26,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 28,
|
||||
"ok": 66,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 29,
|
||||
"ok": 83,
|
||||
"err": 0
|
||||
},
|
||||
{
|
||||
"t": 30,
|
||||
"ok": 4,
|
||||
"err": 0
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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."
|
||||
}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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
|
||||
@@ -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()
|
||||
);
|
||||
@@ -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;
|
||||
@@ -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);
|
||||
@@ -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
|
||||
@@ -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"
|
||||
@@ -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
|
||||
@@ -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; }
|
||||
@@ -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())
|
||||
@@ -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' ' ')"
|
||||
@@ -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"
|
||||
@@ -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 ' ')"
|
||||
@@ -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)"
|
||||
@@ -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
|
||||
@@ -0,0 +1,80 @@
|
||||
"""Граничные случаи контракта: тело при входе и лимит участников чата (stdlib).
|
||||
|
||||
1. POST /auth/sessions с действительным Basic и телом ({bad, {}) -> 400 invalid_request;
|
||||
без тела -> 201.
|
||||
2. POST /chats: 101 участник -> 400 invalid_request; ровно 100 -> 201.
|
||||
|
||||
Запуск: docker compose --profile tools run --rm tester python3 student-tests/contract_edge_cases.py
|
||||
или с хоста: python student-tests/contract_edge_cases.py --base-url http://localhost:8080
|
||||
"""
|
||||
import argparse
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
import uuid
|
||||
|
||||
|
||||
def main() -> int:
|
||||
p = argparse.ArgumentParser()
|
||||
p.add_argument('--base-url', default=os.environ.get('BASE_URL', 'http://localhost:8080'))
|
||||
base = p.parse_args().base_url.rstrip('/') + '/api/v1'
|
||||
|
||||
def call(method, path, body=None, headers=None, raw=None):
|
||||
h = dict(headers or {})
|
||||
if body is not None:
|
||||
raw = json.dumps(body).encode()
|
||||
h['Content-Type'] = 'application/json'
|
||||
req = urllib.request.Request(base + path, data=raw, headers=h, method=method)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=10) as r:
|
||||
return r.status, json.loads(r.read() or b'null')
|
||||
except urllib.error.HTTPError as e:
|
||||
return e.code, json.loads(e.read() or b'null')
|
||||
|
||||
def new_user():
|
||||
name = 'edge' + uuid.uuid4().hex[:12]
|
||||
password = 'edge-case-password-1'
|
||||
status, user = call('POST', '/users', {'username': name, 'display_name': 'Edge case', 'password': password})
|
||||
assert status == 201, f'register: {status}'
|
||||
basic = 'Basic ' + base64.b64encode(f'{name}:{password}'.encode()).decode()
|
||||
return user, basic
|
||||
|
||||
def code(resp):
|
||||
return resp.get('error', {}).get('code') if isinstance(resp, dict) else None
|
||||
|
||||
failed = 0
|
||||
|
||||
def check(label, status, resp, want_status, want_code=None):
|
||||
nonlocal failed
|
||||
ok = status == want_status and (want_code is None or code(resp) == want_code)
|
||||
failed += not ok
|
||||
print(f"{'OK ' if ok else 'FAIL'} {label}: {status} {code(resp) or ''} (ожидается {want_status} {want_code or ''})")
|
||||
|
||||
user, basic = new_user()
|
||||
json_headers = {'Authorization': basic, 'Content-Type': 'application/json'}
|
||||
|
||||
s, r = call('POST', '/auth/sessions', headers=json_headers, raw=b'{bad')
|
||||
check('вход: Basic + тело {bad', s, r, 400, 'invalid_request')
|
||||
s, r = call('POST', '/auth/sessions', headers=json_headers, raw=b'{}')
|
||||
check('вход: Basic + тело {}', s, r, 400, 'invalid_request')
|
||||
s, r = call('POST', '/auth/sessions', headers=json_headers)
|
||||
check('вход: Basic без тела (Content-Type: application/json)', s, r, 201)
|
||||
s, session = call('POST', '/auth/sessions', headers={'Authorization': basic})
|
||||
check('вход: Basic без тела', s, session, 201)
|
||||
|
||||
bearer = {'Authorization': 'Bearer ' + session['token']}
|
||||
others = [new_user()[0]['id'] for _ in range(100)]
|
||||
s, r = call('POST', '/chats', {'title': '101 members', 'member_ids': [user['id']] + others}, headers=bearer)
|
||||
check('чат: 101 участник', s, r, 400, 'invalid_request')
|
||||
s, r = call('POST', '/chats', {'title': '100 members', 'member_ids': [user['id']] + others[:99]}, headers=bearer)
|
||||
check('чат: ровно 100 участников', s, r, 201)
|
||||
|
||||
print('PASS: тело при входе и лимит участников соответствуют контракту' if not failed else f'FAIL: {failed} проверок не прошло')
|
||||
return 1 if failed else 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -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)
|
||||
@@ -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)
|
||||
@@ -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
|
||||
Reference in New Issue
Block a user