ЛР 3 — БПИ2302 — Григорьев — на 4 #138

Closed
Pavel_Grigoriev wants to merge 4 commits from Pavel_Grigoriev/mtusi2026lab3:solution/bpi2302-grigoriev into main
57 changed files with 3255 additions and 23 deletions
+12
View File
@@ -18,3 +18,15 @@ __pycache__
node_modules
evidence
.DS_Store
tests
student-tests
contracts
scripts
examples
*.md
Makefile
lab.json
requirements-dev.txt
Dockerfile*
.dockerignore
.gitignore
+14 -4
View File
@@ -3,11 +3,21 @@
APP_HOST=0.0.0.0
APP_PORT=8080
APP_ENV=lab
APP_SHUTDOWN_TIMEOUT=5
APP_DRAIN_SECONDS=3
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
# Credentials are generated locally by: python scripts/init_secrets.py
# 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
CACHE_URL_FILE=/run/secrets/cache_url
# Sessions: PostgreSQL is the source of truth, Valkey is a read-through cache.
CACHE_URL=redis://valkey:6379/0
SESSION_CACHE_TTL_SECONDS=60
REVOCATION_SYNC_SECONDS=1
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
PASSWORD_HASH_CONCURRENCY=4
DB_POOL_MIN=1
DB_POOL_MAX=10
DB_POOL_TIMEOUT_SECONDS=2
DB_STATEMENT_TIMEOUT_MS=3000
DB_REQUEST_TIMEOUT_SECONDS=4
+2
View File
@@ -0,0 +1,2 @@
*.sh text eol=lf
*.cmd text eol=crlf
+30
View File
@@ -0,0 +1,30 @@
name: Application
on: [push, pull_request]
permissions:
contents: read
jobs:
stack:
runs-on: ubuntu-latest
timeout-minutes: 20
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: cp .env.example .env
- run: python scripts/init_secrets.py
- run: docker compose config --quiet
- run: docker compose up -d --build --wait
- run: make test BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: make student-test BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: python student-tests/expiry_check.py --ttl 2
- run: python student-tests/failure_check.py
- run: make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080 PYTHON=python
- run: docker compose start api && sleep 15
- run: python student-tests/failover_series.py
- run: python student-tests/rolling_update_check.py --no-build
- if: failure()
run: docker compose ps -a && docker compose logs --no-color
- if: always()
run: docker compose down -v
+25
View File
@@ -0,0 +1,25 @@
FROM python:3.12.15-slim-trixie@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1 \
PIP_ROOT_USER_ACTION=ignore
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY migrations/ ./migrations/
COPY src/ ./src/
RUN useradd --uid 10001 --user-group --no-create-home --shell /usr/sbin/nologin app
USER app
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_PORT', '8080'), timeout=2)"]
CMD ["python", "src/main.py"]
+4 -1
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test load test-persistence test-failover
.PHONY: help check validate test load test-persistence test-failover student-test
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -18,6 +18,9 @@ validate:
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
student-test:
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
+125 -18
View File
@@ -1,37 +1,144 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Григорьев Павел, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: 4
- Commit/PR: ветка `solution/bpi2302-grigoriev`; ссылка на PR — после публикации
- Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.3.6 + psycopg-pool 3.3.3, argon2-cffi 25.1.0, redis-py 8.1.0 (полный список — `requirements.txt`); HAProxy 3.0.30, PostgreSQL 17.11, Valkey 8.1.11; документация HAProxy (health checks, resolvers, server-template, retry-on), Docker Compose (deploy.replicas, resources), Uvicorn (graceful shutdown). При разработке использовался ИИ-ассистент.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Требования: Docker Engine 27.x с Compose v2 (проверено: Docker Desktop, Engine 27.2.0, WSL2 на Windows 10); Python 3.9+ только для тестов и скриптов (стандартная библиотека). Порты хоста: `127.0.0.1:8080` (вход через LB) и `127.0.0.1:8404` (страница статистики HAProxy).
Образы закреплены тегом и digest: `python:3.12.15-slim-trixie@sha256:a6e34c59…` (сборка API), `haproxy:3.0.30-alpine@sha256:d2b3567d…`, `postgres:17.11-alpine@sha256:266d3c25…`, `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`.
```sh
git clone <URL fork> mtusi2026lab3 && cd mtusi2026lab3
git switch solution/bpi2302-grigoriev
cp .env.example .env
python scripts/init_secrets.py # secrets/postgres_password, secrets/database_url (вне Git)
docker compose config --quiet
docker compose up -d --build --wait # postgres, valkey → migrate (exit 0) → api ×2 healthy → lb healthy
docker compose ps -a
python tests/smoke.py --base-url http://127.0.0.1:8080 # make test
python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080
python tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
docker compose start api # вернуть остановленную реплику
# на Windows вместо .sh — scripts/restart.cmd и scripts/stop-one.cmd (Python на Windows не исполняет .sh)
python -m unittest discover -s student-tests -v # make student-test
python student-tests/failover_series.py --output evidence/failover-series.json
python student-tests/rolling_update_check.py --output evidence/rolling-update.json
```
Миграции выполняет один раз одноразовый сервис `migrate` (под `pg_advisory_lock`), реплики API стартуют только после его успешного завершения и сами миграции не запускают. Новая миграция `0004_idempotency_keys` только добавляет таблицу — работающая предыдущая версия API с ней совместима. Перед rolling update миграции запускаются явно: `docker compose run --rm --no-deps migrate`.
Возврат остановленной реплики — `docker compose start api` (запускает только остановленные контейнеры сервиса). `docker compose up -d api` для этого не годится: он может пересоздать и работающие реплики (наблюдали — на несколько секунд не осталось ни одной).
На Windows используйте `127.0.0.1`, а не `localhost` (иначе +2 с на каждый запрос). Остановка без потери данных: `docker compose stop`. Намеренное удаление учебных данных: `docker compose down -v`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
клиент ──► 127.0.0.1:8080 ──► lb (HAProxy, roundrobin, активная проверка /health/ready раз в 1 с)
│ сеть backend (internal), порты API наружу не публикуются
├──► api #1 ─┐ stateless: X-Instance-Id = hostname контейнера
└──► api #2 ─┤
├──► postgres — источник истины: пользователи, чаты, сообщения,
│ сессии, отзывы сессий, ключи идемпотентности
└──► valkey — общий кэш проверки сессии (TTL ≤ 60 с)
migrate (one-shot) ──► postgres
```
| Роль | Service | Версия/digest | Health/readiness | Volume | Сеть/порт | Лимиты | Credentials |
| --- | --- | --- | --- | --- | --- | --- | --- |
| load_balancer | `lb` | haproxy 3.0.30-alpine@sha256:d2b3… | `GET /lb/health` (monitor-uri) | — | frontend+backend; `127.0.0.1:8080`, `127.0.0.1:8404` | 0.5 CPU, 128M | — |
| api ×2 | `api` (`deploy.replicas: ${API_REPLICAS:-2}`, без `container_name`) | сборка из `Dockerfile` | `GET /health/ready` (Docker healthcheck и LB) | — | только backend, **порт не публикуется** | 0.5 CPU, 320M каждая | secret `database_url` |
| миграции | `migrate` | тот же образ | exit 0 | — | backend | 0.5 CPU, 128M | secret `database_url` |
| postgres | `postgres` | 17.11-alpine@sha256:266d… | `pg_isready` | `pgdata` | backend | 1 CPU, 384M | secret `postgres_password` |
| redis_or_valkey | `valkey` | 8.1.11-alpine@sha256:2602… | `valkey-cli ping` | — (кэш) | backend | 0.25 CPU, 96M | нет: внутренняя сеть |
Секрет БД смонтирован только в `api` и `migrate`; балансировщик и Valkey его не получают. Сеть `backend` — `internal: true`.
**Балансировщик — HAProxy** (`infra/haproxy/haproxy.cfg`). Почему он: активные HTTP-проверки здоровья в бесплатной версии (у Nginx OSS — только пассивные), обнаружение реплик через DNS Docker (`server-template api 1-4 api:8080` + `resolvers docker`) — масштабирование `api` без правки конфига, страница статистики для демонстрации состояния backend.
- Алгоритм — **roundrobin**: реплики одинаковые, запросы короткие и однородные. Sticky sessions не используются — состояние общее.
- Проверка: `GET /health/ready` каждые **1 с**, `timeout check 1s`, **fall 2** / **rise 2**. Максимальное время обнаружения отказа по проверкам ≈ 2–3 с; при остановке контейнера реплика ещё быстрее исключается по DNS (`hold obsolete 2s`) и по ошибке соединения.
- `retries 2`, `option redispatch`, `retry-on conn-failure` — повтор на другую реплику **только если запрос не был доставлен** (соединение не установилось): безопасно для любых методов, включая POST без ключа идемпотентности. Запрос, уже принятый репликой, LB не повторяет.
- `option http-server-close` — к backend по соединению на запрос: нет гонки «LB отправил запрос в keep-alive соединение, которое реплика закрывает при остановке».
- `timeout connect 1s`, `timeout server 10s` (больше бюджета БД 4 с), `maxconn 2000` (без явного значения HAProxy вычислял его из огромного `ulimit` Docker, резервировал память и был убит OOM при лимите 64M).
- Если **все** реплики не готовы (`/health/ready` = 503 — например, недоступна общая БД), запросы идут во второй backend `api_live`, проверяемый по `/health/live`: приложение само отвечает по контракту (JSON 503, 401, live 200, `X-Instance-Id`), а не HTML-страница LB. Исключать все реплики при отказе общей зависимости бессмысленно.
**`X-Instance-Id`** — hostname контейнера (= первые 12 символов ID), стабилен для жизни процесса, добавляется middleware ко всем ответам API, включая ошибки и health. `scripts/stop-one.sh` по нему находит контейнер среди `docker compose ps -q api` и останавливает только его (`docker stop -t 10`), возвращаясь за ~4 с.
**Остановка по SIGTERM (graceful).** `docker stop` → SIGTERM → реплика сразу начинает отвечать 503 на `/health/ready`, **3 с** (`APP_DRAIN_SECONDS`) продолжает обслуживать запросы, пока HAProxy её исключает (fall 2 × 1 с), затем Uvicorn перестаёт принимать соединения и до 5 с дорабатывает начатые. `stop_grace_period: 15s` > 3 + 5. Итог: при `docker stop` реплики клиенты не получают ни одной ошибки (`sigterm.txt`, `failover-series.json`).
**Идемпотентность отправки сообщения** (`migrations/0004_idempotency_keys.sql`, `src/store.py`). Таблица `idempotency_keys(user_id, scope, key, request_hash, message_id, created_at)`, PK `(user_id, scope, key)`, scope = `POST /api/v1/chats/<chat_id>/messages` — область: пользователь + метод + путь чата + ключ.
- Заголовок обязателен, формат `[A-Za-z0-9._:-]{1,128}`, иначе 400.
- Хеш тела — SHA-256 канонического JSON (`sort_keys`, отсутствующий `attachment_ids` = `[]`), поэтому порядок полей и пробелы не важны.
- Одна транзакция: удалить истёкшие (> `IDEMPOTENCY_TTL_SECONDS` = 24 ч) ключи пользователя → `INSERT … ON CONFLICT DO NOTHING` ключа → если вставлен: вставить сообщение (с проверкой членства) и записать его id в ключ; если конфликт: проверить членство (404), сравнить хеш (иной → 409), вернуть **тот же** Message с 201.
- Параллельный повтор с тем же ключом через другую реплику **ждёт** на уникальном индексе, пока первая транзакция не завершится, затем получает её результат. Ошибка внутри транзакции откатывает и сообщение, и ключ — транзиентные 5xx не фиксируются, клиент безопасно повторяет с тем же ключом.
- Повтор заново проходит аутентификацию и проверку доступа.
**Сессии и кэш между репликами.** Источник истины — PostgreSQL, Valkey общий для всех реплик, поэтому вход на одной реплике действует на всех. Из lab2 перенесён устойчивый отзыв сессии (`session_revocations`); для нескольких реплик сверка отзывов с кэшем теперь выполняется не только после старта и ошибки Valkey, но и **не реже раза в секунду** (`REVOCATION_SYNC_SECONDS=1`) — реплика, не видевшая отказа Valkey, тоже не доверяет кэшу дольше секунды без сверки.
**Прочее.** Бюджет ожидания БД (4 с) теперь отсчитывается с первого обращения к БД в запросе, а не с начала запроса: иначе под нагрузкой его съедало ожидание очереди на Argon2. Одновременных вычислений Argon2 на реплику — не больше 4 (`PASSWORD_HASH_CONCURRENCY`), чтобы 19 МиБ на хеш не превысили лимит памяти; `MALLOC_ARENA_MAX=2` против роста памяти из-за арен glibc в потоках (без него реплика держала 230 из 256 МиБ).
**Перенесено из lab2:** весь API, схема и миграции 0001–0003, сессии и устойчивые отзывы, кэш Valkey, сроки ожидания БД, тесты (теперь через LB). **Изменено:** 2 реплики за HAProxy, `X-Instance-Id`, обязательный `Idempotency-Key`, graceful drain, лимиты ресурсов, периодическая сверка отзывов, сервисы restore-эксперимента lab2 убраны.
Соответствие `.env.example`:
| Переменная | Где используется | По умолчанию |
| --- | --- | --- |
| `API_REPLICAS` | `deploy.replicas` сервиса `api` | `2` |
| `APP_DRAIN_SECONDS` | пауза между readiness=503 и закрытием сервера при SIGTERM | `3` |
| `IDEMPOTENCY_TTL_SECONDS` | сколько хранится ключ идемпотентности | `86400` |
| `REVOCATION_SYNC_SECONDS` | максимальный интервал сверки отзывов сессий с кэшем | `1` |
| `PASSWORD_HASH_CONCURRENCY` | одновременных Argon2 на реплику | `4` |
| `APP_SHUTDOWN_TIMEOUT` | сколько Uvicorn дорабатывает начатые запросы | `5` |
| остальные (`SESSION_*`, `DB_*`, `CACHE_URL`, `DATABASE_URL_FILE`) | как в lab2 | |
`SESSION_STORE` и `CACHE_URL_FILE` из skeleton не используются: сессии всегда в PostgreSQL, адрес кэша несекретный (`CACHE_URL`).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
Файлы — `evidence/`, получены 2026-11-12 со свежих volumes (Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1,9 GiB).
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | `python tests/smoke.py` | `PASS: lab3 public API scenario` | `smoke.txt` |
| 3: стенд в compose.yaml, ≥ 2 API, одна точка входа, общая БД и сессии | `docker compose up -d --build --wait`, `ps` | api ×2, lb, postgres, valkey; порт только у lb | `topology.txt` |
| 3: запросы одного пользователя на разных репликах без повторного входа | `test_one_session_is_served_by_several_replicas`; 6 × `/health/ready` | два чередующихся `X-Instance-Id` | `student-tests.txt`, `topology.txt` |
| 3: остановка любой реплики, ≤ 10 с, подтверждённое доступно | `tests/resilience.py --mode failover` + `stop-one`, для **каждой** реплики | PASS обе; 110–112 записей, **0 ошибок**, запись непрерывна; hook возвращается за 4,3–4,4 с; `ps` после — цель `Exited (0)` | `failover.txt` |
| 3: повтор с тем же ключом не создаёт дубль, в т.ч. конкурентный и через другую реплику | `test_idempotency.py` | 20 одновременных POST с одним ключом через обе реплики → один Message; другой body → 409; без ключа/кривой → 400 | `student-tests.txt` |
| 3: persistence | `tests/resilience.py --mode persistence` + `restart` | PASS, тот же токен; postgres/valkey/api перезапущены | `persistence.txt` |
| 4: health/readiness, timeouts, SIGTERM согласованы; LB исключает недоступный backend; период и время обнаружения | `haproxy.cfg`; `sigterm_check.py`; `failover_series.py` | проверка 1 с, fall 2; при `docker stop` реплика исключается за 1,3–1,4 с, ошибок 0, 130 запросов после SIGTERM — все 200; при `kill` переключение за 0,05–0,1 с | `sigterm.txt`, `failover-series.json` |
| 4: остановить каждую реплику по очереди, RPS, ошибки, восстановление | `failover_series.py` (stop и kill × 2 реплики) | stop: 0 ошибок; kill: 3–4 × 502 (запросы, бывшие внутри убитой реплики), повторены тем же ключом; возврат в ротацию ≈ 11,5 с; потерь и дублей 0 | `failover-series.json`, `failover-series.txt` |
| 4: общая идемпотентность параллельными запросами | `test_parallel_retries_through_replicas_create_one_message` | 20 потоков, 2 реплики, 1 сообщение | `student-tests.txt` |
| 4: CPU/RAM-лимиты, нет портов API в обход LB, нет container_name, секреты только где нужно | `compose.yaml`; `docker stats` | лимиты у всех сервисов; порты только у lb; secret БД только у api/migrate | `topology.txt` |
| 4: rolling update под нагрузкой; миграции однократно и совместимы | `rolling_update_check.py` | 2 реплики заменены по одной за 35 с, **0 ошибок**, RPS 69 → 56 → 53, потерь и дублей 0 | `rolling-update.json`, `rolling-update.txt` |
| сохранено из lab2: истечение, отказ Valkey/PostgreSQL, отзыв сессии | `expiry_check.py`, `failure_check.py` | PASS через LB с двумя репликами | `expiry.txt`, `failure.txt` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Нагрузка — генератор в `student-tests/helpers.py` (`Load`): 4 потока, POST сообщений с уникальным `Idempotency-Key`, при любой ошибке — повтор с тем же ключом; после прогона проверяются потери и дубли. Прогрев 5 с, наблюдение 10 с после воздействия.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Воздействие | Ошибок клиента | RPS до → во время | Последний ответ цели после воздействия | Возврат в ротацию | Потери/дубли |
| --- | --- | --- | --- | --- | --- |
| `docker stop` реплики 1 | 0 | 50 → 37 | +1,35 с | 11,7 с | 0 / 0 |
| `docker stop` реплики 2 | 0 | 72 → 34 | +1,28 с | 11,6 с | 0 / 0 |
| `docker kill` реплики 1 | 4 × 502 | 46 → 24 | +0,10 с | 11,7 с | 0 / 0 |
| `docker kill` реплики 2 | 3 × 502 | 71 → 25 | +0,10 с | 11,5 с | 0 / 0 |
| rolling update (2 реплики, 35 с) | 0 | 69 → 56 | — | — | 0 / 0 |
- При штатной остановке ошибок нет: реплика сначала уходит из ротации, потом закрывается. При внезапной смерти теряются только запросы, которые уже выполнялись внутри неё (502 от LB) — LB их не повторяет, потому что не знает, выполнены ли они; повтор делает клиент с тем же ключом, дублей нет.
- RPS на одной реплике примерно вдвое ниже: каждая ограничена 0,5 CPU — это и показывает, что вторая реплика реально добавляет мощность.
- Возврат ≈ 11,5 с: `docker compose start api` ≈ 4,5 с (Compose заново запускает одноразовый `migrate` как зависимость — он идемпотентен), старт процесса и 2 успешные проверки LB.
Нагрузка public-скриптом (`python tests/load.py --duration 30 --concurrency 4`, через LB): 1 979 успешных, 0 ошибок, **65 RPS**, p50 42 / p95 163 / p99 201 мс; память после: api 75–88 MiB из 320, lb 22 MiB, postgres 64 MiB. В lab2 тот же скрипт давал 283 RPS — там у единственного API не было лимита CPU; здесь у двух реплик суммарно 1 CPU и добавлен переход через LB. Это не предел системы: closed-loop генератор, клиент на той же машине.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Выдерживается: отказ любой одной API-реплики (штатный и внезапный), rolling update, рестарт стенда. Не выдерживается: отказ LB, PostgreSQL, Valkey-хоста или всего Docker-host — это единые точки отказа (один хост, одна БД).
- При внезапной смерти реплики запросы внутри неё получают 502; для сообщений клиент безопасно повторяет с ключом, а для `POST /users` и `POST /chats` прозрачный повтор контрактом не предусмотрен — повтор может создать второй объект.
- Сверка отзывов сессий раз в секунду на реплику — короткое окно, а не нулевое: реплика может доверять кэшу до 1 с после того, как отзыв, не попавший в Valkey, записан другой репликой.
- Rolling update скриптовый (Compose не умеет его сам); имена контейнеров после него — `api-3`, `api-4` (на работу не влияет). В Swarm это было бы `update_config` с `order: start-first`.
- Возврат реплики через `docker compose start api` заново запускает `migrate` (безвредно, но +несколько секунд); можно `docker start <id>`.
+135
View File
@@ -0,0 +1,135 @@
name: grigoriev-lab3
x-app-env: &app-env
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: ${APP_ENV:-lab}
APP_SHUTDOWN_TIMEOUT: ${APP_SHUTDOWN_TIMEOUT:-5}
APP_DRAIN_SECONDS: ${APP_DRAIN_SECONDS:-3}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_CACHE_TTL_SECONDS: ${SESSION_CACHE_TTL_SECONDS:-60}
REVOCATION_SYNC_SECONDS: ${REVOCATION_SYNC_SECONDS:-1}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
PASSWORD_HASH_CONCURRENCY: ${PASSWORD_HASH_CONCURRENCY:-4}
DB_POOL_MIN: ${DB_POOL_MIN:-1}
DB_POOL_MAX: ${DB_POOL_MAX:-10}
DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:-2}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:-3000}
DB_REQUEST_TIMEOUT_SECONDS: ${DB_REQUEST_TIMEOUT_SECONDS:-4}
MALLOC_ARENA_MAX: "2"
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL: ${CACHE_URL:-redis://valkey:6379/0}
x-dns-opt: &dns-opt
- timeout:1
- attempts:1
services:
lb:
image: haproxy:3.0.30-alpine@sha256:d2b3567d836f3b7d174edb6d6f611ed5308e7966e53a9cd9a597e0415a298efd
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
ports:
- "127.0.0.1:8080:8080"
- "127.0.0.1:8404:8404"
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/lb/health"]
interval: 5s
timeout: 2s
retries: 6
depends_on:
api:
condition: service_healthy
deploy:
resources:
limits: {cpus: "0.50", memory: 128M}
networks: [frontend, backend]
restart: unless-stopped
api:
build: .
image: mtusi-messenger:lab3
environment: *app-env
secrets: [database_url]
depends_on:
migrate:
condition: service_completed_successfully
postgres:
condition: service_healthy
valkey:
condition: service_started
dns_opt: *dns-opt
stop_grace_period: 15s
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits: {cpus: "0.50", memory: 320M}
networks: [backend]
restart: unless-stopped
migrate:
build: .
image: mtusi-messenger:lab3
command: ["python", "src/migrate.py"]
environment: *app-env
secrets: [database_url]
depends_on:
postgres:
condition: service_healthy
deploy:
resources:
limits: {cpus: "0.50", memory: 128M}
networks: [backend]
restart: "no"
postgres:
image: postgres:17.11-alpine@sha256:266d3c257594e195b309ae9d1805e54c788f1d7b375f56bf6c367aac6c917e7b
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
command: ["postgres", "-c", "track_io_timing=on"]
secrets: [postgres_password]
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 12
start_period: 10s
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "1.00", memory: 384M}
networks: [backend]
restart: unless-stopped
valkey:
image: valkey/valkey:8.1.11-alpine@sha256:2602ace2be6569bc2bbb06f873776516ab9089821525be34f4305c67eb9db02a
command: ["valkey-server", "--save", "", "--appendonly", "no",
"--maxmemory", "64mb", "--maxmemory-policy", "volatile-ttl"]
healthcheck:
test: ["CMD", "valkey-cli", "ping"]
interval: 5s
timeout: 3s
retries: 12
deploy:
resources:
limits: {cpus: "0.25", memory: 96M}
networks: [backend]
restart: unless-stopped
volumes:
pgdata:
networks:
frontend:
backend:
internal: true
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
+15
View File
@@ -3,3 +3,18 @@
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
## Файлы этого решения (2026-11-12, свежие volumes, Windows 10 + Docker Desktop 27.2.0, VM 12 CPU / 1,9 GiB, api 2 × 0,5 CPU / 320M)
| Файл | Команда | Что показывает |
| --- | --- | --- |
| `topology.txt` | `docker compose ps`, 6 × `/health/ready` через LB, `docker stats` | две реплики, порт только у LB, чередование `X-Instance-Id`, лимиты |
| `smoke.txt` | `python tests/smoke.py` | публичный сценарий lab3 |
| `persistence.txt` | `tests/resilience.py --mode persistence` + `scripts/restart.cmd` | данные и токен после рестарта, `ps` до/после |
| `failover.txt` | `tests/resilience.py --mode failover` + `scripts/stop-one.cmd`, для каждой реплики | какой контейнер остановлен, PASS, 0 ошибок |
| `failover-series.json`, `.txt` | `python student-tests/failover_series.py` | stop и kill каждой реплики под нагрузкой: ошибки, RPS, время исключения и возврата |
| `rolling-update.json`, `.txt` | `python student-tests/rolling_update_check.py` | поочерёдная замена реплик под нагрузкой |
| `student-tests.txt` | `python -m unittest discover -s student-tests -v` | 48 тестов: идемпотентность, реплики, API, аутентификация, БД |
| `sigterm.txt` | `python student-tests/sigterm_check.py` | SIGTERM: вывод из ротации, 0 ошибок клиентам |
| `expiry.txt`, `failure.txt` | `expiry_check.py`, `failure_check.py` | истечение сессии; отказы Valkey и PostgreSQL через LB |
| `load.json` | `python tests/load.py --duration 30 --concurrency 4` | базовая нагрузка через LB |
+10
View File
@@ -0,0 +1,10 @@
# python student-tests/expiry_check.py --ttl 2
# date: 2026-11-12T13:18:06Z; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
пересоздаю api с SESSION_TTL_SECONDS=2
сразу после входа: /users/me -> 200
TTL ключа этой сессии в Valkey: 1 с (-2 = ключа нет)
через 3.5 с: /users/me -> 401, WWW-Authenticate: Bearer realm="messenger"
logout истёкшим токеном -> 401
PASS: сессия истекла по SESSION_TTL_SECONDS=2, кэш не продлил её
возвращаю api с TTL из .env
+160
View File
@@ -0,0 +1,160 @@
{
"replicas": [
"07dbb34db037",
"d4a765ecfdcb"
],
"warmup_s": 5,
"observe_s": 10,
"workers": 4,
"lb_check": "GET /health/ready every 1s, fall 2, rise 2",
"results": [
{
"replica": "07dbb34db037",
"mode": "stop",
"action_seconds": 3.9,
"target_served_until_s": 1.35,
"first_success_on_other_s": 0.05,
"before": {
"seconds": 5.0,
"ok": 251,
"errors": 0,
"rps": 50.2,
"p50_ms": 36.6,
"p95_ms": 269.6,
"p99_ms": 291.4,
"error_kinds": []
},
"during_10s": {
"seconds": 10.0,
"ok": 367,
"errors": 0,
"rps": 36.7,
"p50_ms": 101.5,
"p95_ms": 213.3,
"p99_ms": 300.8,
"error_kinds": []
},
"back_in_rotation_s": 11.69,
"data": {
"confirmed": 740,
"stored": 740,
"lost": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"uncertain_at_stop": 0
}
},
{
"replica": "d4a765ecfdcb",
"mode": "stop",
"action_seconds": 3.96,
"target_served_until_s": 1.28,
"first_success_on_other_s": 0.07,
"before": {
"seconds": 5.0,
"ok": 358,
"errors": 0,
"rps": 71.6,
"p50_ms": 35.2,
"p95_ms": 145.5,
"p99_ms": 174.7,
"error_kinds": []
},
"during_10s": {
"seconds": 10.0,
"ok": 342,
"errors": 0,
"rps": 34.2,
"p50_ms": 104.3,
"p95_ms": 212.3,
"p99_ms": 298.7,
"error_kinds": []
},
"back_in_rotation_s": 11.62,
"data": {
"confirmed": 842,
"stored": 842,
"lost": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"uncertain_at_stop": 0
}
},
{
"replica": "07dbb34db037",
"mode": "kill",
"action_seconds": 0.39,
"target_served_until_s": 0.1,
"first_success_on_other_s": 0.05,
"before": {
"seconds": 5.0,
"ok": 229,
"errors": 0,
"rps": 45.8,
"p50_ms": 48.8,
"p95_ms": 253.5,
"p99_ms": 295.8,
"error_kinds": []
},
"during_10s": {
"seconds": 10.0,
"ok": 241,
"errors": 4,
"rps": 24.1,
"p50_ms": 108.2,
"p95_ms": 308.6,
"p99_ms": 1030.3,
"error_kinds": [
"502"
]
},
"back_in_rotation_s": 11.72,
"data": {
"confirmed": 488,
"stored": 488,
"lost": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"uncertain_at_stop": 0
}
},
{
"replica": "d4a765ecfdcb",
"mode": "kill",
"action_seconds": 0.39,
"target_served_until_s": 0.1,
"first_success_on_other_s": 0.07,
"before": {
"seconds": 5.0,
"ok": 356,
"errors": 0,
"rps": 71.2,
"p50_ms": 40.3,
"p95_ms": 141.2,
"p99_ms": 182.5,
"error_kinds": []
},
"during_10s": {
"seconds": 10.0,
"ok": 245,
"errors": 3,
"rps": 24.5,
"p50_ms": 107.8,
"p95_ms": 295.6,
"p99_ms": 1039.2,
"error_kinds": [
"502"
]
},
"back_in_rotation_s": 11.53,
"data": {
"confirmed": 617,
"stored": 617,
"lost": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"uncertain_at_stop": 0
}
}
]
}
+5
View File
@@ -0,0 +1,5 @@
07dbb34db037 stop errors=0 rps 50.2 -> 36.7 target last answer +1.35s restore 11.7s lost=0 dup=0
d4a765ecfdcb stop errors=0 rps 71.6 -> 34.2 target last answer +1.28s restore 11.6s lost=0 dup=0
07dbb34db037 kill errors=4 rps 45.8 -> 24.1 target last answer +0.10s restore 11.7s lost=0 dup=0
d4a765ecfdcb kill errors=3 rps 71.2 -> 24.5 target last answer +0.10s restore 11.5s lost=0 dup=0
PASS: every replica stopped once per mode; no loss, no duplicates
+29
View File
@@ -0,0 +1,29 @@
# make test-failover ACTION_SCRIPT=scripts/stop-one.cmd (Windows equivalent of stop-one.sh), repeated until every replica was the target
# date: 2026-11-12T13:13:33Z; replicas: 4c764ef640a6 540fcfe80e6c
## run 1
$ docker compose ps -a api (before)
grigoriev-lab3-api-1 4c764ef640a6 Up 21 seconds (healthy)
grigoriev-lab3-api-2 540fcfe80e6c Up 20 seconds (healthy)
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 112, "failed_attempts": 0, "first_recovery_seconds": 4.313}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
$ docker compose ps -a api (after: target stays stopped)
grigoriev-lab3-api-1 4c764ef640a6 Up 38 seconds (healthy)
grigoriev-lab3-api-2 540fcfe80e6c Exited (0) 11 seconds ago
stopped replica: 540fcfe80e6c
restored 540fcfe80e6c (back in LB rotation)
## run 2 (one extra GET /health/live through LB first: shifts round robin so the other replica serves the test message)
$ docker compose ps -a api (before)
grigoriev-lab3-api-1 4c764ef640a6 Up 3 minutes (healthy)
grigoriev-lab3-api-2 540fcfe80e6c Up 22 seconds (healthy)
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 110, "failed_attempts": 0, "first_recovery_seconds": 4.373}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
$ docker compose ps -a api (after: target stays stopped)
grigoriev-lab3-api-1 4c764ef640a6 Exited (0) 11 seconds ago
grigoriev-lab3-api-2 540fcfe80e6c Up 40 seconds (healthy)
stopped replica: 4c764ef640a6
restored 4c764ef640a6 (back in LB rotation)
# note: runs 2-6 of the first attempt repeated the same target (540fcfe80e6c) because the test sends a fixed number of requests before the message and round robin is deterministic
+40
View File
@@ -0,0 +1,40 @@
# python student-tests/failure_check.py
# date: 2026-11-12T13:18:34Z; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL
первый запрос: обнаружение отказа кэша -> 200 за 0.04 с OK
GET /users/me действующим токеном -> 200 за 0.02 с OK
POST сообщение -> 201 за 0.04 с OK
неизвестный токен -> 401 за 0.01 с OK
без Authorization -> 401 за 0.01 с OK
/health/ready (Valkey некритичен) -> 200 за 0.01 с OK
регистрация и вход без кэша -> 200 за 0.13 с OK
logout без кэша -> 204 за 0.02 с OK
отозванный токен -> 401 за 0.01 с OK
1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша
logout при паузе Valkey -> 204 за 0.45 с OK
через 6 с после unpause: /users/me -> 401 за 0.02 с OK
через 6 с после unpause: сообщение -> 401 за 0.01 с OK
1в. Valkey на паузе: logout, рестарт API, unpause — отзыв переживает рестарт процесса
logout при паузе Valkey -> 204 за 0.45 с OK
после рестарта API и unpause: /users/me -> 401 за 0.04 с OK
после рестарта API и unpause: сообщение -> 401 за 0.01 с OK
2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит
GET история -> 503 за 2.03 с OK
POST сообщение -> 503 за 2.01 с OK
неизвестный токен (не 200!) -> 503 за 2.01 с OK
без Authorization -> 401 за 0.01 с OK
вход по Basic верным паролем -> 503 за 2.01 с OK
/health/live -> 200 за 0.03 с OK
/health/ready -> 503 за 1.01 с OK
3. PostgreSQL запущен: готовность через 15.5 с после остановки
прежний токен -> 200; история: ['до отказа', 'без кэша']
4. PostgreSQL заморожен (pause): запросы получают 503 в пределах общего срока, а не зависают
GET история -> 503 за 2.01 с OK
POST сообщение -> 503 за 2.01 с OK
неизвестный токен (не 200!) -> 503 за 2.01 с OK
вход по Basic -> 503 за 2.01 с OK
/health/ready -> 503 за 1.01 с OK
/health/live -> 200 за 0.01 с OK
готовность через 0.4 с после unpause; история: ['до отказа', 'без кэша']
PASS: отказы Valkey и PostgreSQL обработаны
+17
View File
@@ -0,0 +1,17 @@
{
"lab": 3,
"workload": "closed-loop POST messages; no automatic retries",
"requested_duration_seconds": 30.0,
"elapsed_seconds": 30.235,
"concurrency": 4,
"successful_requests": 1979,
"failed_requests": 0,
"error_ratio": 0.0,
"successful_rps": 65.454,
"successful_latency_ms": {
"p50": 42.184,
"p95": 163.116,
"p99": 201.214
},
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
}
+40
View File
@@ -0,0 +1,40 @@
# persistence: python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080
# date: 2026-11-12T13:12:55Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
$ docker compose ps -a (before)
NAME STATUS
grigoriev-lab3-api-1 Up 32 seconds (healthy)
grigoriev-lab3-api-2 Up 31 seconds (healthy)
grigoriev-lab3-lb-1 Up 24 seconds (healthy)
grigoriev-lab3-migrate-1 Exited (0) 32 seconds ago
grigoriev-lab3-postgres-1 Up 41 seconds (healthy)
grigoriev-lab3-valkey-1 Up 41 seconds (healthy)
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
$ docker compose ps -a (after)
NAME STATUS
grigoriev-lab3-api-1 Up 8 seconds (healthy)
grigoriev-lab3-api-2 Up 7 seconds (healthy)
grigoriev-lab3-lb-1 Up 49 seconds (healthy)
grigoriev-lab3-migrate-1 Exited (0) 8 seconds ago
grigoriev-lab3-postgres-1 Up 18 seconds (healthy)
grigoriev-lab3-valkey-1 Up 18 seconds (healthy)
valkey-1 | 7:M 12 Nov 2026 13:13:02.670 * User requested shutdown...
postgres-1 | 2026-11-12 13:13:02.685 UTC [1] LOG: database system is shut down
postgres-1 | 2026-11-12 13:13:03.428 UTC [29] LOG: database system was shut down at 2026-11-12 13:13:02 UTC
postgres-1 | 2026-11-12 13:13:03.439 UTC [1] LOG: database system is ready to accept connections
api-2 | 2026-11-12 13:12:58,240 INFO messenger: signal 15: readiness off, draining for 3.0s
api-1 | 2026-11-12 13:12:58,241 INFO messenger: signal 15: readiness off, draining for 3.0s
valkey-1 | 7:M 12 Nov 2026 13:13:03.287 * Ready to accept connections tcp
api-2 | 2026-11-12 13:13:01,365 INFO messenger: application stopping
api-2 | 2026-11-12 13:13:18,778 INFO uvicorn.error: Waiting for application startup.
api-1 | 2026-11-12 13:13:01,430 INFO messenger: application stopping
api-2 | 2026-11-12 13:13:18,782 INFO messenger: application started
api-1 | 2026-11-12 13:13:18,757 INFO uvicorn.error: Waiting for application startup.
api-1 | 2026-11-12 13:13:18,759 INFO messenger: application started
$ docker volume ls
grigoriev-lab3_pgdata
+59
View File
@@ -0,0 +1,59 @@
{
"replicas_before": [
"07dbb34db037",
"d4a765ecfdcb"
],
"replicas_after": [
"c47d840c5275",
"7037deead3f3"
],
"update_seconds": 35.1,
"update_exit_code": 0,
"before_5s": {
"seconds": 5.0,
"ok": 345,
"errors": 0,
"rps": 69.0,
"p50_ms": 35.5,
"p95_ms": 145.2,
"p99_ms": 184.0,
"error_kinds": []
},
"during_update": {
"seconds": 35.05,
"ok": 1977,
"errors": 0,
"rps": 56.4,
"p50_ms": 36.8,
"p95_ms": 209.0,
"p99_ms": 297.8,
"error_kinds": []
},
"after_5s": {
"seconds": 5.0,
"ok": 267,
"errors": 0,
"rps": 53.4,
"p50_ms": 52.0,
"p95_ms": 195.3,
"p99_ms": 291.3,
"error_kinds": []
},
"data": {
"confirmed": 2593,
"stored": 2593,
"lost": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"uncertain_at_stop": 0
},
"log": [
"old replicas: 07dbb34db037(image 1468428627d8), d4a765ecfdcb(image 1468428627d8)",
"migrations applied once",
"+ c47d840c5275 (image 1468428627d8) in rotation after 8.6s",
"- 07dbb34db037 stopped and removed after 4.0s",
"+ 7037deead3f3 (image 1468428627d8) in rotation after 7.0s",
"- d4a765ecfdcb stopped and removed after 4.2s",
"new replicas: c47d840c5275(image 1468428627d8), 7037deead3f3(image 1468428627d8)"
]
}
+9
View File
@@ -0,0 +1,9 @@
old replicas: 07dbb34db037(image 1468428627d8), d4a765ecfdcb(image 1468428627d8)
migrations applied once
+ c47d840c5275 (image 1468428627d8) in rotation after 8.6s
- 07dbb34db037 stopped and removed after 4.0s
+ 7037deead3f3 (image 1468428627d8) in rotation after 7.0s
- d4a765ecfdcb stopped and removed after 4.2s
new replicas: c47d840c5275(image 1468428627d8), 7037deead3f3(image 1468428627d8)
rolling update 35.1s: errors=0, rps 69.0 -> 56.4 -> 53.4, lost=0, duplicates=0, all replaced=True
PASS
+23
View File
@@ -0,0 +1,23 @@
# python student-tests/sigterm_check.py; docker compose start api
# date: 2026-11-12T13:19:35Z; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
сообщение с маркером отправлено: HTTP 201; маркер в логах: False
docker stop занял: 3.82 с (лимит 10 с)
код выхода контейнера: 0 (0 — сам завершился по SIGTERM; 137 — убит SIGKILL)
запросы до SIGTERM: 27, все 200: True
запросы после SIGTERM: 130, результаты: ['200']
ответов 5xx за всё время: 0
логи остановки:
2026-11-12 13:18:51,256 INFO messenger: signal 15: readiness off, draining for 3.0s
2026-11-12 13:18:54,309 INFO uvicorn.error: Shutting down
2026-11-12 13:18:54,409 INFO uvicorn.error: Waiting for application shutdown.
2026-11-12 13:18:54,410 INFO messenger: application stopping
2026-11-12 13:18:54,411 INFO uvicorn.error: Application shutdown complete.
2026-11-12 13:18:54,412 INFO uvicorn.error: Finished server process [1]
2026-11-12 13:19:37,890 INFO messenger: signal 15: readiness off, draining for 3.0s
2026-11-12 13:19:40,933 INFO uvicorn.error: Shutting down
2026-11-12 13:19:41,034 INFO uvicorn.error: Waiting for application shutdown.
2026-11-12 13:19:41,034 INFO messenger: application stopping
2026-11-12 13:19:41,036 INFO uvicorn.error: Application shutdown complete.
2026-11-12 13:19:41,036 INFO uvicorn.error: Finished server process [1]
+4
View File
@@ -0,0 +1,4 @@
# python tests/smoke.py --base-url http://127.0.0.1:8080
# date: 2026-11-12T13:12:54Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
+108
View File
@@ -0,0 +1,108 @@
# python -m unittest discover -s student-tests -v
# date: 2026-11-12T13:17:34Z; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
test_duplicate_username (test_api.DuplicateUsernameTest.test_duplicate_username)
Повторная регистрация того же username -> 409 conflict ... ok
test_empty_text (test_api.EmptyMessageTest.test_empty_text)
Пустой текст -> 400 ... ok
test_missing_text (test_api.EmptyMessageTest.test_missing_text)
Тело без поля text -> 400 ... ok
test_text_length_limit (test_api.EmptyMessageTest.test_text_length_limit)
4000 символов можно (эмодзи = 1 символ), 4001 — 400 ... ok
test_whitespace_text (test_api.EmptyMessageTest.test_whitespace_text)
Текст только из пробельных символов -> 400 ... ok
test_member_has_access (test_api.ForeignChatTest.test_member_has_access)
Участник видит чат (контроль: 404 выше не из-за ошибки в тесте) ... ok
test_outsider_cannot_read_chat (test_api.ForeignChatTest.test_outsider_cannot_read_chat)
Посторонний читает чат -> 404, как будто чата нет ... ok
test_outsider_cannot_write_or_read_history (test_api.ForeignChatTest.test_outsider_cannot_write_or_read_history)
Посторонний пишет/читает историю -> 404 ... ok
test_outsider_does_not_see_chat_in_list (test_api.ForeignChatTest.test_outsider_does_not_see_chat_in_list)
Чужой чат не попадает в список чатов ... ok
test_lone_surrogate_is_rejected (test_api.IdentityTest.test_lone_surrogate_is_rejected)
Одиночный суррогат не кодируется в UTF-8 -> 400, а не 500 ... ok
test_nul_character_is_preserved (test_api.IdentityTest.test_nul_character_is_preserved)
U+0000 — допустимый code point: сообщение, display_name и title сохраняются и читаются без изменений ... ok
test_sender_cannot_be_forged (test_api.IdentityTest.test_sender_cannot_be_forged)
sender_id в теле запрещён: отправитель только из сессии ... ok
test_extra_field (test_api.InvalidJsonTest.test_extra_field)
Лишнее поле в теле -> 400 ... ok
test_json_not_object (test_api.InvalidJsonTest.test_json_not_object)
JSON-массив вместо объекта -> 400 ... ok
test_malformed_json (test_api.InvalidJsonTest.test_malformed_json)
Битый JSON -> 400 invalid_request ... ok
test_wrong_type (test_api.InvalidJsonTest.test_wrong_type)
Число вместо строки -> 400 (без тихого приведения типов) ... ok
test_cursor_from_other_chat (test_api.PaginationTest.test_cursor_from_other_chat)
cursor от другого чата -> 400 ... ok
test_invalid_cursor_and_limit (test_api.PaginationTest.test_invalid_cursor_and_limit)
Мусорный cursor и limit вне 1..100 -> 400 ... ok
test_walk_several_pages (test_api.PaginationTest.test_walk_several_pages)
7 сообщений по 3: три страницы, без потерь, повторов и перестановок ... ok
test_authentication_before_validation (test_auth.BearerTest.test_authentication_before_validation)
Аноним с битым JSON на защищённом endpoint получает 401, а не 400; с сессией — 400 ... ok
test_only_bearer_is_accepted (test_auth.BearerTest.test_only_bearer_is_accepted)
Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer ... ok
test_scheme_is_case_insensitive (test_auth.BearerTest.test_scheme_is_case_insensitive)
Схема аутентификации нечувствительна к регистру (RFC 9110) ... ok
test_x_user_id_does_not_override_session (test_auth.BearerTest.test_x_user_id_does_not_override_session)
X-User-Id игнорируется: владелец определяется только токеном ... ok
test_login_rejects_body (test_auth.LoginTest.test_login_rejects_body)
POST /auth/sessions принимает только заголовок, JSON body -> 400 ... ok
test_login_returns_opaque_session (test_auth.LoginTest.test_login_returns_opaque_session)
Вход: 201, token_type=Bearer, токен случайный и не содержит username/UUID ... ok
test_malformed_basic (test_auth.LoginTest.test_malformed_basic)
Нет заголовка, не base64, нет двоеточия, Bearer вместо Basic -> 401 Basic ... ok
test_password_with_colon_and_unicode (test_auth.LoginTest.test_password_with_colon_and_unicode)
Двоеточие и не-ASCII в пароле допустимы: делим только по первому ':' ... ok
test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same)
Неверный пароль и несуществующий пользователь -> одинаковый 401 с Basic challenge ... ok
test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session)
Logout -> 204 без тела; этот токен -> 401, вторая сессия того же пользователя работает ... ok
test_password_is_not_returned (test_auth.RegistrationTest.test_password_is_not_returned)
Ответ регистрации и /users/me не содержат password/hash ... ok
test_password_length_limits (test_auth.RegistrationTest.test_password_length_limits)
Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом ... ok
test_password_required_and_not_blank (test_auth.RegistrationTest.test_password_required_and_not_blank)
Без password или из одних пробелов -> 400 ... ok
test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients)
100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории ... ok
test_parallel_registration_of_same_username (test_concurrency.ConcurrencyTest.test_parallel_registration_of_same_username)
20 одновременных регистраций одного username -> ровно один 201, остальные 409; вход только с паролем победителя ... ok
test_chat_creation_is_rolled_back (test_db.DatabaseTest.test_chat_creation_is_rolled_back)
Неизвестный участник: INSERT chats выполнен, INSERT chat_members упал по FK, всё откатано ... ok
test_history_query_uses_index (test_db.DatabaseTest.test_history_query_uses_index)
Запрос страницы истории идёт по индексу (chat_id, created_at, id), без Sort ... ok
test_migrations_are_idempotent (test_db.DatabaseTest.test_migrations_are_idempotent)
Повторный запуск миграций ничего не меняет и завершается успешно ... ok
test_secrets_are_not_stored_in_plaintext (test_db.DatabaseTest.test_secrets_are_not_stored_in_plaintext)
В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен ... ok
test_json_formatting_does_not_matter (test_idempotency.IdempotencyTest.test_json_formatting_does_not_matter)
Порядок/пробелы в JSON семантически равны: повтор с другим форматированием -> тот же Message ... ok
test_key_scope_is_user_and_chat (test_idempotency.IdempotencyTest.test_key_scope_is_user_and_chat)
Одинаковый ключ у разных пользователей и в разных чатах — независимые сообщения ... ok
test_missing_or_invalid_key (test_idempotency.IdempotencyTest.test_missing_or_invalid_key)
Нет ключа, пустой, недопустимые символы, длиннее 128 -> 400 ... ok
test_other_body_with_same_key_conflicts (test_idempotency.IdempotencyTest.test_other_body_with_same_key_conflicts)
Тот же ключ с другим телом -> 409, второе сообщение не создаётся ... ok
test_parallel_retries_through_replicas_create_one_message (test_idempotency.IdempotencyTest.test_parallel_retries_through_replicas_create_one_message)
20 одновременных POST с одним ключом через LB (разные реплики) -> ровно одно сообщение, все 201 с одним id ... ok
test_replay_rechecks_session_and_access (test_idempotency.IdempotencyTest.test_replay_rechecks_session_and_access)
Повтор снова проверяет сессию и доступ: после logout -> 401, посторонний с тем же ключом -> 404 ... ok
test_replay_returns_same_message (test_idempotency.IdempotencyTest.test_replay_returns_same_message)
Повтор того же запроса с тем же ключом -> тот же 201 и тот же Message, дубля нет ... ok
test_every_api_response_has_instance_id (test_replicas.ReplicasTest.test_every_api_response_has_instance_id)
X-Instance-Id есть и в успешных ответах, и в ошибках API, и в health ... ok
test_one_session_is_served_by_several_replicas (test_replicas.ReplicasTest.test_one_session_is_served_by_several_replicas)
Один токен без повторного входа обслуживается разными репликами (X-Instance-Id), все ответы 200 ... ok
test_write_on_one_replica_is_read_on_another (test_replicas.ReplicasTest.test_write_on_one_replica_is_read_on_another)
Сообщение, подтверждённое одной репликой, сразу видно при чтении через другую ... ok
----------------------------------------------------------------------
Ran 48 tests in 31.341s
OK
отправлено 201: 100, уникальных id: 100, прочитано: 100 за 4 страниц(ы)
20 повторов: реплики ['4c764ef640a6', '540fcfe80e6c'], сообщений в истории: 1
+30
View File
@@ -0,0 +1,30 @@
# topology and X-Instance-Id through LB
# date: 2026-11-12T13:12:49Z; fresh volumes; host: Windows 10, Docker Desktop 27.2.0, VM 12 CPU / 1.9 GiB; api 2 x (0.5 CPU, 320M)
SERVICE NAME STATUS PORTS
api grigoriev-lab3-api-1 Up 25 seconds (healthy)
api grigoriev-lab3-api-2 Up 25 seconds (healthy)
lb grigoriev-lab3-lb-1 Up 18 seconds (healthy) 127.0.0.1:8080->8080/tcp, 127.0.0.1:8404->8404/tcp
migrate grigoriev-lab3-migrate-1 Exited (0) 25 seconds ago
postgres grigoriev-lab3-postgres-1 Up 34 seconds (healthy)
valkey grigoriev-lab3-valkey-1 Up 34 seconds (healthy)
$ docker compose ps -q api (container id prefix = X-Instance-Id)
4c764ef640a6
540fcfe80e6c
$ 6 x GET /health/ready through LB
x-instance-id: 540fcfe80e6c
x-instance-id: 4c764ef640a6
x-instance-id: 540fcfe80e6c
x-instance-id: 4c764ef640a6
x-instance-id: 540fcfe80e6c
x-instance-id: 4c764ef640a6
$ docker stats --no-stream (limits)
NAME CPU % MEM USAGE / LIMIT
grigoriev-lab3-lb-1 0.32% 18.62MiB / 128MiB
grigoriev-lab3-api-1 45.81% 58.05MiB / 320MiB
grigoriev-lab3-api-2 7.08% 64.34MiB / 320MiB
grigoriev-lab3-postgres-1 0.41% 45.63MiB / 384MiB
grigoriev-lab3-valkey-1 0.31% 15.56MiB / 96MiB
+53
View File
@@ -0,0 +1,53 @@
global
log stdout format raw local0 info
maxconn 2000
defaults
mode http
log global
option httplog
option http-server-close
option forwardfor
option redispatch
retries 2
retry-on conn-failure
timeout connect 1s
timeout client 30s
timeout server 10s
timeout check 1s
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 2
timeout resolve 1s
timeout retry 1s
hold valid 2s
hold obsolete 2s
hold nx 2s
accepted_payload_size 8192
frontend messenger
bind :8080
monitor-uri /lb/health
use_backend api_live if { nbsrv(api) lt 1 }
default_backend api
backend api
balance roundrobin
option httpchk GET /health/ready
http-check expect status 200
default-server check inter 1s fall 2 rise 2 resolvers docker init-addr none
server-template api 1-4 api:8080
backend api_live
balance roundrobin
option httpchk GET /health/live
http-check expect status 200
default-server check inter 1s fall 2 rise 2 resolvers docker init-addr none
server-template live 1-4 api:8080
listen stats
bind :8404
stats enable
stats uri /
stats refresh 2s
+46
View File
@@ -0,0 +1,46 @@
CREATE TABLE users (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_by uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id),
user_id uuid NOT NULL REFERENCES users (id),
position smallint NOT NULL CHECK (position >= 1),
PRIMARY KEY (chat_id, user_id),
UNIQUE (chat_id, position)
);
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members (chat_id, user_id)
);
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL,
CHECK (expires_at > created_at)
);
CREATE INDEX sessions_user_idx ON sessions (user_id);
CREATE INDEX sessions_expires_idx ON sessions (expires_at);
+14
View File
@@ -0,0 +1,14 @@
ALTER TABLE users
DROP CONSTRAINT users_display_name_check,
ALTER COLUMN display_name TYPE bytea USING convert_to(display_name, 'UTF8'),
ADD CONSTRAINT users_display_name_check CHECK (octet_length(display_name) BETWEEN 1 AND 400);
ALTER TABLE chats
DROP CONSTRAINT chats_title_check,
ALTER COLUMN title TYPE bytea USING convert_to(title, 'UTF8'),
ADD CONSTRAINT chats_title_check CHECK (octet_length(title) BETWEEN 1 AND 400);
ALTER TABLE messages
DROP CONSTRAINT messages_text_check,
ALTER COLUMN text TYPE bytea USING convert_to(text, 'UTF8'),
ADD CONSTRAINT messages_text_check CHECK (octet_length(text) BETWEEN 1 AND 16000);
+6
View File
@@ -0,0 +1,6 @@
CREATE TABLE session_revocations (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
expires_at timestamptz NOT NULL
);
CREATE INDEX session_revocations_expires_idx ON session_revocations (expires_at);
+11
View File
@@ -0,0 +1,11 @@
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL REFERENCES users (id),
scope text NOT NULL,
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
request_hash bytea NOT NULL CHECK (octet_length(request_hash) = 32),
message_id uuid REFERENCES messages (id),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (user_id, scope, key)
);
CREATE INDEX idempotency_keys_created_idx ON idempotency_keys (created_at);
+19
View File
@@ -0,0 +1,19 @@
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==25.1.0
argon2-cffi-bindings==26.1.0
cffi==2.1.1
click==8.5.0
fastapi==0.115.6
h11==0.16.0
idna==3.20
psycopg==3.3.6
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.12
pydantic==2.10.4
pydantic_core==2.27.2
redis==8.1.0
starlette==0.41.3
typing_extensions==4.16.0
uvicorn==0.34.0
+27
View File
@@ -0,0 +1,27 @@
import os
from pathlib import Path
import secrets
ROOT = Path(__file__).resolve().parents[1]
SECRETS = ROOT / 'secrets'
def write(name, value):
path = SECRETS / name
if path.exists():
print('keep existing secrets/%s' % name)
return path.read_text(encoding='utf-8').strip()
path.write_text(value + '\n', encoding='utf-8')
os.chmod(path, 0o644)
print('created secrets/%s' % name)
return value
def main():
SECRETS.mkdir(exist_ok=True)
password = write('postgres_password', secrets.token_hex(24))
write('database_url', 'postgresql://messenger:%s@postgres:5432/messenger' % password)
if __name__ == '__main__':
main()
+6
View File
@@ -0,0 +1,6 @@
@echo off
cd /d "%~dp0.."
docker compose stop api || exit /b 1
docker compose restart postgres valkey || exit /b 1
docker compose up -d --no-build --no-recreate --wait postgres valkey || exit /b 1
docker compose start api || exit /b 1
+7
View File
@@ -0,0 +1,7 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose stop api
docker compose restart postgres valkey
docker compose up -d --no-build --no-recreate --wait postgres valkey
docker compose start api
+76
View File
@@ -0,0 +1,76 @@
"""Поочерёдная замена API-реплик без остановки сервиса.
python scripts/rolling_update.py # пересобрать образ и заменить реплики по одной
python scripts/rolling_update.py --no-build # заменить на текущий образ
1. Один раз применяет миграции (отдельный контейнер migrate; совместимые, только добавляющие изменения).
2. Для каждой старой реплики: поднимает одну новую (--scale +1, --no-recreate), ждёт, пока LB начнёт
отправлять на неё трафик, затем штатно останавливает старую (SIGTERM → вывод из ротации → завершение)
и удаляет её контейнер. Число реплик в ротации не опускается ниже исходного.
"""
import argparse
from pathlib import Path
import subprocess
import sys
import time
import urllib.request
ROOT = Path(__file__).resolve().parents[1]
BASE_URL = 'http://127.0.0.1:8080'
def compose(*args):
return subprocess.run(['docker', 'compose', *args], cwd=ROOT, check=True, capture_output=True, text=True).stdout
def running_api():
return compose('ps', '-q', 'api').split()
def instance_of_next_response():
try:
with urllib.request.urlopen(BASE_URL + '/health/ready', timeout=2) as response:
return response.headers.get('X-Instance-Id')
except OSError:
return None
def wait_in_rotation(container, seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
if instance_of_next_response() == container[:12]:
return
time.sleep(0.1)
raise SystemExit('new replica %s did not enter LB rotation' % container[:12])
def image_of(container):
return subprocess.run(['docker', 'inspect', '-f', '{{.Image}}', container], capture_output=True, text=True).stdout.strip()[7:19]
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--no-build', action='store_true')
args = parser.parse_args()
old = running_api()
print('old replicas:', ', '.join('%s(image %s)' % (c[:12], image_of(c)) for c in old))
if not args.no_build:
compose('build', 'api')
compose('run', '--rm', '--no-deps', 'migrate')
print('migrations applied once')
for container in old:
before = set(running_api())
compose('up', '-d', '--no-deps', '--no-recreate', '--scale', 'api=%d' % (len(before) + 1), 'api')
new = (set(running_api()) - before).pop()
started = time.monotonic()
wait_in_rotation(new)
print('+ %s (image %s) in rotation after %.1fs' % (new[:12], image_of(new), time.monotonic() - started))
started = time.monotonic()
subprocess.run(['docker', 'stop', '-t', '15', container], check=True, capture_output=True)
subprocess.run(['docker', 'rm', container], check=True, capture_output=True)
print('- %s stopped and removed after %.1fs' % (container[:12], time.monotonic() - started))
print('new replicas:', ', '.join('%s(image %s)' % (c[:12], image_of(c)) for c in running_api()))
if __name__ == '__main__':
sys.exit(main())
+11
View File
@@ -0,0 +1,11 @@
@echo off
if "%TARGET_INSTANCE_ID%"=="" exit /b 2
cd /d "%~dp0.."
for /f %%i in ('docker compose ps -q api') do (
echo %%i| findstr /b /i "%TARGET_INSTANCE_ID%" >nul && (
docker stop -t 10 %%i >nul
exit /b 0
)
)
echo no running api replica matches TARGET_INSTANCE_ID 1>&2
exit /b 1
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
cd "$(dirname "$0")/.."
for id in $(docker compose ps -q api); do
case "$id" in
"$TARGET_INSTANCE_ID"*)
docker stop -t 10 "$id" >/dev/null
exit 0
;;
esac
done
echo "no running api replica matches TARGET_INSTANCE_ID" >&2
exit 1
+175
View File
@@ -0,0 +1,175 @@
from contextlib import asynccontextmanager
import hashlib
import json
import logging
import re
import socket
import time
from typing import Annotated, Optional
import uuid
from fastapi import Depends, FastAPI, Header, Query, Request, Response
from fastapi.exceptions import RequestValidationError
import psycopg
from starlette.concurrency import run_in_threadpool
from starlette.exceptions import HTTPException as StarletteHTTPException
import auth
from cache import cache
from config import settings
from db import connection, pool, request_deadline
from errors import ApiError, error_response
from models import CreateChat, CreateMessage, CreateUser
import store
log = logging.getLogger('messenger')
Limit = Annotated[int, Query(ge=1, le=100)]
Cursor = Annotated[Optional[str], Query(min_length=1)]
INSTANCE_ID = socket.gethostname()
IDEMPOTENCY_KEY = re.compile(r'^[A-Za-z0-9._:-]{1,128}$')
PUBLIC = {('POST', '/api/v1/users'), ('POST', '/api/v1/auth/sessions')}
state = {'ready': False}
@asynccontextmanager
async def lifespan(app):
pool.open(wait=False)
log.info('instance %s, session cache: %s', INSTANCE_ID, 'valkey' if cache.client else 'disabled')
state['ready'] = True
log.info('application started')
yield
state['ready'] = False
log.info('application stopping')
pool.close(timeout=2)
app = FastAPI(title='MTUSI Messenger lab2', lifespan=lifespan)
@app.middleware('http')
async def request_context(request: Request, call_next):
request.state.request_id = uuid.uuid4().hex
request_deadline.set({'deadline': None})
started = time.perf_counter()
try:
response = await call_next(request)
except Exception:
log.exception('unhandled error request_id=%s', request.state.request_id)
response = error_response(request, 500, 'Внутренняя ошибка сервера')
response.headers['X-Request-Id'] = request.state.request_id
response.headers['X-Instance-Id'] = INSTANCE_ID
log.info('%s %s -> %d %.1fms request_id=%s', request.method, request.url.path,
response.status_code, (time.perf_counter() - started) * 1000, request.state.request_id)
return response
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
return error_response(request, exc.status, exc.message, exc.headers)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
messages = {404: 'Ресурс не найден', 405: 'Метод не поддерживается'}
return error_response(request, exc.status_code, messages.get(exc.status_code, 'Ошибка запроса'))
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
if request.url.path.startswith('/api/v1/') and (request.method, request.url.path) not in PUBLIC:
try:
await run_in_threadpool(auth.authenticate, request.headers.get('authorization'))
except ApiError as error:
return error_response(request, error.status, error.message, error.headers)
except (psycopg.OperationalError, psycopg.InterfaceError):
return error_response(request, 503, 'Хранилище временно недоступно')
errors = exc.errors()
where = '.'.join(str(part) for part in errors[0]['loc']) if errors else 'request'
return error_response(request, 400, 'Некорректный запрос: ' + where)
@app.exception_handler(psycopg.OperationalError)
@app.exception_handler(psycopg.InterfaceError)
async def handle_database_unavailable(request: Request, exc: psycopg.Error):
log.warning('database unavailable: %s request_id=%s', type(exc).__name__, request.state.request_id)
return error_response(request, 503, 'Хранилище временно недоступно')
@app.get('/health/live')
async def liveness():
return {'status': 'ok'}
@app.get('/health/ready')
def readiness():
if not state['ready']:
raise ApiError(503, 'Сервис не готов')
with connection(limit=1) as conn:
conn.execute('SELECT 1')
return {'status': 'ok'}
def current_session(authorization: Annotated[Optional[str], Header()] = None):
return auth.authenticate(authorization)
def current_user(session: Annotated[dict, Depends(current_session)]):
return session['user']
@app.post('/api/v1/users', status_code=201)
def register_user(body: CreateUser):
return store.create_user(body.username, body.display_name, auth.hash_password(body.password))
@app.post('/api/v1/auth/sessions', status_code=201)
def create_session(request: Request, authorization: Annotated[Optional[str], Header()] = None):
if request.headers.get('content-length', '0') != '0' or 'transfer-encoding' in request.headers:
raise ApiError(400, 'Вход принимает только заголовок Authorization: Basic, без тела')
return auth.login(authorization)
@app.delete('/api/v1/auth/sessions/current', status_code=204)
def delete_session(session: Annotated[dict, Depends(current_session)]):
auth.logout(session)
return Response(status_code=204)
@app.get('/api/v1/users/me')
def get_me(user: Annotated[dict, Depends(current_user)]):
return user
@app.post('/api/v1/chats', status_code=201)
def create_chat(body: CreateChat, user: Annotated[dict, Depends(current_user)]):
return store.create_chat(user['id'], body.title, body.member_ids)
@app.get('/api/v1/chats')
def list_chats(user: Annotated[dict, Depends(current_user)], limit: Limit = 50, cursor: Cursor = None):
return store.list_chats(user['id'], cursor, limit)
@app.get('/api/v1/chats/{chat_id}')
def get_chat(chat_id: uuid.UUID, user: Annotated[dict, Depends(current_user)]):
return store.get_chat(str(chat_id), user['id'])
@app.post('/api/v1/chats/{chat_id}/messages', status_code=201)
def create_message(chat_id: uuid.UUID, body: CreateMessage, user: Annotated[dict, Depends(current_user)],
idempotency_key: Annotated[Optional[str], Header()] = None):
if idempotency_key is None or not IDEMPOTENCY_KEY.match(idempotency_key):
raise ApiError(400, 'Нужен заголовок Idempotency-Key: [A-Za-z0-9._:-]{1,128}')
canonical = json.dumps({'text': body.text, 'attachment_ids': []}, ensure_ascii=False, sort_keys=True)
return store.create_message(str(chat_id), user['id'], body.text, idempotency_key,
hashlib.sha256(canonical.encode('utf-8')).digest(), settings.idempotency_ttl)
@app.get('/api/v1/chats/{chat_id}/messages')
def list_messages(chat_id: uuid.UUID, user: Annotated[dict, Depends(current_user)],
limit: Limit = 50, cursor: Cursor = None):
return store.list_messages(str(chat_id), user['id'], cursor, limit)
+120
View File
@@ -0,0 +1,120 @@
import base64
import binascii
import hashlib
import re
import secrets
import threading
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
import psycopg
from cache import REVOKED, cache
from config import settings
from db import iso
from errors import BASIC_CHALLENGE, BEARER_CHALLENGE, unauthorized
import store
REVOCATION_MARGIN_SECONDS = 5
USERNAME = re.compile(r'^[a-z0-9_]{3,32}$')
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
hashing = threading.BoundedSemaphore(settings.password_hash_concurrency)
DUMMY_HASH = hasher.hash('dummy-password-for-equal-timing')
def hash_password(password):
with hashing:
return hasher.hash(password)
def verify_password(password_hash, password):
try:
with hashing:
return hasher.verify(password_hash, password)
except (VerificationError, InvalidHashError):
return False
def token_hash(token):
return hashlib.sha256(token.encode('ascii')).digest()
def parse_credentials(header, scheme):
name, _, value = (header or '').strip().partition(' ')
value = value.strip()
if name.lower() != scheme or not value or ' ' in value:
return None
return value
def parse_basic(header):
value = parse_credentials(header, 'basic')
if value is None:
return None
try:
decoded = base64.b64decode(value, validate=True).decode('utf-8')
except (binascii.Error, UnicodeDecodeError):
return None
username, separator, password = decoded.partition(':')
if not separator or not USERNAME.match(username) or not 12 <= len(password) <= 128:
return None
return username, password
def login(header):
credentials = parse_basic(header)
row = store.find_credentials(credentials[0]) if credentials else None
if row is None:
verify_password(DUMMY_HASH, credentials[1] if credentials else 'x' * 12)
raise unauthorized(BASIC_CHALLENGE, 'Неверное имя пользователя или пароль')
if not verify_password(row['password_hash'], credentials[1]):
raise unauthorized(BASIC_CHALLENGE, 'Неверное имя пользователя или пароль')
token = secrets.token_urlsafe(32)
digest = token_hash(token)
expires_at = store.create_session(row['id'], digest, settings.session_ttl)
user = store.user_out(row)
cache.put(digest, user, expires_at)
return {'token': token, 'token_type': 'Bearer', 'expires_at': iso(expires_at), 'user': user}
def authenticate(header):
token = parse_credentials(header, 'bearer')
if token is None or not token.isascii():
raise unauthorized(BEARER_CHALLENGE)
digest = token_hash(token)
if cache.client is not None and not cache.trusted():
sync_revocations()
user = cache.get(digest)
if user == REVOKED:
raise unauthorized(BEARER_CHALLENGE)
if user is None:
row = store.session_user(digest)
if row is None:
raise unauthorized(BEARER_CHALLENGE)
user = store.user_out(row)
cache.put(digest, user, row['expires_at'])
return {'user': user, 'token_hash': digest}
def sync_revocations():
errors_before = cache.errors
pending = store.pending_revocations()
if not cache.revoke_all(pending):
return
if pending:
try:
store.clear_revocations(pending)
except psycopg.Error:
pass
cache.mark_synced(errors_before)
def logout(session):
store.revoke_session(session['token_hash'], cache.max_ttl + REVOCATION_MARGIN_SECONDS)
if cache.revoke(session['token_hash']):
try:
store.clear_revocations([session['token_hash']])
except psycopg.Error:
pass
+89
View File
@@ -0,0 +1,89 @@
from datetime import datetime, timezone
import json
import logging
import threading
import time
import redis
from config import settings
log = logging.getLogger('messenger.cache')
BYPASS_SECONDS = 5
REVOKED = 'revoked'
FAILED = object()
class SessionCache:
def __init__(self, url, max_ttl):
self.client = redis.Redis.from_url(url, socket_timeout=0.2, socket_connect_timeout=0.2,
decode_responses=True) if url else None
self.max_ttl = max_ttl
self.bypass_until = 0.0
self.lock = threading.Lock()
self.errors = 0
self.synced = False
self.synced_at = 0.0
def _run(self, action, force=False):
if self.client is None:
return None
if not force and time.monotonic() < self.bypass_until:
return FAILED
try:
return action(self.client)
except redis.RedisError as error:
log.warning('session cache unavailable (%s), using PostgreSQL for %ds', type(error).__name__, BYPASS_SECONDS)
self.bypass_until = time.monotonic() + BYPASS_SECONDS
with self.lock:
self.errors += 1
self.synced = False
return FAILED
@staticmethod
def key(token_hash):
return 'session:' + token_hash.hex()
def mark_synced(self, errors_before):
with self.lock:
if self.errors == errors_before:
self.synced = True
self.synced_at = time.monotonic()
def trusted(self):
return self.synced and time.monotonic() - self.synced_at < settings.revocation_sync_seconds
def get(self, token_hash):
if not self.trusted():
return None
raw = self._run(lambda c: c.get(self.key(token_hash)))
if raw is FAILED or not raw or raw == REVOKED:
return REVOKED if raw == REVOKED else None
entry = json.loads(raw)
if entry['expires_at'] <= time.time():
return None
return entry['user']
def put(self, token_hash, user, expires_at: datetime):
remaining = int((expires_at - datetime.now(timezone.utc)).total_seconds())
ttl = min(self.max_ttl, remaining)
if ttl <= 0:
return
value = json.dumps({'user': user, 'expires_at': expires_at.timestamp()}, ensure_ascii=False)
self._run(lambda c: c.set(self.key(token_hash), value, ex=ttl, nx=True))
def revoke(self, token_hash):
return self._run(lambda c: c.set(self.key(token_hash), REVOKED, ex=self.max_ttl), force=True) is not FAILED
def revoke_all(self, token_hashes):
def write(client):
with client.pipeline(transaction=False) as pipe:
for token_hash in token_hashes:
pipe.set(self.key(token_hash), REVOKED, ex=self.max_ttl)
pipe.execute()
return True
return not token_hashes or self._run(write) is not FAILED
cache = SessionCache(settings.cache_url, settings.session_cache_ttl)
+42
View File
@@ -0,0 +1,42 @@
import os
def setting(name, default=None):
path = os.environ.get(name + '_FILE')
if path:
with open(path, encoding='utf-8') as file:
return file.read().strip()
return os.environ.get(name, default)
def positive_int(name, default):
value = int(os.environ.get(name, default))
if value <= 0:
raise SystemExit('%s must be a positive integer' % name)
return value
class Settings:
def __init__(self):
self.host = os.environ.get('APP_HOST', '0.0.0.0')
self.port = positive_int('APP_PORT', '8080')
self.env = os.environ.get('APP_ENV', 'lab')
self.shutdown_timeout = positive_int('APP_SHUTDOWN_TIMEOUT', '5')
self.database_url = setting('DATABASE_URL')
self.cache_url = setting('CACHE_URL') or None
self.session_ttl = positive_int('SESSION_TTL_SECONDS', '3600')
self.session_cache_ttl = positive_int('SESSION_CACHE_TTL_SECONDS', '60')
self.db_pool_min = positive_int('DB_POOL_MIN', '1')
self.db_pool_max = positive_int('DB_POOL_MAX', '10')
self.db_pool_timeout = float(os.environ.get('DB_POOL_TIMEOUT_SECONDS', '2'))
self.db_statement_timeout_ms = positive_int('DB_STATEMENT_TIMEOUT_MS', '3000')
self.db_request_timeout = float(os.environ.get('DB_REQUEST_TIMEOUT_SECONDS', '4'))
self.drain_seconds = float(os.environ.get('APP_DRAIN_SECONDS', '3'))
self.idempotency_ttl = positive_int('IDEMPOTENCY_TTL_SECONDS', '86400')
self.revocation_sync_seconds = float(os.environ.get('REVOCATION_SYNC_SECONDS', '1'))
self.password_hash_concurrency = positive_int('PASSWORD_HASH_CONCURRENCY', '4')
if not self.database_url:
raise SystemExit('DATABASE_URL or DATABASE_URL_FILE is required')
settings = Settings()
+127
View File
@@ -0,0 +1,127 @@
from contextlib import contextmanager
import contextvars
from datetime import timezone
import itertools
import logging
import os
import socket
import threading
import time
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from config import settings
log = logging.getLogger('messenger.db')
request_deadline = contextvars.ContextVar('request_deadline', default=None)
CHECK_SECONDS = 1
def abort(conn):
try:
sock = socket.socket(fileno=os.dup(conn.fileno()))
except (OSError, psycopg.Error):
return
try:
sock.shutdown(socket.SHUT_RDWR)
except OSError:
pass
finally:
sock.close()
class Watchdog:
def __init__(self):
self.cond = threading.Condition()
self.armed = {}
self.ids = itertools.count()
threading.Thread(target=self.loop, name='db-watchdog', daemon=True).start()
@contextmanager
def guard(self, conn, seconds):
key = next(self.ids)
with self.cond:
self.armed[key] = (time.monotonic() + seconds, conn)
self.cond.notify()
try:
yield
finally:
with self.cond:
self.armed.pop(key, None)
def loop(self):
with self.cond:
while True:
now = time.monotonic()
for key, (deadline, conn) in list(self.armed.items()):
if deadline <= now:
del self.armed[key]
log.warning('database did not answer in time, aborting connection')
abort(conn)
wake = min((deadline for deadline, _ in self.armed.values()), default=now + 60)
self.cond.wait(max(wake - now, 0.01))
watchdog = Watchdog()
def check(conn):
with watchdog.guard(conn, CHECK_SECONDS):
ConnectionPool.check_connection(conn)
pool = ConnectionPool(
settings.database_url,
min_size=settings.db_pool_min,
max_size=settings.db_pool_max,
timeout=settings.db_pool_timeout,
check=check,
open=False,
name='messenger',
kwargs={
'connect_timeout': 3,
'row_factory': dict_row,
'options': '-c timezone=UTC -c statement_timeout=%d' % settings.db_statement_timeout_ms,
},
)
def remaining(limit=None):
budget = request_deadline.get()
if budget is None:
left = settings.db_request_timeout
else:
if budget['deadline'] is None:
budget['deadline'] = time.monotonic() + settings.db_request_timeout
left = budget['deadline'] - time.monotonic()
if limit is not None:
left = min(left, limit)
if left <= 0:
raise psycopg.OperationalError('request deadline exceeded')
return left
@contextmanager
def connection(limit=None):
conn = pool.getconn(timeout=min(settings.db_pool_timeout, remaining(limit)))
try:
with watchdog.guard(conn, remaining(limit)):
try:
yield conn
except BaseException:
try:
conn.rollback()
except psycopg.Error:
pass
raise
conn.commit()
finally:
pool.putconn(conn)
def iso(value):
return value.astimezone(timezone.utc).strftime('%Y-%m-%dT%H:%M:%S.%fZ')
+37
View File
@@ -0,0 +1,37 @@
from fastapi import Request
from fastapi.responses import JSONResponse
CODES = {
400: 'invalid_request',
401: 'unauthorized',
404: 'not_found',
409: 'conflict',
413: 'payload_too_large',
415: 'unsupported_media_type',
429: 'rate_limited',
500: 'internal_error',
503: 'unavailable',
}
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
class ApiError(Exception):
def __init__(self, status, message, headers=None):
super().__init__(message)
self.status = status
self.message = message
self.headers = headers
def unauthorized(challenge, message='Нужна действительная сессия'):
return ApiError(401, message, {'WWW-Authenticate': challenge})
def error_response(request: Request, status, message, headers=None):
request_id = getattr(request.state, 'request_id', '-')
body = {'error': {'code': CODES.get(status, 'invalid_request'), 'message': message, 'request_id': request_id}}
if status == 401 and not headers:
headers = {'WWW-Authenticate': BEARER_CHALLENGE}
return JSONResponse(body, status_code=status, headers=headers)
+34
View File
@@ -0,0 +1,34 @@
import logging
import sys
import threading
import uvicorn
from config import settings
class DrainingServer(uvicorn.Server):
def handle_exit(self, sig, frame):
from app import state
if not state['ready'] or settings.drain_seconds <= 0:
return super().handle_exit(sig, frame)
state['ready'] = False
logging.getLogger('messenger').info('signal %s: readiness off, draining for %.1fs', sig, settings.drain_seconds)
threading.Timer(settings.drain_seconds, super().handle_exit, (sig, frame)).start()
def main():
logging.basicConfig(stream=sys.stdout, level=logging.INFO,
format='%(asctime)s %(levelname)s %(name)s: %(message)s')
logging.getLogger('messenger').info('config host=%s port=%d env=%s session_ttl=%ds session_cache_ttl=%ds',
settings.host, settings.port, settings.env,
settings.session_ttl, settings.session_cache_ttl)
from app import app
config = uvicorn.Config(app, host=settings.host, port=settings.port, access_log=False, log_config=None,
timeout_graceful_shutdown=settings.shutdown_timeout)
DrainingServer(config).run()
if __name__ == '__main__':
main()
+47
View File
@@ -0,0 +1,47 @@
import logging
from pathlib import Path
import sys
import time
import psycopg
from config import settings
MIGRATIONS = Path(__file__).resolve().parent.parent / 'migrations'
LOCK_ID = 20260002
log = logging.getLogger('migrate')
def connect(attempts=30):
for attempt in range(1, attempts + 1):
try:
return psycopg.connect(settings.database_url, autocommit=True, connect_timeout=3)
except psycopg.OperationalError:
if attempt == attempts:
raise
log.info('database is not ready, retry %d/%d', attempt, attempts)
time.sleep(1)
def main():
logging.basicConfig(stream=sys.stdout, level=logging.INFO, format='%(asctime)s %(name)s: %(message)s')
with connect() as conn:
conn.execute('SELECT pg_advisory_lock(%s)', (LOCK_ID,))
conn.execute('CREATE TABLE IF NOT EXISTS schema_migrations ('
'version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())')
applied = {row[0] for row in conn.execute('SELECT version FROM schema_migrations')}
for path in sorted(MIGRATIONS.glob('*.sql')):
if path.stem in applied:
log.info('skip %s: already applied', path.stem)
continue
with conn.transaction():
conn.execute(path.read_text(encoding='utf-8'))
conn.execute('INSERT INTO schema_migrations (version) VALUES (%s)', (path.stem,))
log.info('applied %s', path.stem)
conn.execute('SELECT pg_advisory_unlock(%s)', (LOCK_ID,))
log.info('schema is up to date')
if __name__ == '__main__':
main()
+45
View File
@@ -0,0 +1,45 @@
from pydantic import BaseModel, ConfigDict, Field, field_validator
class StrictModel(BaseModel):
model_config = ConfigDict(extra='forbid', strict=True)
def not_blank(value):
if not value.strip():
raise ValueError('must not be blank')
try:
value.encode('utf-8')
except UnicodeEncodeError:
raise ValueError('must be valid Unicode') from None
return value
class CreateUser(StrictModel):
username: str = Field(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('display_name', 'password')
@classmethod
def not_blank_fields(cls, value):
return not_blank(value)
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[str] = Field(min_length=1, max_length=100)
@field_validator('title')
@classmethod
def title_not_blank(cls, value):
return not_blank(value)
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
@field_validator('text')
@classmethod
def text_not_blank(cls, value):
return not_blank(value)
+31
View File
@@ -0,0 +1,31 @@
import base64
from datetime import datetime
import json
import uuid
from errors import ApiError
def encode_cursor(scope, item):
raw = json.dumps({'s': scope, 't': item['created_at'], 'i': item['id']}, separators=(',', ':'))
return base64.urlsafe_b64encode(raw.encode()).decode().rstrip('=')
def decode_cursor(scope, cursor):
try:
padded = cursor + '=' * (-len(cursor) % 4)
data = json.loads(base64.urlsafe_b64decode(padded.encode('ascii')))
if data['s'] != scope or not isinstance(data['t'], str) or not isinstance(data['i'], str):
raise ValueError
created_at = datetime.fromisoformat(data['t'])
if created_at.tzinfo is None:
raise ValueError
return created_at, uuid.UUID(data['i'])
except (ValueError, TypeError, KeyError, AttributeError):
raise ApiError(400, 'Некорректный cursor') from None
def page(items, scope, limit):
chunk = items[:limit]
has_more = len(items) > limit
return {'items': chunk, 'next_cursor': encode_cursor(scope, chunk[-1]) if has_more else None}
+186
View File
@@ -0,0 +1,186 @@
import uuid
from psycopg import errors
from db import connection, iso
from errors import ApiError
from pagination import decode_cursor, page
USER_COLUMNS = 'u.id, u.username, u.display_name, u.created_at'
MESSAGE_COLUMNS = 'id, chat_id, sender_id, text, created_at'
CHAT_SELECT = ('SELECT c.id, c.title, c.created_at, '
'ARRAY(SELECT m.user_id FROM chat_members m WHERE m.chat_id = c.id ORDER BY m.position) AS member_ids '
'FROM chats c ')
def utf8(value):
return value.encode('utf-8')
def unicode(value):
return bytes(value).decode('utf-8')
def user_out(row):
return {'id': str(row['id']), 'username': row['username'],
'display_name': unicode(row['display_name']), 'created_at': iso(row['created_at'])}
def chat_out(row):
return {'id': str(row['id']), 'title': unicode(row['title']),
'member_ids': [str(m) for m in row['member_ids']], 'created_at': iso(row['created_at'])}
def message_out(row):
return {'id': str(row['id']), 'chat_id': str(row['chat_id']), 'sender_id': str(row['sender_id']),
'text': unicode(row['text']), 'created_at': iso(row['created_at'])}
def create_user(username, display_name, password_hash):
try:
with connection() as conn:
row = conn.execute(
'INSERT INTO users AS u (username, display_name, password_hash) VALUES (%s, %s, %s) '
'RETURNING ' + USER_COLUMNS,
(username, utf8(display_name), password_hash)).fetchone()
except errors.UniqueViolation:
raise ApiError(409, 'Имя пользователя уже занято') from None
return user_out(row)
def find_credentials(username):
with connection() as conn:
return conn.execute('SELECT ' + USER_COLUMNS + ', u.password_hash FROM users u WHERE u.username = %s',
(username,)).fetchone()
def create_session(user_id, token_hash, ttl_seconds):
with connection() as conn:
conn.execute('DELETE FROM sessions WHERE user_id = %s AND expires_at <= now()', (user_id,))
return conn.execute(
'INSERT INTO sessions (token_hash, user_id, expires_at) '
'VALUES (%s, %s, now() + make_interval(secs => %s)) RETURNING expires_at',
(token_hash, user_id, ttl_seconds)).fetchone()['expires_at']
def session_user(token_hash):
with connection() as conn:
return conn.execute(
'SELECT ' + USER_COLUMNS + ', s.expires_at FROM sessions s JOIN users u ON u.id = s.user_id '
'WHERE s.token_hash = %s AND s.expires_at > now()',
(token_hash,)).fetchone()
def revoke_session(token_hash, keep_seconds):
with connection() as conn:
conn.execute('DELETE FROM sessions WHERE token_hash = %s', (token_hash,))
conn.execute('INSERT INTO session_revocations (token_hash, expires_at) '
'VALUES (%s, now() + make_interval(secs => %s)) '
'ON CONFLICT (token_hash) DO UPDATE SET expires_at = EXCLUDED.expires_at',
(token_hash, keep_seconds))
def pending_revocations():
with connection() as conn:
conn.execute('DELETE FROM session_revocations WHERE expires_at <= now()')
return [bytes(r['token_hash']) for r in conn.execute('SELECT token_hash FROM session_revocations').fetchall()]
def clear_revocations(token_hashes):
with connection() as conn:
conn.execute('DELETE FROM session_revocations WHERE token_hash = ANY(%s)', (list(token_hashes),))
def create_chat(creator_id, title, member_ids):
try:
members = [str(uuid.UUID(m)) for m in member_ids]
except ValueError:
raise ApiError(400, 'Неизвестный участник чата') from None
if len(set(members)) != len(members):
raise ApiError(400, 'Участники не должны повторяться')
if creator_id not in members:
raise ApiError(400, 'Создатель должен быть участником чата')
try:
with connection() as conn, conn.transaction():
chat = conn.execute('INSERT INTO chats (title, created_by) VALUES (%s, %s) RETURNING id, title, created_at',
(utf8(title), creator_id)).fetchone()
conn.execute('INSERT INTO chat_members (chat_id, user_id, position) '
'SELECT %s, member, position FROM unnest(%s::uuid[]) WITH ORDINALITY AS t(member, position)',
(chat['id'], members))
except errors.ForeignKeyViolation:
raise ApiError(400, 'Неизвестный участник чата') from None
return chat_out({**chat, 'member_ids': members})
def get_chat(chat_id, user_id):
with connection() as conn:
row = conn.execute(CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s '
'WHERE c.id = %s', (user_id, chat_id)).fetchone()
if row is None:
raise ApiError(404, 'Чат не найден')
return chat_out(row)
def list_chats(user_id, cursor, limit):
scope = 'user:' + user_id
sql = CHAT_SELECT + 'JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s '
params = [user_id]
if cursor:
sql += 'AND (c.created_at, c.id) > (%s, %s) '
params += decode_cursor(scope, cursor)
sql += 'ORDER BY c.created_at, c.id LIMIT %s'
with connection() as conn:
rows = conn.execute(sql, params + [limit + 1]).fetchall()
return page([chat_out(r) for r in rows], scope, limit)
def is_member(conn, chat_id, user_id):
return conn.execute('SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s',
(chat_id, user_id)).fetchone() is not None
def create_message(chat_id, sender_id, text, key, request_hash, key_ttl_seconds):
scope = 'POST /api/v1/chats/%s/messages' % chat_id
with connection() as conn, conn.transaction():
conn.execute('DELETE FROM idempotency_keys WHERE user_id = %s AND created_at < now() - make_interval(secs => %s)',
(sender_id, key_ttl_seconds))
claimed = conn.execute(
'INSERT INTO idempotency_keys (user_id, scope, key, request_hash) VALUES (%s, %s, %s, %s) '
'ON CONFLICT DO NOTHING RETURNING 1',
(sender_id, scope, key, request_hash)).fetchone()
if claimed is None:
if not is_member(conn, chat_id, sender_id):
raise ApiError(404, 'Чат не найден')
stored = conn.execute(
'SELECT k.request_hash, m.id, m.chat_id, m.sender_id, m.text, m.created_at '
'FROM idempotency_keys k JOIN messages m ON m.id = k.message_id '
'WHERE k.user_id = %s AND k.scope = %s AND k.key = %s',
(sender_id, scope, key)).fetchone()
if bytes(stored['request_hash']) != request_hash:
raise ApiError(409, 'Idempotency-Key уже использован с другим запросом')
return message_out(stored)
row = conn.execute(
'INSERT INTO messages (chat_id, sender_id, text) SELECT %s, %s, %s '
'WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s) '
'RETURNING ' + MESSAGE_COLUMNS,
(chat_id, sender_id, utf8(text), chat_id, sender_id)).fetchone()
if row is None:
raise ApiError(404, 'Чат не найден')
conn.execute('UPDATE idempotency_keys SET message_id = %s WHERE user_id = %s AND scope = %s AND key = %s',
(row['id'], sender_id, scope, key))
return message_out(row)
def list_messages(chat_id, user_id, cursor, limit):
scope = 'chat:' + chat_id
sql = 'SELECT ' + MESSAGE_COLUMNS + ' FROM messages WHERE chat_id = %s '
params = [chat_id]
if cursor:
sql += 'AND (created_at, id) > (%s, %s) '
params += decode_cursor(scope, cursor)
sql += 'ORDER BY created_at, id LIMIT %s'
with connection() as conn:
if not is_member(conn, chat_id, user_id):
raise ApiError(404, 'Чат не найден')
rows = conn.execute(sql, params + [limit + 1]).fetchall()
return page([message_out(r) for r in rows], scope, limit)
+56
View File
@@ -0,0 +1,56 @@
"""Usage (стенд уже запущен через docker compose up -d):
python student-tests/expiry_check.py --ttl 2
Скрипт пересоздаёт только api с SESSION_TTL_SECONDS=<ttl>, проверяет истечение сессии,
затем возвращает api с обычным TTL из .env. Volumes и данные не трогаются.
"""
import argparse
import hashlib
import os
import time
from helpers import call, compose, new_user, wait_ready
def restart_api(ttl=None):
env = dict(os.environ)
if ttl is None:
env.pop('SESSION_TTL_SECONDS', None)
else:
env['SESSION_TTL_SECONDS'] = str(ttl)
compose('up', '-d', '--no-deps', '--no-build', 'api', env=env)
wait_ready()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--ttl', type=int, default=2)
args = parser.parse_args()
print('пересоздаю api с SESSION_TTL_SECONDS=%d' % args.ttl)
restart_api(args.ttl)
try:
alice = new_user('expiry')
status = call('GET', '/api/v1/users/me', token=alice['token'])[0]
print('сразу после входа: /users/me -> %d' % status)
assert status == 200
key = 'session:' + hashlib.sha256(alice['token'].encode()).hexdigest()
cache_ttl = int(compose('exec', '-T', 'valkey', 'valkey-cli', 'TTL', key))
print('TTL ключа этой сессии в Valkey: %d с (-2 = ключа нет)' % cache_ttl)
assert cache_ttl <= args.ttl, 'кэш живёт дольше сессии'
time.sleep(args.ttl + 1.5)
status, headers, _ = call('GET', '/api/v1/users/me', token=alice['token'])
print('через %.1f с: /users/me -> %d, WWW-Authenticate: %s' % (args.ttl + 1.5, status, headers['WWW-Authenticate']))
assert status == 401 and headers['WWW-Authenticate'] == 'Bearer realm="messenger"'
status = call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])[0]
print('logout истёкшим токеном -> %d' % status)
assert status == 401
print('PASS: сессия истекла по SESSION_TTL_SECONDS=%d, кэш не продлил её' % args.ttl)
finally:
print('возвращаю api с TTL из .env')
restart_api()
if __name__ == '__main__':
main()
+71
View File
@@ -0,0 +1,71 @@
"""Usage (стенд запущен через docker compose up -d, обе реплики в ротации):
python student-tests/failover_series.py --output evidence/failover-series.json
Для каждой API-реплики по очереди и в двух режимах (docker stop — штатная остановка с выводом из ротации,
docker kill — внезапная смерть процесса) под нагрузкой: останавливает реплику, меряет ошибки, RPS,
время до последнего ответа остановленной реплики, восстанавливает её (docker compose start api)
и ждёт возврата в ротацию LB. Volumes, БД и LB не трогаются.
"""
import argparse
import json
import subprocess
import time
from helpers import Load, api_containers, compose, new_chat, new_user, wait_in_rotation
WARMUP, AFTER = 5, 10
def run(container, mode):
alice = new_user('series')
chat = new_chat(alice)
load = Load(alice['token'], chat['id']).start()
time.sleep(WARMUP)
acted = time.monotonic()
command = ['docker', 'stop', '-t', '15', container] if mode == 'stop' else ['docker', 'kill', container]
subprocess.run(command, capture_output=True, check=True)
action_seconds = time.monotonic() - acted
time.sleep(AFTER)
load.stop()
instance = container[:12]
target = [r for r in load.records if r[2] == 201 and r[3] == instance and r[0] >= acted]
others = [r for r in load.records if r[2] == 201 and r[3] != instance and r[0] >= acted]
restored = time.monotonic()
compose('start', 'api')
back = wait_in_rotation(container)
result = {
'replica': instance, 'mode': mode, 'action_seconds': round(action_seconds, 2),
'target_served_until_s': round(max(r[1] for r in target) - acted, 2) if target else 0.0,
'first_success_on_other_s': round(min(r[1] for r in others) - acted, 2) if others else None,
'before': load.window(acted - WARMUP, acted),
'during_10s': load.window(acted, acted + AFTER),
'back_in_rotation_s': round(back - restored, 2),
'data': load.verify(alice['token']),
}
print('%-12s %-4s errors=%-3d rps %5.1f -> %5.1f target last answer +%.2fs restore %.1fs lost=%d dup=%d'
% (instance, mode, result['during_10s']['errors'], result['before']['rps'], result['during_10s']['rps'],
result['target_served_until_s'], result['back_in_rotation_s'], result['data']['lost'],
result['data']['duplicate_texts']))
return result
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output')
parser.add_argument('--modes', default='stop,kill')
args = parser.parse_args()
replicas = api_containers()
assert len(replicas) >= 2, 'need at least two running API replicas'
results = [run(container, mode) for mode in args.modes.split(',') for container in replicas]
bad = [r for r in results if r['data']['lost'] or r['data']['duplicate_texts'] or r['data']['duplicate_ids']]
summary = {'replicas': [c[:12] for c in replicas], 'warmup_s': WARMUP, 'observe_s': AFTER, 'workers': 4,
'lb_check': 'GET /health/ready every 1s, fall 2, rise 2', 'results': results}
if args.output:
with open(args.output, 'w', encoding='utf-8') as file:
json.dump(summary, file, ensure_ascii=False, indent=2)
print('FAIL: data loss or duplicates' if bad else 'PASS: every replica stopped once per mode; no loss, no duplicates')
raise SystemExit(1 if bad else 0)
if __name__ == '__main__':
main()
+127
View File
@@ -0,0 +1,127 @@
"""Usage (стенд уже запущен через docker compose up -d):
python student-tests/failure_check.py
Останавливает и замораживает Valkey и PostgreSQL (docker compose stop/pause, без удаления volumes),
проверяет поведение API и восстановление.
"""
import time
import uuid
from helpers import basic, call, compose, new_chat, new_user, wait_ready
failures = []
def timed(method, path, token=None, body=None, headers=None):
started = time.monotonic()
try:
status = call(method, path, body=body, token=token, headers=headers, timeout=10)[0]
except OSError as error:
status = type(error).__name__
return status, time.monotonic() - started
def expect(title, result, allowed, max_seconds):
status, seconds = result
ok = status in allowed and seconds <= max_seconds
print(' %-48s -> %-4s за %.2f с %s' % (title, status, seconds, 'OK' if ok else 'FAIL'))
if not ok:
failures.append(title)
def main():
alice = new_user('failure')
chat = new_chat(alice)
history = '/api/v1/chats/%s/messages' % chat['id']
assert call('POST', history, {'text': 'до отказа'}, alice['token'])[0] == 201
fake = uuid.uuid4().hex * 2
print('1. Valkey остановлен: кэш обходится, всё работает через PostgreSQL')
compose('stop', 'valkey')
try:
expect('первый запрос: обнаружение отказа кэша', timed('GET', '/api/v1/users/me', alice['token']), [200], 1.5)
expect('GET /users/me действующим токеном', timed('GET', '/api/v1/users/me', alice['token']), [200], 1)
expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'без кэша'}), [201], 1)
expect('неизвестный токен', timed('GET', '/api/v1/users/me', fake), [401], 1)
expect('без Authorization', timed('GET', '/api/v1/users/me'), [401], 1)
expect('/health/ready (Valkey некритичен)', timed('GET', '/health/ready'), [200], 1)
started = time.monotonic()
other = new_user('nocache')
expect('регистрация и вход без кэша', (200, time.monotonic() - started), [200], 1)
expect('logout без кэша', timed('DELETE', '/api/v1/auth/sessions/current', other['token']), [204], 1.5)
expect('отозванный токен', timed('GET', '/api/v1/users/me', other['token']), [401], 1)
finally:
compose('up', '-d', '--wait', 'valkey')
print('1б. Valkey на паузе: logout, затем unpause — отозванный токен не оживает из кэша')
revoked = new_user('paused')
call('GET', '/api/v1/users/me', token=revoked['token'])
compose('pause', 'valkey')
try:
expect('logout при паузе Valkey', timed('DELETE', '/api/v1/auth/sessions/current', revoked['token']), [204], 1.5)
finally:
compose('unpause', 'valkey')
time.sleep(6)
expect('через 6 с после unpause: /users/me', timed('GET', '/api/v1/users/me', revoked['token']), [401], 1)
expect('через 6 с после unpause: сообщение', timed('POST', history, revoked['token'], {'text': 'после logout'}), [401], 1)
print('1в. Valkey на паузе: logout, рестарт API, unpause — отзыв переживает рестарт процесса')
restarted = new_user('restart')
call('GET', '/api/v1/users/me', token=restarted['token'])
compose('pause', 'valkey')
try:
expect('logout при паузе Valkey', timed('DELETE', '/api/v1/auth/sessions/current', restarted['token']), [204], 1.5)
compose('restart', 'api')
wait_ready()
finally:
compose('unpause', 'valkey')
time.sleep(6)
expect('после рестарта API и unpause: /users/me', timed('GET', '/api/v1/users/me', restarted['token']), [401], 1)
expect('после рестарта API и unpause: сообщение', timed('POST', history, restarted['token'], {'text': 'после рестарта'}), [401], 1)
print('2. PostgreSQL остановлен: ограниченная ошибка 503, анонимный запрос не проходит')
compose('stop', 'postgres')
stopped_at = time.monotonic()
try:
expect('GET история', timed('GET', history, alice['token']), [503], 3)
expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'при отказе БД'}), [503], 3)
expect('неизвестный токен (не 200!)', timed('GET', '/api/v1/users/me', fake), [503], 3)
expect('без Authorization', timed('GET', '/api/v1/users/me'), [401], 1)
expect('вход по Basic верным паролем', timed('POST', '/api/v1/auth/sessions',
headers=basic(alice['username'], alice['password'])), [503], 3)
expect('/health/live', timed('GET', '/health/live'), [200], 1)
expect('/health/ready', timed('GET', '/health/ready'), [503], 3)
finally:
compose('up', '-d', '--wait', 'postgres')
ready_at = wait_ready()
print('3. PostgreSQL запущен: готовность через %.1f с после остановки' % (ready_at - stopped_at))
status = call('GET', '/api/v1/users/me', token=alice['token'])[0]
texts = [m['text'] for m in call('GET', history + '?limit=100', token=alice['token'])[2]['items']]
print(' прежний токен -> %d; история: %s' % (status, texts))
if status != 200 or texts != ['до отказа', 'без кэша']:
failures.append('восстановление')
print('4. PostgreSQL заморожен (pause): запросы получают 503 в пределах общего срока, а не зависают')
compose('pause', 'postgres')
try:
expect('GET история', timed('GET', history, alice['token']), [503], 4.5)
expect('POST сообщение', timed('POST', history, alice['token'], {'text': 'при заморозке'}), [503], 4.5)
expect('неизвестный токен (не 200!)', timed('GET', '/api/v1/users/me', fake), [503], 4.5)
expect('вход по Basic', timed('POST', '/api/v1/auth/sessions', headers=basic(alice['username'], alice['password'])), [503], 4.5)
expect('/health/ready', timed('GET', '/health/ready'), [503], 2)
expect('/health/live', timed('GET', '/health/live'), [200], 1)
finally:
compose('unpause', 'postgres')
unpaused = time.monotonic()
wait_ready()
texts = [m['text'] for m in call('GET', history + '?limit=100', token=alice['token'])[2]['items']]
print(' готовность через %.1f с после unpause; история: %s' % (time.monotonic() - unpaused, texts))
if texts != ['до отказа', 'без кэша']:
failures.append('после заморозки')
print('FAIL: ' + ', '.join(failures) if failures else 'PASS: отказы Valkey и PostgreSQL обработаны')
raise SystemExit(1 if failures else 0)
if __name__ == '__main__':
main()
+191
View File
@@ -0,0 +1,191 @@
import base64
import json
import os
from pathlib import Path
import subprocess
import threading
import time
import urllib.error
import urllib.parse
import urllib.request
import uuid
BASE_URL = os.environ.get('BASE_URL', 'http://127.0.0.1:8080').rstrip('/')
ROOT = Path(__file__).resolve().parents[1]
def call(method, path, body=None, token=None, raw=None, headers=None, timeout=10):
all_headers = {}
if token:
all_headers['Authorization'] = 'Bearer ' + token
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode('utf-8')
if raw is not None:
all_headers['Content-Type'] = 'application/json'
all_headers.update(headers or {})
if method == 'POST' and path.split('?')[0].endswith('/messages') and 'Idempotency-Key' not in all_headers:
all_headers['Idempotency-Key'] = uuid.uuid4().hex
all_headers = {name: value for name, value in all_headers.items() if value is not None}
request = urllib.request.Request(BASE_URL + path, data=raw, headers=all_headers, method=method)
try:
response = urllib.request.urlopen(request, timeout=timeout)
except urllib.error.HTTPError as error:
response = error
with response:
data = response.read()
is_json = response.headers.get_content_type() == 'application/json'
return response.status, response.headers, json.loads(data) if data and is_json else None
def basic(username, password):
return {'Authorization': 'Basic ' + base64.b64encode((username + ':' + password).encode('utf-8')).decode()}
def register(label='user', password=None):
username = (label + '_' + uuid.uuid4().hex[:12])[:32]
password = password or 'Pw-' + uuid.uuid4().hex
status, _, user = call('POST', '/api/v1/users', {'username': username, 'display_name': label, 'password': password})
assert status == 201, status
return user, password
def login(username, password):
status, _, session = call('POST', '/api/v1/auth/sessions', headers=basic(username, password))
assert status == 201, status
return session
def new_user(label='user'):
user, password = register(label)
session = login(user['username'], password)
return dict(user, password=password, token=session['token'])
def new_chat(owner, *others, title='Тестовый чат'):
members = [owner['id']] + [u['id'] for u in others]
status, _, chat = call('POST', '/api/v1/chats', {'title': title, 'member_ids': members}, owner['token'])
assert status == 201, status
return chat
def read_all_messages(chat_id, token, limit):
items, cursor, pages = [], None, 0
while True:
query = '?limit=%d' % limit + ('&cursor=' + urllib.parse.quote(cursor, safe='') if cursor else '')
status, _, page = call('GET', '/api/v1/chats/%s/messages%s' % (chat_id, query), token=token)
assert status == 200, status
items += page['items']
pages += 1
cursor = page['next_cursor']
if cursor is None:
return items, pages
def compose(*args, env=None, check=True):
result = subprocess.run(['docker', 'compose', *args], cwd=ROOT, capture_output=True, text=True,
encoding='utf-8', env=env)
if check and result.returncode != 0:
raise RuntimeError('docker compose %s failed: %s' % (' '.join(args), result.stderr.strip()))
return result.stdout.strip()
def sql(query, db='messenger', service='postgres'):
return compose('exec', '-T', service, 'psql', '-U', 'messenger', '-d', db, '-X', '-tA', '-v', 'ON_ERROR_STOP=1',
'-c', query)
def wait_ready(seconds=90):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call('GET', '/health/ready', timeout=2)[0] == 200:
return time.monotonic()
except OSError:
pass
time.sleep(0.3)
raise AssertionError('API is not ready after %ds' % seconds)
def api_containers():
return compose('ps', '-q', 'api').split()
def wait_in_rotation(container, seconds=60):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call('GET', '/health/ready', timeout=2)[1].get('X-Instance-Id') == container[:12]:
return time.monotonic()
except OSError:
pass
time.sleep(0.1)
raise AssertionError('container %s did not enter LB rotation' % container[:12])
class Load:
"""Отправляет сообщения в несколько потоков; неудачный POST повторяет с тем же Idempotency-Key."""
def __init__(self, token, chat_id, workers=4):
self.token, self.path, self.workers = token, '/api/v1/chats/%s/messages' % chat_id, workers
self.records, self.confirmed, self.uncertain = [], [], 0
self.stopped = threading.Event()
self.threads = []
def start(self):
self.threads = [threading.Thread(target=self.worker, args=(n,), daemon=True) for n in range(self.workers)]
for thread in self.threads:
thread.start()
return self
def stop(self):
self.stopped.set()
for thread in self.threads:
thread.join()
def worker(self, n):
sent = 0
while not self.stopped.is_set():
key, text = uuid.uuid4().hex, 'load %d-%d %s' % (n, sent, uuid.uuid4().hex[:6])
sent += 1
while True:
started = time.monotonic()
try:
status, headers, body = call('POST', self.path, {'text': text}, self.token,
headers={'Idempotency-Key': key}, timeout=5)
instance = headers.get('X-Instance-Id')
except OSError as error:
status, instance, body = type(error).__name__, None, None
self.records.append((started, time.monotonic(), status, instance))
if status == 201:
self.confirmed.append(body)
break
if self.stopped.is_set():
self.uncertain += 1
break
time.sleep(0.05)
def window(self, start, end):
rows = [r for r in self.records if start <= r[0] < end]
ok = [r for r in rows if r[2] == 201]
latencies = sorted((r[1] - r[0]) * 1000 for r in ok)
p = lambda q: round(latencies[min(len(latencies) - 1, int(len(latencies) * q))], 1) if latencies else None
return {'seconds': round(end - start, 2), 'ok': len(ok), 'errors': len(rows) - len(ok),
'rps': round(len(ok) / (end - start), 1) if end > start else 0,
'p50_ms': p(0.5), 'p95_ms': p(0.95), 'p99_ms': p(0.99),
'error_kinds': sorted({str(r[2]) for r in rows if r[2] != 201})}
def verify(self, token):
stored, cursor = [], None
while True:
query = '?limit=100' + ('&cursor=' + urllib.parse.quote(cursor, safe='') if cursor else '')
page = call('GET', self.path + query, token=token)[2]
stored += page['items']
cursor = page['next_cursor']
if cursor is None:
break
ids = [m['id'] for m in stored]
texts = [m['text'] for m in stored]
return {'confirmed': len(self.confirmed), 'stored': len(stored),
'lost': len({m['id'] for m in self.confirmed} - set(ids)),
'duplicate_ids': len(ids) - len(set(ids)), 'duplicate_texts': len(texts) - len(set(texts)),
'uncertain_at_stop': self.uncertain}
+60
View File
@@ -0,0 +1,60 @@
"""Usage (стенд запущен, обе реплики в ротации):
python student-tests/rolling_update_check.py --output evidence/rolling-update.json
Под непрерывной нагрузкой (4 потока, повтор с тем же Idempotency-Key) выполняет scripts/rolling_update.py
и проверяет: ошибки клиента, RPS, что все реплики заменены, что подтверждённые сообщения не потеряны и не задвоены.
"""
import argparse
import json
from pathlib import Path
import subprocess
import sys
import time
from helpers import Load, api_containers, new_chat, new_user
ROOT = Path(__file__).resolve().parents[1]
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output')
parser.add_argument('--no-build', action='store_true')
args = parser.parse_args()
before = api_containers()
alice = new_user('rolling')
chat = new_chat(alice)
load = Load(alice['token'], chat['id']).start()
time.sleep(5)
started = time.monotonic()
command = [sys.executable, str(ROOT / 'scripts' / 'rolling_update.py')] + (['--no-build'] if args.no_build else [])
update = subprocess.run(command, capture_output=True, text=True, encoding='utf-8')
finished = time.monotonic()
time.sleep(5)
load.stop()
print(update.stdout.strip())
after = api_containers()
result = {
'replicas_before': [c[:12] for c in before], 'replicas_after': [c[:12] for c in after],
'update_seconds': round(finished - started, 1), 'update_exit_code': update.returncode,
'before_5s': load.window(started - 5, started),
'during_update': load.window(started, finished),
'after_5s': load.window(finished, finished + 5),
'data': load.verify(alice['token']),
'log': update.stdout.strip().splitlines(),
}
replaced = not set(before) & set(after) and len(after) == len(before)
ok = update.returncode == 0 and replaced and not result['data']['lost'] and not result['data']['duplicate_texts']
print('rolling update %.1fs: errors=%d, rps %.1f -> %.1f -> %.1f, lost=%d, duplicates=%d, all replaced=%s'
% (result['update_seconds'], result['during_update']['errors'], result['before_5s']['rps'],
result['during_update']['rps'], result['after_5s']['rps'], result['data']['lost'],
result['data']['duplicate_texts'], replaced))
if args.output:
with open(args.output, 'w', encoding='utf-8') as file:
json.dump(result, file, ensure_ascii=False, indent=2)
print('PASS' if ok else 'FAIL: ' + update.stderr.strip()[-500:])
raise SystemExit(0 if ok else 1)
if __name__ == '__main__':
main()
+79
View File
@@ -0,0 +1,79 @@
"""Usage (стенд запущен через docker compose up -d):
python student-tests/sigterm_check.py
docker compose start api
Останавливает одну API-реплику (docker stop = SIGTERM) и всё это время опрашивает API через LB:
реплика сначала выходит из ротации (readiness 503), потом завершается; клиенты не должны получить ошибок.
"""
import argparse
import subprocess
import threading
import time
import urllib.error
import urllib.request
import uuid
from helpers import BASE_URL, api_containers, call, new_chat, new_user
def docker(*args):
return subprocess.run(['docker', *args], capture_output=True, text=True, encoding='utf-8').stdout.strip()
def probe_forever(results, stop_event):
while not stop_event.is_set():
started = time.monotonic()
try:
with urllib.request.urlopen(BASE_URL + '/health/live', timeout=1) as response:
outcome = str(response.status)
except urllib.error.HTTPError as error:
outcome = str(error.code)
except Exception as error:
outcome = type(error).__name__
results.append((started, outcome))
time.sleep(0.02)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--container', default=None)
parser.add_argument('--stop-timeout', type=int, default=10, help='секунд до SIGKILL у docker stop')
args = parser.parse_args()
args.container = args.container or api_containers()[0]
marker = 'PRIVATE-' + uuid.uuid4().hex
alice = new_user('alice')
chat = new_chat(alice)
status = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': marker}, alice['token'])[0]
logs_before = docker('logs', args.container)
print('сообщение с маркером отправлено: HTTP %d; маркер в логах: %s' % (status, marker in logs_before))
results, stop_event = [], threading.Event()
prober = threading.Thread(target=probe_forever, args=(results, stop_event))
prober.start()
time.sleep(1)
sigterm_at = time.monotonic()
docker('stop', '-t', str(args.stop_timeout), args.container)
stopped_at = time.monotonic()
time.sleep(1)
stop_event.set()
prober.join()
before = [r for t, r in results if t < sigterm_at]
after = [r for t, r in results if t >= sigterm_at]
exit_code = docker('inspect', '--format', '{{.State.ExitCode}}', args.container)
print('docker stop занял: %.2f с (лимит %d с)' % (stopped_at - sigterm_at, args.stop_timeout))
print('код выхода контейнера: %s (0 — сам завершился по SIGTERM; 137 — убит SIGKILL)' % exit_code)
print('запросы до SIGTERM: %d, все 200: %s' % (len(before), set(before) == {'200'}))
print('запросы после SIGTERM: %d, результаты: %s' % (len(after), sorted(set(after))))
print('ответов 5xx за всё время: %d' % sum(r.startswith('5') for _, r in results))
print('\nлоги остановки:')
for line in docker('logs', args.container).splitlines():
if any(word in line for word in ('draining', 'Shutting down', 'stopping', 'shutdown', 'Finished server')):
print(' ' + line)
if __name__ == '__main__':
main()
+157
View File
@@ -0,0 +1,157 @@
import unittest
import uuid
from helpers import call, login, new_chat, new_user, read_all_messages
class ErrorFormatMixin:
def assertError(self, result, status, code):
actual, headers, body = result
self.assertEqual(actual, status)
self.assertEqual(body['error']['code'], code)
self.assertEqual(body['error']['request_id'], headers['X-Request-Id'])
self.assertNotIn('Traceback', body['error']['message'])
class InvalidJsonTest(ErrorFormatMixin, unittest.TestCase):
def test_malformed_json(self):
"""Битый JSON -> 400 invalid_request"""
self.assertError(call('POST', '/api/v1/users', raw=b'{"username": "abc",'), 400, 'invalid_request')
def test_json_not_object(self):
"""JSON-массив вместо объекта -> 400"""
self.assertError(call('POST', '/api/v1/users', raw=b'[1, 2, 3]'), 400, 'invalid_request')
def test_wrong_type(self):
"""Число вместо строки -> 400 (без тихого приведения типов)"""
self.assertError(call('POST', '/api/v1/users', {'username': 12345, 'display_name': 'x', 'password': 'Long-enough-pass-1'}), 400, 'invalid_request')
def test_extra_field(self):
"""Лишнее поле в теле -> 400"""
body = {'username': 'u_' + uuid.uuid4().hex[:8], 'display_name': 'x', 'password': 'Long-enough-pass-1', 'is_admin': True}
self.assertError(call('POST', '/api/v1/users', body), 400, 'invalid_request')
class DuplicateUsernameTest(ErrorFormatMixin, unittest.TestCase):
def test_duplicate_username(self):
"""Повторная регистрация того же username -> 409 conflict"""
user = new_user('dup')
again = call('POST', '/api/v1/users', {'username': user['username'], 'display_name': 'Другой',
'password': 'Other-password-123'})
self.assertError(again, 409, 'conflict')
class ForeignChatTest(ErrorFormatMixin, unittest.TestCase):
def setUp(self):
self.alice, self.bob, self.eve = new_user('alice'), new_user('bob'), new_user('eve')
self.chat = new_chat(self.alice, self.bob)
self.path = '/api/v1/chats/' + self.chat['id']
def test_outsider_cannot_read_chat(self):
"""Посторонний читает чат -> 404, как будто чата нет"""
self.assertError(call('GET', self.path, token=self.eve['token']), 404, 'not_found')
missing = call('GET', '/api/v1/chats/' + str(uuid.uuid4()), token=self.eve['token'])
self.assertEqual(missing[2]['error']['message'], call('GET', self.path, token=self.eve['token'])[2]['error']['message'])
def test_outsider_cannot_write_or_read_history(self):
"""Посторонний пишет/читает историю -> 404"""
self.assertError(call('POST', self.path + '/messages', {'text': 'чужое'}, self.eve['token']), 404, 'not_found')
self.assertError(call('GET', self.path + '/messages', token=self.eve['token']), 404, 'not_found')
def test_outsider_does_not_see_chat_in_list(self):
"""Чужой чат не попадает в список чатов"""
status, _, page = call('GET', '/api/v1/chats?limit=100', token=self.eve['token'])
self.assertEqual(status, 200)
self.assertNotIn(self.chat['id'], [c['id'] for c in page['items']])
def test_member_has_access(self):
"""Участник видит чат (контроль: 404 выше не из-за ошибки в тесте)"""
self.assertEqual(call('GET', self.path, token=self.bob['token'])[0], 200)
class EmptyMessageTest(ErrorFormatMixin, unittest.TestCase):
def setUp(self):
self.alice = new_user('alice')
self.path = '/api/v1/chats/%s/messages' % new_chat(self.alice)['id']
def test_empty_text(self):
"""Пустой текст -> 400"""
self.assertError(call('POST', self.path, {'text': ''}, self.alice['token']), 400, 'invalid_request')
def test_whitespace_text(self):
"""Текст только из пробельных символов -> 400"""
self.assertError(call('POST', self.path, {'text': ' \t\n '}, self.alice['token']), 400, 'invalid_request')
def test_missing_text(self):
"""Тело без поля text -> 400"""
self.assertError(call('POST', self.path, {}, self.alice['token']), 400, 'invalid_request')
def test_text_length_limit(self):
"""4000 символов можно (эмодзи = 1 символ), 4001 — 400"""
self.assertEqual(call('POST', self.path, {'text': '😀' * 4000}, self.alice['token'])[0], 201)
self.assertError(call('POST', self.path, {'text': 'x' * 4001}, self.alice['token']), 400, 'invalid_request')
class PaginationTest(ErrorFormatMixin, unittest.TestCase):
def setUp(self):
self.alice = new_user('alice')
self.chat = new_chat(self.alice)
self.sent = [call('POST', '/api/v1/chats/%s/messages' % self.chat['id'],
{'text': 'сообщение %d' % i}, self.alice['token'])[2] for i in range(7)]
def test_walk_several_pages(self):
"""7 сообщений по 3: три страницы, без потерь, повторов и перестановок"""
items, pages = read_all_messages(self.chat['id'], self.alice['token'], limit=3)
self.assertEqual(pages, 3)
self.assertEqual([m['id'] for m in items], [m['id'] for m in self.sent])
keys = [(m['created_at'], m['id']) for m in items]
self.assertEqual(keys, sorted(keys))
def test_cursor_from_other_chat(self):
"""cursor от другого чата -> 400"""
_, _, page = call('GET', '/api/v1/chats/%s/messages?limit=1' % self.chat['id'], token=self.alice['token'])
other = new_chat(self.alice, title='Другой')
self.assertError(call('GET', '/api/v1/chats/%s/messages?cursor=%s' % (other['id'], page['next_cursor']),
token=self.alice['token']), 400, 'invalid_request')
def test_invalid_cursor_and_limit(self):
"""Мусорный cursor и limit вне 1..100 -> 400"""
path = '/api/v1/chats/%s/messages' % self.chat['id']
for query in ('?cursor=not-a-cursor', '?limit=0', '?limit=101', '?limit=abc'):
with self.subTest(query=query):
self.assertError(call('GET', path + query, token=self.alice['token']), 400, 'invalid_request')
class IdentityTest(ErrorFormatMixin, unittest.TestCase):
def test_sender_cannot_be_forged(self):
"""sender_id в теле запрещён: отправитель только из сессии"""
alice, bob = new_user('alice'), new_user('bob')
chat = new_chat(alice, bob)
forged = call('POST', '/api/v1/chats/%s/messages' % chat['id'], {'text': 'hi', 'sender_id': bob['id']}, alice['token'])
self.assertError(forged, 400, 'invalid_request')
def test_nul_character_is_preserved(self):
"""U+0000 — допустимый code point: сообщение, display_name и title сохраняются и читаются без изменений"""
username, password = 'nul_' + uuid.uuid4().hex[:12], 'Nul-password-123'
status, _, user = call('POST', '/api/v1/users', {'username': username, 'display_name': 'a\u0000lice', 'password': password})
self.assertEqual((status, user['display_name']), (201, 'a\u0000lice'))
alice = dict(user, token=login(username, password)['token'])
self.assertEqual(call('GET', '/api/v1/users/me', token=alice['token'])[2]['display_name'], 'a\u0000lice')
status, _, chat = call('POST', '/api/v1/chats', {'title': 't\u0000', 'member_ids': [alice['id']]}, alice['token'])
self.assertEqual((status, chat['title']), (201, 't\u0000'))
path = '/api/v1/chats/%s/messages' % chat['id']
status, _, message = call('POST', path, {'text': 'a\u0000b'}, alice['token'])
self.assertEqual((status, message['text']), (201, 'a\u0000b'))
self.assertEqual(call('GET', path, token=alice['token'])[2]['items'][0]['text'], 'a\u0000b')
self.assertEqual(call('GET', '/api/v1/chats/' + chat['id'], token=alice['token'])[2]['title'], 't\u0000')
def test_lone_surrogate_is_rejected(self):
"""Одиночный суррогат не кодируется в UTF-8 -> 400, а не 500"""
alice = new_user('alice')
chat = new_chat(alice)
self.assertError(call('POST', '/api/v1/chats/%s/messages' % chat['id'], raw=b'{"text": "a\\ud800b"}',
token=alice['token']), 400, 'invalid_request')
if __name__ == '__main__':
unittest.main()
+132
View File
@@ -0,0 +1,132 @@
from datetime import datetime, timezone
import unittest
import uuid
from helpers import basic, call, login, new_user, register
class RegistrationTest(unittest.TestCase):
def body(self, password):
return {'username': 'reg_' + uuid.uuid4().hex[:12], 'display_name': 'Регистрация', 'password': password}
def test_password_is_not_returned(self):
"""Ответ регистрации и /users/me не содержат password/hash"""
status, _, user = call('POST', '/api/v1/users', self.body('Secret-password-1'))
self.assertEqual(status, 201)
self.assertEqual(set(user), {'id', 'username', 'display_name', 'created_at'})
def test_password_length_limits(self):
"""Пароль 12..128 символов; 11 и 129 -> 400; эмодзи считается одним символом"""
self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 11))[0], 400)
self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 129))[0], 400)
self.assertEqual(call('POST', '/api/v1/users', self.body('x' * 128))[0], 201)
self.assertEqual(call('POST', '/api/v1/users', self.body('🔑' * 12))[0], 201)
def test_password_required_and_not_blank(self):
"""Без password или из одних пробелов -> 400"""
body = self.body('x')
del body['password']
self.assertEqual(call('POST', '/api/v1/users', body)[0], 400)
self.assertEqual(call('POST', '/api/v1/users', self.body(' ' * 20))[0], 400)
class LoginTest(unittest.TestCase):
def setUp(self):
self.user, self.password = register('login')
def assertBasicChallenge(self, result):
status, headers, body = result
self.assertEqual(status, 401)
self.assertEqual(headers['WWW-Authenticate'], 'Basic realm="messenger", charset="UTF-8"')
self.assertEqual(body['error']['code'], 'unauthorized')
return body['error']['message']
def test_login_returns_opaque_session(self):
"""Вход: 201, token_type=Bearer, токен случайный и не содержит username/UUID"""
first = login(self.user['username'], self.password)
second = login(self.user['username'], self.password)
self.assertEqual(first['token_type'], 'Bearer')
self.assertEqual(first['user'], self.user)
self.assertGreaterEqual(len(first['token']), 43)
self.assertNotEqual(first['token'], second['token'])
self.assertNotIn(self.user['username'], first['token'])
self.assertNotIn(self.user['id'], first['token'])
expires = datetime.fromisoformat(first['expires_at'].replace('Z', '+00:00'))
self.assertGreater(expires, datetime.now(timezone.utc))
def test_wrong_password_and_unknown_user_look_the_same(self):
"""Неверный пароль и несуществующий пользователь -> одинаковый 401 с Basic challenge"""
wrong = self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions',
headers=basic(self.user['username'], 'Wrong-password-1')))
unknown = self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions',
headers=basic('nobody_' + uuid.uuid4().hex[:8], 'Wrong-password-1')))
self.assertEqual(wrong, unknown)
def test_malformed_basic(self):
"""Нет заголовка, не base64, нет двоеточия, Bearer вместо Basic -> 401 Basic"""
for header in (None, 'Basic', 'Basic !!!not-base64!!!', 'Basic ' + 'bm9jb2xvbg==', 'Bearer abc'):
with self.subTest(header=header):
headers = {'Authorization': header} if header else {}
self.assertBasicChallenge(call('POST', '/api/v1/auth/sessions', headers=headers))
def test_password_with_colon_and_unicode(self):
"""Двоеточие и не-ASCII в пароле допустимы: делим только по первому ':'"""
user, password = register('colon', password='пароль:с:двоеточием🔑')
self.assertEqual(login(user['username'], password)['user']['id'], user['id'])
def test_login_rejects_body(self):
"""POST /auth/sessions принимает только заголовок, JSON body -> 400"""
status = call('POST', '/api/v1/auth/sessions', {'username': self.user['username']},
headers=basic(self.user['username'], self.password))[0]
self.assertEqual(status, 400)
class BearerTest(unittest.TestCase):
def setUp(self):
self.alice = new_user('alice')
self.eve = new_user('eve')
def assertBearerChallenge(self, headers):
status, response_headers, _ = call('GET', '/api/v1/users/me', headers=headers)
self.assertEqual(status, 401)
self.assertEqual(response_headers['WWW-Authenticate'], 'Bearer realm="messenger"')
def test_only_bearer_is_accepted(self):
"""Нет заголовка, Basic, X-User-Id, мусорный токен -> 401 Bearer"""
self.assertBearerChallenge({})
self.assertBearerChallenge(basic(self.alice['username'], self.alice['password']))
self.assertBearerChallenge({'X-User-Id': self.alice['id']})
self.assertBearerChallenge({'Authorization': 'Bearer ' + uuid.uuid4().hex})
self.assertBearerChallenge({'Authorization': 'Bearer'})
def test_authentication_before_validation(self):
"""Аноним с битым JSON на защищённом endpoint получает 401, а не 400; с сессией — 400"""
self.assertEqual(call('POST', '/api/v1/chats', raw=b'{bad')[0], 401)
self.assertEqual(call('POST', '/api/v1/chats', raw=b'{bad', token=self.alice['token'])[0], 400)
self.assertEqual(call('POST', '/api/v1/users', raw=b'{bad')[0], 400)
def test_scheme_is_case_insensitive(self):
"""Схема аутентификации нечувствительна к регистру (RFC 9110)"""
status, _, me = call('GET', '/api/v1/users/me', headers={'Authorization': 'bearer ' + self.alice['token']})
self.assertEqual((status, me['id']), (200, self.alice['id']))
def test_x_user_id_does_not_override_session(self):
"""X-User-Id игнорируется: владелец определяется только токеном"""
status, _, me = call('GET', '/api/v1/users/me', token=self.alice['token'], headers={'X-User-Id': self.eve['id']})
self.assertEqual((status, me['id']), (200, self.alice['id']))
class LogoutTest(unittest.TestCase):
def test_logout_revokes_only_current_session(self):
"""Logout -> 204 без тела; этот токен -> 401, вторая сессия того же пользователя работает"""
alice = new_user('alice')
other = login(alice['username'], alice['password'])['token']
status, _, body = call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])
self.assertEqual((status, body), (204, None))
self.assertEqual(call('GET', '/api/v1/users/me', token=alice['token'])[0], 401)
self.assertEqual(call('DELETE', '/api/v1/auth/sessions/current', token=alice['token'])[0], 401)
self.assertEqual(call('GET', '/api/v1/users/me', token=other)[0], 200)
if __name__ == '__main__':
unittest.main()
+68
View File
@@ -0,0 +1,68 @@
from concurrent.futures import ThreadPoolExecutor
import threading
import unittest
import uuid
from helpers import basic, call, new_chat, new_user, read_all_messages
CLIENTS = 10
REGISTRATIONS = 20
PER_CLIENT = 10
class ConcurrencyTest(unittest.TestCase):
def test_100_messages_from_10_clients(self):
"""100 параллельных сообщений от 10 клиентов -> ровно 100 уникальных в истории"""
users = [new_user('client%d' % i) for i in range(CLIENTS)]
chat = new_chat(users[0], *users[1:], title='Нагрузка')
path = '/api/v1/chats/%s/messages' % chat['id']
barrier = threading.Barrier(CLIENTS)
def client(index):
barrier.wait()
results = []
for n in range(PER_CLIENT):
status, _, message = call('POST', path, {'text': 'client %d msg %d' % (index, n)}, users[index]['token'])
results.append((status, message))
return results
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
responses = [r for batch in pool.map(client, range(CLIENTS)) for r in batch]
self.assertEqual([s for s, _ in responses], [201] * CLIENTS * PER_CLIENT)
sent_ids = {m['id'] for _, m in responses}
items, pages = read_all_messages(chat['id'], users[0]['token'], limit=30)
read_ids = [m['id'] for m in items]
keys = [(m['created_at'], m['id']) for m in items]
self.assertEqual(len(sent_ids), 100, 'сервер выдал повторяющиеся id')
self.assertEqual(len(read_ids), 100, 'в истории не ровно 100 сообщений')
self.assertEqual(set(read_ids), sent_ids, 'история не совпадает с подтверждёнными сообщениями')
self.assertEqual(len({m['text'] for m in items}), 100, 'потерялся или задвоился текст')
self.assertEqual(keys, sorted(keys), 'история не упорядочена по (created_at, id)')
print('\n отправлено 201: %d, уникальных id: %d, прочитано: %d за %d страниц(ы)'
% (len(responses), len(sent_ids), len(read_ids), pages))
def test_parallel_registration_of_same_username(self):
"""20 одновременных регистраций одного username -> ровно один 201, остальные 409; вход только с паролем победителя"""
username = 'race_' + uuid.uuid4().hex[:12]
barrier = threading.Barrier(REGISTRATIONS)
def register(index):
password = 'Race-password-%02d' % index
barrier.wait()
status = call('POST', '/api/v1/users', {'username': username, 'display_name': 'Гонка', 'password': password})[0]
return status, password
with ThreadPoolExecutor(max_workers=REGISTRATIONS) as pool:
results = list(pool.map(register, range(REGISTRATIONS)))
statuses = sorted(status for status, _ in results)
self.assertEqual(statuses, [201] + [409] * (REGISTRATIONS - 1))
winner = [password for status, password in results if status == 201][0]
loser = [password for status, password in results if status == 409][0]
self.assertEqual(call('POST', '/api/v1/auth/sessions', headers=basic(username, winner))[0], 201)
self.assertEqual(call('POST', '/api/v1/auth/sessions', headers=basic(username, loser))[0], 401)
if __name__ == '__main__':
unittest.main()
+58
View File
@@ -0,0 +1,58 @@
import hashlib
import time
import unittest
import uuid
from helpers import call, compose, new_chat, new_user, sql
class DatabaseTest(unittest.TestCase):
def test_chat_creation_is_rolled_back(self):
"""Неизвестный участник: INSERT chats выполнен, INSERT chat_members упал по FK, всё откатано"""
alice = new_user('alice')
chats_before = int(sql('SELECT count(*) FROM chats'))
members_before = int(sql('SELECT count(*) FROM chat_members'))
ghost = str(uuid.uuid4())
since = sql("SELECT to_char(now() - interval '1 second', 'YYYY-MM-DD\"T\"HH24:MI:SS\"Z\"')")
status, _, body = call('POST', '/api/v1/chats', {'title': 'Откат', 'member_ids': [alice['id'], ghost]},
alice['token'])
self.assertEqual(status, 400, body)
time.sleep(0.5)
log = compose('logs', '--no-log-prefix', '--since', since, 'postgres')
self.assertIn('violates foreign key constraint', log)
self.assertIn(ghost, log)
self.assertEqual(int(sql('SELECT count(*) FROM chats')), chats_before)
self.assertEqual(int(sql('SELECT count(*) FROM chat_members')), members_before)
def test_secrets_are_not_stored_in_plaintext(self):
"""В users лежит argon2id-хеш, в sessions — sha256 токена, не сам токен"""
alice = new_user('alice')
password_hash = sql("SELECT password_hash FROM users WHERE id = '%s'" % alice['id'])
self.assertTrue(password_hash.startswith('$argon2id$'), password_hash[:10])
self.assertNotIn(alice['password'], password_hash)
digest = hashlib.sha256(alice['token'].encode()).hexdigest()
self.assertEqual(sql("SELECT count(*) FROM sessions WHERE token_hash = '\\x%s'" % digest), '1')
dump = sql("SELECT string_agg(encode(token_hash, 'escape'), '') FROM sessions WHERE user_id = '%s'" % alice['id'])
self.assertNotIn(alice['token'], dump)
def test_migrations_are_idempotent(self):
"""Повторный запуск миграций ничего не меняет и завершается успешно"""
before = sql('SELECT version, applied_at FROM schema_migrations ORDER BY version')
users = sql('SELECT count(*) FROM users')
output = compose('run', '--rm', '--no-deps', 'migrate')
self.assertIn('skip 0001_init: already applied', output)
self.assertEqual(sql('SELECT version, applied_at FROM schema_migrations ORDER BY version'), before)
self.assertEqual(sql('SELECT count(*) FROM users'), users)
def test_history_query_uses_index(self):
"""Запрос страницы истории идёт по индексу (chat_id, created_at, id), без Sort"""
alice = new_user('alice')
chat = new_chat(alice)
plan = sql("SET enable_seqscan = off; SET enable_bitmapscan = off; EXPLAIN SELECT id FROM messages WHERE chat_id = '%s' "
"ORDER BY created_at, id LIMIT 51" % chat['id'])
self.assertIn('messages_chat_history_idx', plan)
self.assertNotIn('Sort', plan)
if __name__ == '__main__':
unittest.main()
+96
View File
@@ -0,0 +1,96 @@
from concurrent.futures import ThreadPoolExecutor
import threading
import unittest
import uuid
from helpers import call, new_chat, new_user, read_all_messages
PARALLEL = 20
def post(chat, user, key, body=None, raw=None):
return call('POST', '/api/v1/chats/%s/messages' % chat['id'], body, user['token'], raw=raw,
headers={'Idempotency-Key': key})
class IdempotencyTest(unittest.TestCase):
def setUp(self):
self.alice, self.bob = new_user('alice'), new_user('bob')
self.chat = new_chat(self.alice, self.bob)
def history(self):
return read_all_messages(self.chat['id'], self.alice['token'], limit=100)[0]
def test_replay_returns_same_message(self):
"""Повтор того же запроса с тем же ключом -> тот же 201 и тот же Message, дубля нет"""
key = uuid.uuid4().hex
first = post(self.chat, self.alice, key, {'text': 'один раз'})
second = post(self.chat, self.alice, key, {'text': 'один раз'})
self.assertEqual((first[0], second[0]), (201, 201))
self.assertEqual(first[2], second[2])
self.assertEqual([m['id'] for m in self.history()], [first[2]['id']])
def test_json_formatting_does_not_matter(self):
"""Порядок/пробелы в JSON семантически равны: повтор с другим форматированием -> тот же Message"""
key = uuid.uuid4().hex
first = post(self.chat, self.alice, key, raw='{"text":"формат"}'.encode())
second = post(self.chat, self.alice, key, raw='{ "text" : "формат" }'.encode())
self.assertEqual((first[0], second[0]), (201, 201))
self.assertEqual(first[2]['id'], second[2]['id'])
def test_other_body_with_same_key_conflicts(self):
"""Тот же ключ с другим телом -> 409, второе сообщение не создаётся"""
key = uuid.uuid4().hex
self.assertEqual(post(self.chat, self.alice, key, {'text': 'первое'})[0], 201)
status, _, body = post(self.chat, self.alice, key, {'text': 'другое'})
self.assertEqual((status, body['error']['code']), (409, 'conflict'))
self.assertEqual(len(self.history()), 1)
def test_missing_or_invalid_key(self):
"""Нет ключа, пустой, недопустимые символы, длиннее 128 -> 400"""
for key in (None, '', 'bad key', 'bad/key', 'café', 'x' * 129):
with self.subTest(key=key):
self.assertEqual(post(self.chat, self.alice, key, {'text': 'x'})[0], 400)
self.assertEqual(post(self.chat, self.alice, 'A.b_c:d-1' + 'x' * 119, {'text': 'граница'})[0], 201)
def test_key_scope_is_user_and_chat(self):
"""Одинаковый ключ у разных пользователей и в разных чатах — независимые сообщения"""
key = uuid.uuid4().hex
other_chat = new_chat(self.alice, title='Другой')
a = post(self.chat, self.alice, key, {'text': 'от Алисы'})
b = post(self.chat, self.bob, key, {'text': 'от Боба'})
c = post(other_chat, self.alice, key, {'text': 'от Алисы'})
self.assertEqual([a[0], b[0], c[0]], [201, 201, 201])
self.assertEqual(len({a[2]['id'], b[2]['id'], c[2]['id']}), 3)
def test_replay_rechecks_session_and_access(self):
"""Повтор снова проверяет сессию и доступ: после logout -> 401, посторонний с тем же ключом -> 404"""
key = uuid.uuid4().hex
self.assertEqual(post(self.chat, self.alice, key, {'text': 'до выхода'})[0], 201)
eve = new_user('eve')
self.assertEqual(post(self.chat, eve, key, {'text': 'до выхода'})[0], 404)
call('DELETE', '/api/v1/auth/sessions/current', token=self.alice['token'])
self.assertEqual(post(self.chat, self.alice, key, {'text': 'до выхода'})[0], 401)
def test_parallel_retries_through_replicas_create_one_message(self):
"""20 одновременных POST с одним ключом через LB (разные реплики) -> ровно одно сообщение, все 201 с одним id"""
key = uuid.uuid4().hex
barrier = threading.Barrier(PARALLEL)
def send(_):
barrier.wait()
status, headers, body = post(self.chat, self.alice, key, {'text': 'конкурентный повтор'})
return status, headers['X-Instance-Id'], body
with ThreadPoolExecutor(max_workers=PARALLEL) as pool:
results = list(pool.map(send, range(PARALLEL)))
self.assertEqual({status for status, _, _ in results}, {201})
self.assertEqual(len({body['id'] for _, _, body in results}), 1)
self.assertGreaterEqual(len({instance for _, instance, _ in results}), 2, 'запросы не попали на разные реплики')
self.assertEqual(len(self.history()), 1)
print('\n 20 повторов: реплики %s, сообщений в истории: %d'
% (sorted({instance for _, instance, _ in results}), len(self.history())))
if __name__ == '__main__':
unittest.main()
+41
View File
@@ -0,0 +1,41 @@
import unittest
import uuid
from helpers import call, new_chat, new_user
class ReplicasTest(unittest.TestCase):
def test_one_session_is_served_by_several_replicas(self):
"""Один токен без повторного входа обслуживается разными репликами (X-Instance-Id), все ответы 200"""
alice = new_user('alice')
results = [call('GET', '/api/v1/users/me', token=alice['token']) for _ in range(10)]
self.assertEqual({status for status, _, _ in results}, {200})
self.assertGreaterEqual(len({headers['X-Instance-Id'] for _, headers, _ in results}), 2)
def test_write_on_one_replica_is_read_on_another(self):
"""Сообщение, подтверждённое одной репликой, сразу видно при чтении через другую"""
alice = new_user('alice')
chat = new_chat(alice)
path = '/api/v1/chats/%s/messages' % chat['id']
for i in range(6):
_, written_by, message = call('POST', path, {'text': 'm%d' % i}, alice['token'])
status, read_by, page = call('GET', path + '?limit=100', token=alice['token'])
self.assertEqual(status, 200)
self.assertIn(message['id'], [m['id'] for m in page['items']],
'запись через %s не видна через %s' % (written_by['X-Instance-Id'], read_by['X-Instance-Id']))
def test_every_api_response_has_instance_id(self):
"""X-Instance-Id есть и в успешных ответах, и в ошибках API, и в health"""
alice = new_user('alice')
for method, path, token, expected in (
('GET', '/health/live', None, 200), ('GET', '/health/ready', None, 200),
('GET', '/api/v1/users/me', None, 401), ('GET', '/api/v1/users/me', alice['token'], 200),
('GET', '/api/v1/chats/' + str(uuid.uuid4()), alice['token'], 404), ('GET', '/nope', None, 404)):
with self.subTest(path=path, expected=expected):
status, headers, _ = call(method, path, token=token)
self.assertEqual(status, expected)
self.assertTrue(headers['X-Instance-Id'])
if __name__ == '__main__':
unittest.main()