ЛР 3 — БВТ-2303 — Мусаев — на 4 #82

Closed
mxr013 wants to merge 7 commits from mxr013/mtusi2026lab3:solution/bvt2303-musaev into main
62 changed files with 3994 additions and 16 deletions
+16
View File
@@ -18,3 +18,19 @@ __pycache__
node_modules
evidence
.DS_Store
# в образ идут только requirements.txt, src/ и migrations/
tests
student-tests
contracts
examples
scripts
infra
*.md
Makefile
Dockerfile*
compose*.yaml
lab.json
requirements-dev.txt
.gitignore
.idea
.vscode
+14 -1
View File
@@ -7,7 +7,20 @@ SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
SESSION_STORE=redis
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
# info / debug / warning
LOG_LEVEL=info
# Сколько секунд после SIGTERM ждать незавершённые запросы (не больше 10).
SHUTDOWN_TIMEOUT=8
# Пул соединений с PostgreSQL и таймауты в секундах.
DB_POOL_MIN_SIZE=2
DB_POOL_MAX_SIZE=10
DB_POOL_TIMEOUT=3
DB_CONNECT_TIMEOUT=3
DB_STATEMENT_TIMEOUT=5
# Пул соединений с Redis и таймаут операций в секундах.
CACHE_POOL_MAX_SIZE=20
CACHE_TIMEOUT=2
+37
View File
@@ -0,0 +1,37 @@
FROM python:3.13.16-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1
WORKDIR /app
# сначала зависимости: слой переиспользуется, пока не меняется requirements.txt
COPY requirements.txt .
RUN pip install -r requirements.txt
RUN groupadd --system --gid 10001 app \
&& useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app
COPY src/ .
COPY migrations/ migrations/
USER 10001:10001
ARG APP_VERSION=dev
ENV APP_HOST=0.0.0.0 \
APP_PORT=8080 \
APP_ENV=lab \
APP_VERSION=$APP_VERSION
EXPOSE 8080
HEALTHCHECK --interval=5s --timeout=4s --start-period=20s --start-interval=1s --retries=3 \
CMD ["python", "healthcheck.py"]
STOPSIGNAL SIGTERM
# exec-форма: python запускается как PID 1 и сам получает SIGTERM
CMD ["python", "main.py"]
+45 -1
View File
@@ -2,9 +2,11 @@ PYTHON ?= python3
BASE_URL ?= http://localhost:8080
CA_FILE ?=
ACTION_SCRIPT ?=
COMPOSE = docker compose --env-file .env
COMPOSE_TEST = $(COMPOSE) -f compose.yaml -f compose.test.yaml
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 env up down clean restore student-test test-failures explain failover-each failover-hard rolling-update
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -28,3 +30,45 @@ test-persistence:
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
env:
./scripts/init-env.sh
up: env
$(COMPOSE) up -d --build
BASE_URL="$(BASE_URL)" ./scripts/wait-ready.sh
down:
$(COMPOSE_TEST) down
# удаляет контейнеры вместе с данными PostgreSQL и Redis
clean:
$(COMPOSE_TEST) down -v
# возвращает реплики, остановленные scripts/stop-one.sh
restore:
$(COMPOSE) up -d --no-recreate --no-build api
BASE_URL="$(BASE_URL)" ./scripts/wait-ready.sh
student-test:
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests -v
# останавливает и запускает redis/postgres, поднимает отдельный API на порту 8081
test-failures:
BASE_URL="$(BASE_URL)" $(PYTHON) -m unittest discover -s student-tests/failures -v
explain:
./scripts/explain_history.sh
# по очереди останавливает каждую реплику под нагрузкой
failover-each:
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py stop --output evidence/failover-each.json
# то же с SIGKILL и с зависшей репликой (docker pause)
failover-hard:
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py kill --output evidence/failover-kill.json
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py pause --output evidence/failover-pause.json
# заменяет реплики новым образом под нагрузкой: make rolling-update APP_VERSION=2
rolling-update:
BASE_URL="$(BASE_URL)" $(PYTHON) scripts/chaos.py rolling --output evidence/rolling-update.json
+241 -14
View File
@@ -1,37 +1,264 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Мусаев Абдул-Хамид Рамзанович, БВТ-2303
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не заявлен
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/82
- Использованные источники, библиотеки и помощь ИИ:
- библиотеки и образы: FastAPI 0.143.0, Uvicorn 0.54.0, psycopg 3.3.6, redis-py 8.1.0, argon2-cffi 25.1.0, HAProxy 3.2.26, PostgreSQL 17.11, Redis 7.4.11 (полный список в `requirements.txt`, `compose.yaml`, `infra/haproxy/Dockerfile`);
- источники: документация HAProxy (проверки, resolvers, retry-on, http-error), PostgreSQL (`INSERT ... ON CONFLICT`, READ COMMITTED), Docker Compose, `contracts/README.md`;
- помощь ИИ: ИИ-ассистент использовался во вспомогательных целях.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker с Compose v2 (проверено на Docker 29.3.0, Compose 5.1.0), `make`, `openssl`, `curl` и Python 3.9+ на хосте для тестов. Выбран Compose, Swarm не используется.
```sh
make up # создаёт .env с паролями, собирает образы, поднимает стенд и ждёт /health/ready
make check # структура skeleton
make test # публичный smoke
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make restore # вернуть реплику, остановленную failover-тестом
make student-test # собственные тесты API
make test-failures # истечение сессии и ключа, отказ Redis и PostgreSQL, откат транзакции
make failover-each # остановка каждой реплики под нагрузкой (SIGTERM)
make failover-hard # то же с SIGKILL и с зависшей репликой
make rolling-update APP_VERSION=2 # поочерёдная замена реплик под нагрузкой
python3 scripts/sigterm_check.py
make explain # синтетическая история и планы запросов
make down # остановить и удалить контейнеры, данные остаются в volumes
make clean # то же и удалить volumes: намеренное удаление учебных данных
```
То же без `make`:
```sh
./scripts/init-env.sh
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
./scripts/wait-ready.sh
```
Число реплик задаёт `API_REPLICAS` в `.env`. На работающем стенде реплику можно добавить без перезапуска остальных: `docker compose --env-file .env up -d --no-deps --no-recreate --no-build --scale api=3 api`. Балансировщик рассчитан на 6 реплик.
`make test-failures` сам останавливает и запускает `redis` и `postgres` и поднимает отдельный API на порту 8081 из `compose.test.yaml`, поэтому запускать его нужно только на учебном стенде.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```
edge data (internal)
клиент ──> lb (HAProxy) ──┬──> api-1 ──┬──> postgres: пользователи, чаты, сообщения, ключи идемпотентности
127.0.0.1:8080 └──> api-2 ──┴──> redis: сессии с TTL
migrate: одноразовый контейнер, применяет миграции до старта реплик
```
### Роли и сервисы
| Роль | Сервис compose | Образ | Готовность | Volume | Сеть и порт | Лимиты | Как получает секреты |
| --- | --- | --- | --- | --- | --- | --- | --- |
| load_balancer | `lb` | собирается из `infra/haproxy/Dockerfile` на `haproxy:3.2.26-alpine` | `/lb-health` на внутреннем порту 8404 | нет | `edge`, опубликован только `127.0.0.1:8080` | 0,5 CPU, 128 МБ | не нужны |
| api | `api`, 2 реплики | собирается из `Dockerfile` на `python:3.13.16-slim-bookworm` | HEALTHCHECK → `/health/ready` | нет, состояния не хранит | `edge` и `data`, порт 8080 не опубликован | 1 CPU, 256 МБ на реплику | файлы `/run/secrets/database_url`, `/run/secrets/cache_url` |
| миграции | `migrate` | тот же образ | одноразовый, код выхода 0 | нет | `data` | 0,5 CPU, 128 МБ | файл `/run/secrets/database_url` |
| postgres | `postgres` | `postgres:17.11-alpine` | `pg_isready` | `pgdata` | `data` | 1 CPU, 512 МБ | `POSTGRES_PASSWORD_FILE` |
| redis | `redis` | `redis:7.4.11-alpine` | `redis-cli ping` | `redisdata` | `data` | 0,5 CPU, 128 МБ | `--requirepass` из файла секрета |
Сеть `data` объявлена `internal`: балансировщик не видит хранилища, а хранилища не имеют выхода наружу. `container_name` не используется, поэтому сервис `api` масштабируется. Секреты описаны как `secrets` с источником из `.env` и попадают в контейнеры файлами, в окружении контейнеров их нет (`evidence/09-containers.txt`).
Конфигурация HAProxy лежит внутри образа, а не монтируется с хоста: версия балансировщика и его настройки меняются только сборкой, и `haproxy -c` проверяет конфигурацию уже при сборке.
### Новое и изменённое в этой работе
| Файл | Что в нём |
| --- | --- |
| `infra/haproxy/haproxy.cfg` | балансировка, проверки готовности, DNS, таймауты, ошибки в формате контракта |
| `infra/haproxy/errors/*.http` | готовые JSON-ответы для запросов, которые не удалось разобрать |
| `migrations/0002_idempotency.sql` | таблица ключей идемпотентности |
| `src/store.py` | `add_message` с ключом |
| `src/main.py` | `X-Instance-Id`, разбор `Idempotency-Key`, разбор тела после проверки токена |
| `compose.yaml`, `compose.test.yaml` | стенд и отдельный API с коротким TTL только для тестов |
| `scripts/stop-one.sh`, `scripts/restart.sh`, `scripts/rolling-update.sh` | отказ реплики, перезапуск стенда, поочерёдная замена |
| `scripts/chaos.py`, `scripts/sigterm_check.py` | нагрузка во время отказов и проверка SIGTERM |
### Балансировка и обнаружение отказа
`balance roundrobin`, sticky session нет: любой запрос может уйти на любую реплику. API не хранит локального состояния, поэтому это безопасно.
Список реплик не задан вручную. `server-template api 1-6 api:8080` с `resolvers docker` берёт адреса из DNS Docker по имени сервиса: новые контейнеры появляются сами, остановленные исчезают. `depends_on` и healthcheck контейнера этого не делают: они влияют только на порядок запуска и статус контейнера, а трафик распределяет балансировщик.
Проверка активная: `GET /health/ready` раз в секунду на каждую реплику.
| Настройка | Значение | Зачем |
| --- | --- | --- |
| `inter` / `fall` / `rise` | 1 с / 2 / 2 | две неудачи подряд исключают реплику, две удачи возвращают |
| `timeout check` | 1 с | зависшая реплика считается неудачной проверкой |
| `timeout connect` | 1 с | столько запрос ждёт соединения, потом идёт на другую реплику |
| `retries` + `retry-on conn-failure` + `option redispatch` | 2 | повтор только при отказе соединения, то есть когда запрос не дошёл до приложения; поэтому это безопасно и для POST |
| `option http-server-close` | — | новое соединение с API на каждый запрос: остановленная реплика сразу видна как отказ соединения, нет гонки с закрытием простаивающего соединения |
| `timeout server` | 12 с | больше самого долгого ответа API: 3 с на соединение из пула + 5 с на запрос + 2 с на Redis |
| `timeout client` / `timeout http-request` | 30 с / 10 с | защита от клиента, который не присылает запрос |
**Максимальное время обнаружения отказа.** Процесс остановлен: соединения отвергаются сразу, отказ виден не позже двух проверок, около 2 с; DNS Docker обычно убирает контейнер раньше. Измерено 0,4–1,3 с. Реплика зависла: соединения открыты, ответов нет, две проверки по 1 с плюс интервал дают около 3 с. Измерено 3,2–3,5 с (в замер входит опрос статистики балансировщика). Возврат реплики — около 2 с после готовности.
### Согласованность остановки
1. `docker stop` шлёт SIGTERM процессу PID 1.
2. Uvicorn сразу закрывает слушающий сокет: новые соединения отвергаются, HAProxy отправляет запрос на другую реплику.
3. Начатые запросы завершаются, но не дольше `SHUTDOWN_TIMEOUT` = 8 с.
4. Процесс выходит с кодом 0 раньше, чем `stop_grace_period` = 10 с закончится SIGKILL.
Отдельной паузы со сбросом готовности перед закрытием сокета нет: отказ соединения обрабатывается повтором на другую реплику, и замеры показали, что этого достаточно. Цена описана в разделе про ограничения.
### Идемпотентность отправки сообщения
Ключи хранятся в PostgreSQL, таблица `idempotency_keys`, первичный ключ `(user_id, chat_id, key)` — это область уникальности контракта: пользователь + метод + путь чата + ключ. Значение — `message_id` и время создания. Хранилище общее, поэтому реплики видят одни и те же ключи.
`add_message` выполняется одной транзакцией:
1. Проверка членства в чате. Посторонний получает 404, ключ не занимается.
2. `INSERT ... ON CONFLICT (user_id, chat_id, key) DO UPDATE ... WHERE срок вышел RETURNING message_id`.
3. Строка вернулась — ключ занят этой транзакцией: вставляется сообщение, ответ 201.
4. Строки нет — сообщение уже есть: оно читается и сравнивается по тексту. Текст тот же — ответ 201 с исходным сообщением. Другой — 409.
**Почему одновременные повторы создают ровно одно сообщение.** Уникальный индекс заставляет вторую транзакцию ждать на шаге 2, пока первая не завершится. Если первая зафиксирована, вторая идёт на шаг 4 и читает её результат: в READ COMMITTED каждый запрос видит уже зафиксированные данные. Если первая откатилась, вторая занимает ключ сама.
**Почему побочный эффект и результат атомарны.** Ключ и сообщение пишутся в одной транзакции, а внешний ключ `message_id` отложен до COMMIT (`DEFERRABLE INITIALLY DEFERRED`), потому что ключ вставляется первым. При сбое не остаётся ни того, ни другого, поэтому транзиентный 5xx не становится окончательным результатом, и запрос можно повторить с тем же ключом.
Текст сравнивается напрямую, поэтому порядок ключей и пробелы в JSON на результат не влияют. Срок хранения — `IDEMPOTENCY_TTL_SECONDS`, по умолчанию 24 часа; после него тот же ключ снова свободен. Повтор проходит те же проверки сессии и доступа, что и первый запрос.
`Idempotency-Key` обязателен, формат `[A-Za-z0-9._:-]{1,128}`, иначе 400. Проверка идёт после токена. Посторонний с неверным ключом получит 400, а не 404: существование чата при этом не раскрывается, ответ не зависит от чата.
### X-Instance-Id
Каждый ответ API содержит `X-Instance-Id`, значение — `socket.gethostname()`, то есть короткий id контейнера. Оно стабильно на время жизни процесса, по нему `scripts/stop-one.sh` находит контейнер среди контейнеров сервиса `api`. В lab7 нужно заменить на непрозрачный alias. Ответы самого балансировщика этого заголовка не имеют, контракт это допускает.
### Ответы балансировщика
Когда готовых реплик нет или соединение оборвалось, HAProxy отвечает сам. Для 500, 502, 503, 504 используется `http-error` с формированием JSON и `X-Request-Id` из `unique-id`. Запросы, которые не удалось разобрать (400, 408, 414, 431), до `http-error` не доходят: у них ещё нет идентификатора, поэтому ответы готовые, из файлов, с постоянным `request_id` вида `lb-400`, который совпадает с заголовком. Формат проверен тестами в `test_balancing.py`.
### Миграции и поочерёдная замена
Миграции выполняет один контейнер `migrate` до старта реплик, реплики их не запускают. `pg_advisory_lock` защищает от двух одновременных запусков.
`scripts/rolling-update.sh`: собрать образ → один раз применить миграции → для каждой старой реплики поднять новую, дождаться `healthy` и двух проверок балансировщика, затем остановить и удалить старую. Число работающих реплик не падает ниже исходного.
Миграция `0002` только добавляет таблицу, поэтому работающая версия без идемпотентности продолжила бы работать на новой схеме. Совместная работа версии lab2 с этой схемой не проверялась, проверена замена версии lab3 на версию lab3 с другим `APP_VERSION`. Общее правило: миграция должна подходить и старой, и новой версии; удаление или переименование колонок делается отдельным выпуском после замены всех реплик.
### Что перенесено из lab2 и что изменено
Перенесены: PostgreSQL и миграции, Argon2id, Basic и Bearer, сессии в Redis с AOF, пул и таймауты, cursor-пагинация со строгой проверкой, исправления по замечаниям к lab1 и lab2.
Изменено сверх требований lab3 (для большего соответствия контракту):
- тело запроса разбирается после проверки токена, поэтому сломанный JSON без токена теперь даёт 401, а не 400;
- принимается только UTF-8: раньше тело в UTF-16 проходило;
- UUID в пути и в `member_ids` принимается только в записи 8-4-4-4-12: раньше проходили скобки и `urn:uuid:`;
- нужен `Content-Type: application/json`.
Поведение при отказе зависимостей изменилось из-за балансировщика: `/health/ready` реплик становится 503, реплики исключаются, и через 2–3 с на все запросы, включая анонимные и `/health/live`, отвечает 503 сам балансировщик. Это осознанно: реплика, которая не может обслужить запрос, не должна получать трафик.
Контракт и публичные тесты не менялись. Значение `SESSION_STORE` в `.env.example` изменено на `redis`.
### Соответствие переменных окружения
| Переменная в `.env` | По умолчанию | Что делает |
| --- | --- | --- |
| `API_REPLICAS` | `2` | число реплик сервиса `api` |
| `IDEMPOTENCY_TTL_SECONDS` | `86400` | срок хранения ключа |
| `APP_HOST`, `APP_PORT` | `0.0.0.0`, `8080` | адрес сервера; в compose заданы жёстко, из `.env` не читаются |
| `APP_ENV`, `LOG_LEVEL`, `SHUTDOWN_TIMEOUT` | `lab`, `info`, `8` | как в lab2 |
| `APP_VERSION` | `dev` | аргумент сборки; задаётся при замене реплик, выводится в лог при старте |
| `SESSION_TTL_SECONDS`, `SESSION_STORE` | `3600`, `redis` | срок сессии; поддерживается только `redis` |
| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | `/run/secrets/...` | пути к строкам подключения; в compose заданы жёстко |
| `DB_POOL_*`, `DB_*_TIMEOUT`, `CACHE_*` | см. `.env.example` | пул и таймауты; 10 соединений × 6 реплик = 60 при `max_connections` = 100 |
| `POSTGRES_PASSWORD`, `REDIS_PASSWORD`, `DATABASE_URL`, `CACHE_URL` | создаёт `init-env.sh` | источник compose-секретов |
### Семантика порядка сообщений
`created_at` — `now()` PostgreSQL, часы общие для всех реплик, поэтому разница часов реплик на порядок не влияет. Но это время начала транзакции: две параллельные транзакции могут зафиксироваться не в порядке своих `created_at`, и сообщение может появиться в истории чуть раньше места, которое клиент уже прошёл по cursor. Окно — длительность транзакции вставки. Повторов при обходе нет. Чтение после записи выполняется на любой реплике: ответ 201 приходит после COMMIT (`test_read_after_write_on_any_replica`).
## Доказательства критериев
Стенд: Apple M3 Pro, 11 CPU, 18 ГБ RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0. Лимиты контейнеров указаны в таблице ролей; генератор нагрузки работал на том же компьютере. Файлы получены из чистого clone на пустых volumes, commit `269b449`; `evidence/08-failures.txt` получен следующим коммитом после удаления повторявшихся тестов.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke | `make test` | `PASS: lab3 public API scenario` | `evidence/01-up-and-smoke.txt` |
| 3: стенд в compose.yaml, ≥2 реплики, одна точка входа, общие БД и сессии | `make up`, `docker compose ps` | 2 реплики `api`, опубликован только `lb` | `evidence/01-up-and-smoke.txt`, `evidence/09-containers.txt` |
| 3: разные реплики без повторного входа | `curl` 6 раз, `test_balancing.py` | значения `X-Instance-Id` чередуются и совпадают с id контейнеров | `evidence/01-up-and-smoke.txt`, `evidence/02-student-tests.txt` |
| 3: остановка любой реплики, продолжение за ≤10 с | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, 2 прогона | `PASS`, 2 реплики до отказа, контейнер в состоянии `exited`, запись восстановилась за 1,8 с | `evidence/04-failover-public.txt` |
| 3: повтор с тем же ключом без дубля, включая конкурентный и переключение реплики | `test_idempotency.py`, `test_transactions.py`, `scripts/chaos.py` | 8 параллельных запросов на ключ через 2 реплики дают одно сообщение; 20 параллельных дают одну строку в `messages` и в `idempotency_keys` | `evidence/02-student-tests.txt`, `evidence/08-failures.txt` |
| 3: неподтверждённую запись можно повторить | `test_uncertain_write_can_be_repeated_with_same_key`, режим `pause` | 503 при отказе БД, затем 201 с тем же ключом; при зависшей реплике клиент не дождался ответа и повторил, дублей нет | `evidence/08-failures.txt`, `evidence/06-failover-hard.txt` |
| 3: persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS`, у всех контейнеров новое время старта, volumes те же | `evidence/03-persistence.txt` |
| 4: health, таймауты, SIGTERM согласованы, LB исключает недоступную реплику | `haproxy.cfg`, `scripts/sigterm_check.py` | начатые запросы 201, 0 из 20 новых на останавливаемой реплике, выход за 1,43 с с кодом 0; период 1 с, обнаружение до ~3,5 с | `evidence/10-sigterm.txt`, `evidence/05-failover-each.txt`, `evidence/06-failover-hard.txt` |
| 4: поочерёдная остановка каждой реплики, RPS, ошибки, восстановление | `make failover-each` | см. таблицу ниже | `evidence/05-failover-each.txt`, `evidence/failover-each.json` |
| 4: идемпотентность параллельными запросами | `test_parallel_repeat_through_different_replicas` | 10 ключей по 8 запросов, 2 реплики, 10 сообщений | `evidence/02-student-tests.txt` |
| 4: лимиты CPU/RAM, API без публичных портов, нет container_name | `docker inspect`, `docker compose ps`, `grep` | лимиты у всех сервисов, опубликован только `lb`, `container_name` 0 | `evidence/09-containers.txt` |
| 4: rolling update под нагрузкой | `make rolling-update APP_VERSION=2` | 18 344 записи, 0 ошибок, контейнеры и образ заменены | `evidence/07-rolling-update.txt`, `evidence/rolling-update.json` |
| 4: миграции однократно и совместимо | сервис `migrate`, `rolling-update.sh` | применены один раз, повтор ничего не меняет; ограничение совместимости описано выше | `evidence/03-persistence.txt`, `evidence/08-failures.txt` |
| Возможности lab2: истечение сессии, отказ Redis и БД, откат, гонка регистрации, индекс | `make test-failures`, `make explain` | 15 тестов `ok`, Index Scan на странице истории | `evidence/08-failures.txt`, `evidence/11-explain.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Собственные тесты: 86 тестов API (`make student-test`) и 15 тестов отказов (`make test-failures`).
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Методика `scripts/chaos.py`: 4 клиента в closed loop отправляют сообщения в один чат через балансировщик, неопределённый результат повторяется с тем же ключом и текстом. Таймаут клиента 3 с. На 5-й секунде выполняется воздействие, через 10 с реплика возвращается, затем ещё 2 с нагрузки. В конце вся история сверяется с подтверждёнными сообщениями. Отказ каждой реплики — отдельный раунд, предыдущая к этому моменту восстановлена.
| Воздействие | Реплика | Длительность, с | Успешных | RPS | Ошибок (коды) | Исключена LB через, с | Самая длинная пауза записи, с | Потери / дубли |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `docker stop` (SIGTERM) | 1 | 19,65 | 12 992 | 661 | 1 (502) | 0,59 | 1,01 | 0 / 0 |
| `docker stop` (SIGTERM) | 2 | 19,49 | 13 416 | 688 | 0 | 1,32 | 1,00 | 0 / 0 |
| `docker kill` (SIGKILL) | 1 | 18,08 | 12 553 | 694 | 2 (502) | 1,07 | 1,01 | 0 / 0 |
| `docker kill` (SIGKILL) | 2 | 19,69 | 13 654 | 693 | 3 (502) | 0,36 | 1,02 | 0 / 0 |
| `docker pause` (зависание) | 1 | 18,19 | 11 314 | 622 | 4 (таймаут клиента) | 3,16 | 3,08 | 0 / 0 |
| `docker pause` (зависание) | 2 | 18,40 | 9 341 | 508 | 8 (таймаут клиента) | 3,46 | 3,06 | 0 / 0 |
| rolling update, 12,4 с | обе | 22,41 | 18 344 | 819 | 0 | — | 1,01 | 0 / 0 |
Всего 91 614 подтверждённых записей, 18 неудачных попыток, все закрыты повтором с тем же ключом; подтверждённых потерь и дублей нет.
Что показывают данные:
- **Пауза около 1 с при остановке** — это `timeout connect`: пока реплика не исключена, запрос к её пропавшему адресу ждёт секунду и уходит на другую. Ошибки клиент при этом не видит, но задержка есть.
- **502 при SIGTERM и SIGKILL** — соединение оборвалось, когда запрос уже был передан. Такой запрос HAProxy намеренно не повторяет: он мог быть выполнен. Повторяет клиент с тем же ключом. При SIGTERM это случилось один раз на 26 408 записей; точную причину не выяснял, вероятнее всего запрос попал в очередь сокета в момент его закрытия.
- **Зависшая реплика** — самый тяжёлый случай: открытые запросы ждут до таймаута клиента, запись частично останавливается примерно на 3 с. После `docker unpause` зависшие запросы дорабатывают и получают тот же ключ, поэтому дублей нет. Это проверка идемпотентности на настоящем сценарии.
- RPS ограничен и клиентом на Python: это не максимальная производительность стенда. RPS разных строк сравнивать не стоит, размер истории и условия прогрева отличаются.
Ошибка, найденная при проверке: первая версия `rolling-update.sh` завершалась успешно, но ничего не заменяла. В `sh` нет локальных переменных, цикл внутри функции перезаписывал `$container`, и скрипт останавливал только что поднятую реплику. Нагрузка этого не показала: 0 ошибок выглядели как идеальное обновление. Несовпадение заметил по списку контейнеров, поэтому `chaos.py rolling` теперь завершается с ошибкой, если хоть один контейнер или образ остался прежним.
Индекс истории (`make explain`, 152 048 сообщений, 10 000 в исследуемом чате, в кэше):
| Запрос | План | Буферов | Время |
| --- | --- | --- | --- |
| первая страница | Index Scan | 10 | 0,037 мс |
| страница после 5000-го сообщения, keyset | Index Scan | 8 | 0,036 мс |
| та же страница через OFFSET | Bitmap Heap Scan и сортировка | 992 | 2,277 мс |
| keyset без индекса | Parallel Seq Scan и сортировка | 2092 | 4,793 мс |
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| остановка одной реплики | чтение и запись продолжаются | запись шла непрерывно, 0–1 ошибка на раунд | 1,8 с в публичном тесте; потерь нет |
| `docker compose restart` всего стенда | данные и сессия на месте | прежний токен читает прежние сообщения | несколько секунд; потерь нет |
| `docker compose stop redis` | запросы с токеном не выполняются | 503 за 0,015 с, затем 503 от балансировщика; аноним данных не получает | около 2 с после возврата Redis; сессии на месте, сообщение во время отказа не записано |
| `docker compose stop postgres` | запросы к данным не выполняются | 503 за 3,0 с, через 4 с 503 от балансировщика за 0,003 с | около 2 с после возврата; повтор с тем же ключом создаёт одно сообщение |
| TTL сессии и ключа 2 с | сессия истекает, ключ освобождается | через 3 с 401; после срока тот же ключ создаёт новое сообщение | — |
| добавление третьей реплики | балансировщик находит её сам | 9 запросов поровну на 3 реплики | не больше 8 с: проверено через 8 с после запуска |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- **Выдерживается** отказ одной реплики API. **Не выдерживается** отказ `lb`, `postgres`, `redis` или всего хоста: каждый из них один, резервных копий нет. Все контейнеры на одном Docker-хосте, поэтому отказ узла здесь не проверялся и не защищён. Отказ процесса и отказ узла — разные случаи.
- При отказе Redis или PostgreSQL недоступен весь API, включая анонимные запросы через балансировщик. Возврат занимает около 2 с после восстановления зависимости.
- При остановке реплики возможна задержка до 1 с и единичный 502 на запись. Убрать это могла бы пауза перед закрытием сокета со сбросом готовности (drain). Не сделано: цена — более долгая остановка, а клиент и так безопасно повторяет запрос.
- Записи в `idempotency_keys` с истёкшим сроком не удаляются, а перезаписываются при повторном использовании ключа, таблица растёт. Нужна периодическая очистка, в этой работе её нет.
- Сравнение повтора идёт по тексту сообщения. В lab4 появятся `attachment_ids`, сравнение нужно будет расширить.
- После поочерёдной замены номера контейнеров меняются (`api-3`, `api-4`). На работу это не влияет.
- `rolling-update.sh` останавливается при сбое новой реплики, но не откатывает уже заменённые.
- Лимита размера тела запроса нет.
- Нет ограничения числа попыток входа, код 429 не используется.
- Порядок истории при параллельных вставках описан выше.
- `X-Instance-Id` раскрывает короткий id контейнера. Для учебной lab3 допустимо, в lab7 нужен alias.
- Пароли в `.env` лежат открытым текстом на диске разработчика (права 600). Для локального стенда с синтетическими данными это допустимо.
- `make explain` оставляет в БД синтетические чаты; убрать их можно только `make clean`.
- Проверено на одном стенде (macOS, Docker Desktop). На Linux не запускалось. Генератор нагрузки работал на том же компьютере, замеры дают порядок величин, а не предел стенда.
+14
View File
@@ -0,0 +1,14 @@
# Только для тестов срока жизни: отдельный API с короткими TTL, опубликованный на 8081.
# В основной стенд не входит, там API доступен только через балансировщик.
services:
api-short-ttl:
extends:
file: compose.yaml
service: api
environment:
SESSION_TTL_SECONDS: "2"
IDEMPOTENCY_TTL_SECONDS: "2"
ports:
- "127.0.0.1:8081:8080"
deploy:
replicas: 1
+171
View File
@@ -0,0 +1,171 @@
name: mtusi-messenger-lab3
# Настройки и секреты берутся из .env (создаёт scripts/init-env.sh, в Git не попадает).
# Секреты доходят до контейнеров только файлами в /run/secrets, в переменных окружения контейнеров их нет.
x-app: &app
build:
context: .
args:
APP_VERSION: ${APP_VERSION:-dev}
image: mtusi-messenger:lab3
x-app-env: &app-env
APP_HOST: 0.0.0.0
APP_PORT: "8080"
APP_ENV: ${APP_ENV:-lab}
LOG_LEVEL: ${LOG_LEVEL:-info}
SHUTDOWN_TIMEOUT: ${SHUTDOWN_TIMEOUT:-8}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
SESSION_STORE: ${SESSION_STORE:-redis}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
DATABASE_URL_FILE: /run/secrets/database_url
CACHE_URL_FILE: /run/secrets/cache_url
DB_POOL_MIN_SIZE: ${DB_POOL_MIN_SIZE:-2}
DB_POOL_MAX_SIZE: ${DB_POOL_MAX_SIZE:-10}
DB_POOL_TIMEOUT: ${DB_POOL_TIMEOUT:-3}
DB_CONNECT_TIMEOUT: ${DB_CONNECT_TIMEOUT:-3}
DB_STATEMENT_TIMEOUT: ${DB_STATEMENT_TIMEOUT:-5}
CACHE_POOL_MAX_SIZE: ${CACHE_POOL_MAX_SIZE:-20}
CACHE_TIMEOUT: ${CACHE_TIMEOUT:-2}
services:
lb:
build: infra/haproxy
image: mtusi-messenger-lb:lab3
# единственный опубликованный порт стенда
ports:
- "127.0.0.1:8080:8080"
networks:
- edge
depends_on:
api:
condition: service_started
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8404/lb-health"]
interval: 5s
timeout: 3s
retries: 5
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
restart: unless-stopped
api:
<<: *app
environment: *app-env
secrets:
- database_url
- cache_url
networks:
- edge
- data
depends_on:
migrate:
condition: service_completed_successfully
redis:
condition: service_healthy
# SIGTERM -> приём закрыт -> незавершённые запросы до SHUTDOWN_TIMEOUT -> выход раньше SIGKILL
stop_grace_period: 10s
deploy:
replicas: ${API_REPLICAS:-2}
resources:
limits:
cpus: "1.0"
memory: 256M
restart: unless-stopped
# миграции выполняет один контейнер до старта реплик, а не каждая реплика
migrate:
<<: *app
command: ["python", "migrate.py"]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets:
- database_url
networks:
- data
depends_on:
postgres:
condition: service_healthy
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
restart: "no"
postgres:
image: postgres:17.11-alpine
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets:
- postgres_password
networks:
- data
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
restart: unless-stopped
redis:
image: redis:7.4.11-alpine
# сессии хранятся только здесь, поэтому включён AOF с fsync на каждую запись;
# запуск через docker-entrypoint.sh, чтобы процесс работал от пользователя redis, а не от root
command:
- sh
- -c
- exec docker-entrypoint.sh redis-server --appendonly yes --appendfsync always --requirepass "$$(cat /run/secrets/redis_password)"
secrets:
- redis_password
networks:
- data
volumes:
- redisdata:/data
healthcheck:
test: ["CMD-SHELL", "redis-cli --no-auth-warning -a \"$$(cat /run/secrets/redis_password)\" ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 10
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
restart: unless-stopped
networks:
# балансировщик и реплики
edge:
# реплики и хранилища; балансировщик сюда не входит, выхода наружу нет
data:
internal: true
volumes:
pgdata:
redisdata:
secrets:
postgres_password:
environment: POSTGRES_PASSWORD
redis_password:
environment: REDIS_PASSWORD
database_url:
environment: DATABASE_URL
cache_url:
environment: CACHE_URL
+89
View File
@@ -0,0 +1,89 @@
# Запуск из чистого clone на пустых volumes, публичный smoke
# дата: 2026-10-30T18:43Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make env
./scripts/init-env.sh
пароли записаны в .env
$ docker compose --env-file .env config --quiet
$ docker compose --env-file .env up -d --build
Image mtusi-messenger:lab3 Built
Image mtusi-messenger:lab3 Built
Image mtusi-messenger-lb:lab3 Built
Network mtusi-messenger-lab3_data Creating
Network mtusi-messenger-lab3_data Created
Network mtusi-messenger-lab3_edge Creating
Network mtusi-messenger-lab3_edge Created
Volume mtusi-messenger-lab3_redisdata Creating
Volume mtusi-messenger-lab3_redisdata Created
Volume mtusi-messenger-lab3_pgdata Creating
Volume mtusi-messenger-lab3_pgdata Created
Container mtusi-messenger-lab3-redis-1 Creating
Container mtusi-messenger-lab3-postgres-1 Creating
Container mtusi-messenger-lab3-redis-1 Created
Container mtusi-messenger-lab3-postgres-1 Created
Container mtusi-messenger-lab3-migrate-1 Creating
Container mtusi-messenger-lab3-migrate-1 Created
Container mtusi-messenger-lab3-api-2 Creating
Container mtusi-messenger-lab3-api-1 Creating
Container mtusi-messenger-lab3-api-2 Created
Container mtusi-messenger-lab3-api-1 Created
Container mtusi-messenger-lab3-lb-1 Creating
Container mtusi-messenger-lab3-lb-1 Created
Container mtusi-messenger-lab3-redis-1 Starting
Container mtusi-messenger-lab3-postgres-1 Starting
Container mtusi-messenger-lab3-postgres-1 Started
Container mtusi-messenger-lab3-postgres-1 Waiting
Container mtusi-messenger-lab3-redis-1 Started
Container mtusi-messenger-lab3-postgres-1 Healthy
Container mtusi-messenger-lab3-migrate-1 Starting
Container mtusi-messenger-lab3-migrate-1 Started
Container mtusi-messenger-lab3-migrate-1 Waiting
Container mtusi-messenger-lab3-redis-1 Waiting
Container mtusi-messenger-lab3-redis-1 Healthy
Container mtusi-messenger-lab3-migrate-1 Exited
Container mtusi-messenger-lab3-api-2 Starting
Container mtusi-messenger-lab3-api-2 Started
Container mtusi-messenger-lab3-api-1 Starting
Container mtusi-messenger-lab3-api-1 Started
Container mtusi-messenger-lab3-lb-1 Starting
Container mtusi-messenger-lab3-lb-1 Started
$ ./scripts/wait-ready.sh
готов: http://localhost:8080
$ docker compose --env-file .env ps -a
SERVICE IMAGE STATE STATUS PORTS
api mtusi-messenger:lab3 running Up 4 seconds (healthy) 8080/tcp
api mtusi-messenger:lab3 running Up 4 seconds (healthy) 8080/tcp
lb mtusi-messenger-lb:lab3 running Up 4 seconds (health: starting) 127.0.0.1:8080->8080/tcp
migrate mtusi-messenger:lab3 exited Exited (0) 5 seconds ago
postgres postgres:17.11-alpine running Up 11 seconds (healthy) 5432/tcp
redis redis:7.4.11-alpine running Up 11 seconds (healthy) 6379/tcp
$ docker compose --env-file .env logs migrate
migrate-1 | применена: 0001_init.sql
migrate-1 | применена: 0002_idempotency.sql
$ make check
python3 scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
$ make test
python3 tests/smoke.py --base-url "http://localhost:8080"
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
# одна сессия обслуживается разными репликами
$ 6 раз curl /health/live, заголовок X-Instance-Id
x-instance-id: 3a8c5ed61bd5
x-instance-id: b7c5235a859f
x-instance-id: 3a8c5ed61bd5
x-instance-id: b7c5235a859f
x-instance-id: 3a8c5ed61bd5
x-instance-id: b7c5235a859f
# id контейнеров сервиса api
3a8c5ed61bd5
b7c5235a859f
+102
View File
@@ -0,0 +1,102 @@
# Собственные тесты API
# дата: 2026-10-30T18:43Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make student-test
BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests -v
test_blank_title (test_access.CreateChatTest.test_blank_title) ... ok
test_creator_must_be_member (test_access.CreateChatTest.test_creator_must_be_member) ... ok
test_duplicate_members (test_access.CreateChatTest.test_duplicate_members) ... ok
test_empty_members (test_access.CreateChatTest.test_empty_members) ... ok
test_failed_create_leaves_no_chat (test_access.CreateChatTest.test_failed_create_leaves_no_chat) ... ok
test_unknown_member (test_access.CreateChatTest.test_unknown_member) ... ok
test_bad_chat_id (test_access.ForeignChatTest.test_bad_chat_id) ... ok
test_chat_is_not_listed_for_outsider (test_access.ForeignChatTest.test_chat_is_not_listed_for_outsider) ... ok
test_foreign_chat_looks_like_missing_chat (test_access.ForeignChatTest.test_foreign_chat_looks_like_missing_chat) ... ok
test_member_id_must_be_canonical_uuid (test_access.ForeignChatTest.test_member_id_must_be_canonical_uuid) ... ok
test_members_can_read_and_write (test_access.ForeignChatTest.test_members_can_read_and_write) ... ok
test_outsider_gets_404_everywhere (test_access.ForeignChatTest.test_outsider_gets_404_everywhere) ... ok
test_outsider_message_is_not_saved (test_access.ForeignChatTest.test_outsider_message_is_not_saved) ... ok
test_basic_is_not_accepted_on_business_endpoints (test_auth.BearerTest.test_basic_is_not_accepted_on_business_endpoints) ... ok
test_garbage_token_is_401_not_500 (test_auth.BearerTest.test_garbage_token_is_401_not_500) ... ok
test_no_token (test_auth.BearerTest.test_no_token) ... ok
test_token_is_checked_before_anything_else (test_auth.BearerTest.test_token_is_checked_before_anything_else) ... ok
test_unknown_tokens (test_auth.BearerTest.test_unknown_tokens) ... ok
test_x_user_id_does_not_change_identity (test_auth.BearerTest.test_x_user_id_does_not_change_identity) ... ok
test_x_user_id_gives_no_access (test_auth.BearerTest.test_x_user_id_gives_no_access) ... ok
test_colon_and_unicode_in_password (test_auth.LoginTest.test_colon_and_unicode_in_password) ... ok
test_garbage_after_basic_is_401_not_500 (test_auth.LoginTest.test_garbage_after_basic_is_401_not_500) ... ok
test_login (test_auth.LoginTest.test_login) ... ok
test_malformed_credentials (test_auth.LoginTest.test_malformed_credentials) ... ok
test_token_is_opaque_and_unique (test_auth.LoginTest.test_token_is_opaque_and_unique) ... ok
test_username_that_cannot_exist (test_auth.LoginTest.test_username_that_cannot_exist) ... ok
test_wrong_password_and_unknown_user_look_the_same (test_auth.LoginTest.test_wrong_password_and_unknown_user_look_the_same) ... ok
test_login_again_after_logout (test_auth.LogoutTest.test_login_again_after_logout) ... ok
test_logout_requires_token (test_auth.LogoutTest.test_logout_requires_token) ... ok
test_logout_revokes_only_current_session (test_auth.LogoutTest.test_logout_revokes_only_current_session) ... ok
test_invalid_http (test_balancing.ErrorsFromBalancerTest.test_invalid_http) ... ok
test_too_large_headers (test_balancing.ErrorsFromBalancerTest.test_too_large_headers) ... ok
test_too_long_uri (test_balancing.ErrorsFromBalancerTest.test_too_long_uri) ... ok
test_every_answer_has_instance_id (test_balancing.ReplicasTest.test_every_answer_has_instance_id) ... ok
test_logout_works_on_all_replicas (test_balancing.ReplicasTest.test_logout_works_on_all_replicas) ... ok
test_no_sticky_cookie (test_balancing.ReplicasTest.test_no_sticky_cookie) ... ok
test_one_session_is_served_by_different_replicas (test_balancing.ReplicasTest.test_one_session_is_served_by_different_replicas) ... ok
test_read_after_write_on_any_replica (test_balancing.ReplicasTest.test_read_after_write_on_any_replica) ... ok
test_session_created_on_one_replica_works_on_all (test_balancing.ReplicasTest.test_session_created_on_one_replica_works_on_all) ... ok
test_100_messages_from_10_clients (test_concurrency.ConcurrencyTest.test_100_messages_from_10_clients) ... ok
test_same_username_registered_once (test_concurrency.ConcurrencyTest.test_same_username_registered_once) ... ok
test_bad_keys (test_idempotency.IdempotencyTest.test_bad_keys) ... ok
test_good_key_alphabet (test_idempotency.IdempotencyTest.test_good_key_alphabet) ... ok
test_invalid_body_does_not_take_key (test_idempotency.IdempotencyTest.test_invalid_body_does_not_take_key) ... ok
test_key_is_required (test_idempotency.IdempotencyTest.test_key_is_required) ... ok
test_key_order_in_json_does_not_matter (test_idempotency.IdempotencyTest.test_key_order_in_json_does_not_matter) ... ok
test_other_text_with_same_key_is_409 (test_idempotency.IdempotencyTest.test_other_text_with_same_key_is_409) ... ok
test_parallel_repeat_through_different_replicas (test_idempotency.IdempotencyTest.test_parallel_repeat_through_different_replicas) ... ok
test_repeat_checks_access_again (test_idempotency.IdempotencyTest.test_repeat_checks_access_again) ... ok
test_repeat_returns_same_message (test_idempotency.IdempotencyTest.test_repeat_returns_same_message) ... ok
test_same_key_for_other_user_and_other_chat (test_idempotency.IdempotencyTest.test_same_key_for_other_user_and_other_chat) ... ok
test_chat_cursor_belongs_to_user (test_pagination.ChatPaginationTest.test_chat_cursor_belongs_to_user) ... ok
test_walk_chat_list (test_pagination.ChatPaginationTest.test_walk_chat_list) ... ok
test_bad_cursor (test_pagination.MessagePaginationTest.test_bad_cursor) ... ok
test_bad_limit (test_pagination.MessagePaginationTest.test_bad_limit) ... ok
test_cursor_format_is_checked (test_pagination.MessagePaginationTest.test_cursor_format_is_checked) ... ok
test_cursor_from_another_chat (test_pagination.MessagePaginationTest.test_cursor_from_another_chat) ... ok
test_default_limit (test_pagination.MessagePaginationTest.test_default_limit) ... ok
test_exact_page_has_no_cursor (test_pagination.MessagePaginationTest.test_exact_page_has_no_cursor) ... ok
test_limit_can_change_between_pages (test_pagination.MessagePaginationTest.test_limit_can_change_between_pages) ... ok
test_new_message_appears_after_last_page (test_pagination.MessagePaginationTest.test_new_message_appears_after_last_page) ... ok
test_no_duplicates_and_order (test_pagination.MessagePaginationTest.test_no_duplicates_and_order) ... ok
test_walk_several_pages (test_pagination.MessagePaginationTest.test_walk_several_pages) ... ok
test_broken_json_without_token_is_401 (test_validation.InvalidJsonTest.test_broken_json_without_token_is_401) ... ok
test_content_type_must_be_json (test_validation.InvalidJsonTest.test_content_type_must_be_json) ... ok
test_deeply_nested_json (test_validation.InvalidJsonTest.test_deeply_nested_json) ... ok
test_extra_field (test_validation.InvalidJsonTest.test_extra_field) ... ok
test_malformed_json (test_validation.InvalidJsonTest.test_malformed_json) ... ok
test_malformed_json_in_message (test_validation.InvalidJsonTest.test_malformed_json_in_message) ... ok
test_missing_field (test_validation.InvalidJsonTest.test_missing_field) ... ok
test_not_an_object (test_validation.InvalidJsonTest.test_not_an_object) ... ok
test_only_utf8_is_accepted (test_validation.InvalidJsonTest.test_only_utf8_is_accepted) ... ok
test_wrong_type (test_validation.InvalidJsonTest.test_wrong_type) ... ok
test_empty_message (test_validation.MessageValidationTest.test_empty_message) ... ok
test_nul_character (test_validation.MessageValidationTest.test_nul_character) ... ok
test_sender_id_is_not_accepted (test_validation.MessageValidationTest.test_sender_id_is_not_accepted) ... ok
test_text_limit (test_validation.MessageValidationTest.test_text_limit) ... ok
test_unicode_is_kept (test_validation.MessageValidationTest.test_unicode_is_kept) ... ok
test_whitespace_message (test_validation.MessageValidationTest.test_whitespace_message) ... ok
test_bad_display_names (test_validation.UserValidationTest.test_bad_display_names) ... ok
test_bad_passwords (test_validation.UserValidationTest.test_bad_passwords) ... ok
test_bad_usernames (test_validation.UserValidationTest.test_bad_usernames) ... ok
test_display_name_length_is_counted_in_code_points (test_validation.UserValidationTest.test_display_name_length_is_counted_in_code_points) ... ok
test_duplicate_username (test_validation.UserValidationTest.test_duplicate_username) ... ok
test_password_is_never_returned (test_validation.UserValidationTest.test_password_is_never_returned) ... ok
test_password_length_limits (test_validation.UserValidationTest.test_password_length_limits) ... ok
----------------------------------------------------------------------
Ran 86 tests in 2.969s
OK
отправлено 100, подтверждено 100, в истории 100, уникальных id 100
10 ключей по 8 параллельных запросов: реплик 2, сообщений в истории 10
+48
View File
@@ -0,0 +1,48 @@
# Сохранность: перезапуск балансировщика, реплик, PostgreSQL и Redis с сохранением volumes
# дата: 2026-10-30T18:43Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
# до перезапуска
/mtusi-messenger-lab3-api-1 StartedAt=2026-10-30T18:43:31.186405878Z
/mtusi-messenger-lab3-api-2 StartedAt=2026-10-30T18:43:31.097777795Z
/mtusi-messenger-lab3-lb-1 StartedAt=2026-10-30T18:43:31.260557462Z
/mtusi-messenger-lab3-postgres-1 StartedAt=2026-10-30T18:43:24.360103334Z
/mtusi-messenger-lab3-redis-1 StartedAt=2026-10-30T18:43:24.358376875Z
$ cat scripts/restart.sh
#!/bin/sh
# Перезапускает балансировщик, все реплики API и оба хранилища. Volumes не трогает.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api lb
$ make test-persistence ACTION_SCRIPT=scripts/restart.sh
python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
# после перезапуска: новое время старта у всех контейнеров
/mtusi-messenger-lab3-api-1 StartedAt=2026-10-30T18:43:40.663879758Z
/mtusi-messenger-lab3-api-2 StartedAt=2026-10-30T18:43:40.704967008Z
/mtusi-messenger-lab3-lb-1 StartedAt=2026-10-30T18:43:40.433273008Z
/mtusi-messenger-lab3-postgres-1 StartedAt=2026-10-30T18:43:40.567209883Z
/mtusi-messenger-lab3-redis-1 StartedAt=2026-10-30T18:43:40.48552355Z
$ docker volume ls --filter name=mtusi-messenger-lab3
DRIVER VOLUME NAME
local mtusi-messenger-lab3_pgdata
local mtusi-messenger-lab3_redisdata
# повторный запуск миграций
$ docker compose --env-file .env run --rm migrate
Container mtusi-messenger-lab3-postgres-1 Running
Container mtusi-messenger-lab3-postgres-1 Waiting
Container mtusi-messenger-lab3-postgres-1 Healthy
Container mtusi-messenger-lab3-migrate-run-87950778e980 Creating
Container mtusi-messenger-lab3-migrate-run-87950778e980 Created
уже применена: 0001_init.sql
уже применена: 0002_idempotency.sql
$ psql: SELECT version FROM schema_migrations
0001_init.sql
0002_idempotency.sql
+85
View File
@@ -0,0 +1,85 @@
# Публичный failover: два прогона подряд с восстановлением реплики между ними
# дата: 2026-10-30T18:43Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
## прогон 1
# реплики до отказа
NAME STATE STATUS
mtusi-messenger-lab3-api-1 running Up 10 seconds (healthy)
mtusi-messenger-lab3-api-2 running Up 10 seconds (healthy)
$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 120, "failed_attempts": 0, "first_recovery_seconds": 1.822}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
# какой контейнер реально остановлен
NAME STATE STATUS
mtusi-messenger-lab3-api-1 running Up 26 seconds (healthy)
mtusi-messenger-lab3-api-2 exited Exited (0) 14 seconds ago
$ docker compose logs lb | grep 'is DOWN' | tail -2
lb-1 | Server api/api2 is DOWN, reason: Layer4 connection problem, info: "Connection refused", check duration: 0ms. 1 active and 0 backup servers lef
$ make restore
docker compose --env-file .env up -d --no-recreate --no-build api
Container mtusi-messenger-lab3-redis-1 Running
Container mtusi-messenger-lab3-postgres-1 Running
Container mtusi-messenger-lab3-api-1 Running
Container mtusi-messenger-lab3-postgres-1 Waiting
Container mtusi-messenger-lab3-postgres-1 Healthy
Container mtusi-messenger-lab3-migrate-1 Starting
Container mtusi-messenger-lab3-migrate-1 Started
Container mtusi-messenger-lab3-redis-1 Waiting
Container mtusi-messenger-lab3-migrate-1 Waiting
Container mtusi-messenger-lab3-redis-1 Healthy
Container mtusi-messenger-lab3-migrate-1 Exited
Container mtusi-messenger-lab3-api-2 Starting
Container mtusi-messenger-lab3-api-2 Started
BASE_URL="http://localhost:8080" ./scripts/wait-ready.sh
готов: http://localhost:8080
## прогон 2
# реплики до отказа
NAME STATE STATUS
mtusi-messenger-lab3-api-1 running Up 32 seconds (healthy)
mtusi-messenger-lab3-api-2 running Up 4 seconds (healthy)
$ make test-failover ACTION_SCRIPT=scripts/stop-one.sh
python3 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 120, "failed_attempts": 0, "first_recovery_seconds": 1.585}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
# какой контейнер реально остановлен
NAME STATE STATUS
mtusi-messenger-lab3-api-1 running Up 47 seconds (healthy)
mtusi-messenger-lab3-api-2 exited Exited (0) 14 seconds ago
$ docker compose logs lb | grep 'is DOWN' | tail -2
lb-1 | Server api/api2 is DOWN, reason: Layer4 connection problem, info: "Connection refused", check duration: 0ms. 1 active and 0 backup servers lef
lb-1 | Server api/api2 is DOWN, reason: Layer4 connection problem, info: "Connection refused", check duration: 0ms. 1 active and 0 backup servers lef
$ make restore
docker compose --env-file .env up -d --no-recreate --no-build api
Container mtusi-messenger-lab3-postgres-1 Running
Container mtusi-messenger-lab3-redis-1 Running
Container mtusi-messenger-lab3-api-1 Running
Container mtusi-messenger-lab3-postgres-1 Waiting
Container mtusi-messenger-lab3-postgres-1 Healthy
Container mtusi-messenger-lab3-migrate-1 Starting
Container mtusi-messenger-lab3-migrate-1 Started
Container mtusi-messenger-lab3-redis-1 Waiting
Container mtusi-messenger-lab3-migrate-1 Waiting
Container mtusi-messenger-lab3-redis-1 Healthy
Container mtusi-messenger-lab3-migrate-1 Exited
Container mtusi-messenger-lab3-api-2 Starting
Container mtusi-messenger-lab3-api-2 Started
BASE_URL="http://localhost:8080" ./scripts/wait-ready.sh
готов: http://localhost:8080
# реплики в конце
NAME STATE STATUS
mtusi-messenger-lab3-api-1 running Up 53 seconds (healthy)
mtusi-messenger-lab3-api-2 running Up 4 seconds (healthy)
+10
View File
@@ -0,0 +1,10 @@
# Остановка каждой реплики под нагрузкой (SIGTERM), полные данные в failover-each.json
# дата: 2026-10-30T18:44Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make failover-each
BASE_URL="http://localhost:8080" python3 scripts/chaos.py stop --output evidence/failover-each.json
{"seconds": 19.65, "successful_requests": 12992, "failed_attempts": 1, "failed_statuses": [502], "successful_rps": 661.0, "longest_gap_between_successes_s": 1.013, "first_success_after_action_s": 0.0, "last_success_on_target_after_action_s": 14.65, "instances_seen": 2, "target": "3a8c5ed61bd5", "signal": "SIGTERM", "stop_command_s": 0.48, "excluded_by_lb_after_s": 0.59, "verify": {"confirmed": 12992, "in_history": 12992, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
{"seconds": 19.49, "successful_requests": 13416, "failed_attempts": 0, "failed_statuses": [], "successful_rps": 688.4, "longest_gap_between_successes_s": 1.003, "first_success_after_action_s": 0.0, "last_success_on_target_after_action_s": 14.488, "instances_seen": 2, "target": "b7c5235a859f", "signal": "SIGTERM", "stop_command_s": 0.5, "excluded_by_lb_after_s": 1.32, "verify": {"confirmed": 13416, "in_history": 13416, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
PASS: подтверждённые сообщения на месте, дублей нет
+14
View File
@@ -0,0 +1,14 @@
# SIGKILL и зависшая реплика (docker pause) под нагрузкой, полные данные в failover-kill.json и failover-pause.json
# дата: 2026-10-30T18:45Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make failover-hard
BASE_URL="http://localhost:8080" python3 scripts/chaos.py kill --output evidence/failover-kill.json
{"seconds": 18.08, "successful_requests": 12553, "failed_attempts": 2, "failed_statuses": [502], "successful_rps": 694.1, "longest_gap_between_successes_s": 1.009, "first_success_after_action_s": 0.003, "last_success_on_target_after_action_s": 13.081, "instances_seen": 2, "target": "3a8c5ed61bd5", "signal": "SIGKILL", "stop_command_s": 0.25, "excluded_by_lb_after_s": 1.07, "verify": {"confirmed": 12553, "in_history": 12553, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
{"seconds": 19.69, "successful_requests": 13654, "failed_attempts": 3, "failed_statuses": [502], "successful_rps": 693.4, "longest_gap_between_successes_s": 1.018, "first_success_after_action_s": 0.003, "last_success_on_target_after_action_s": 14.688, "instances_seen": 2, "target": "b7c5235a859f", "signal": "SIGKILL", "stop_command_s": 0.25, "excluded_by_lb_after_s": 0.36, "verify": {"confirmed": 13654, "in_history": 13654, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
PASS: подтверждённые сообщения на месте, дублей нет
BASE_URL="http://localhost:8080" python3 scripts/chaos.py pause --output evidence/failover-pause.json
{"seconds": 18.19, "successful_requests": 11314, "failed_attempts": 4, "failed_statuses": [0], "successful_rps": 621.9, "longest_gap_between_successes_s": 3.075, "first_success_after_action_s": 0.004, "last_success_on_target_after_action_s": 13.19, "instances_seen": 2, "target": "3a8c5ed61bd5", "signal": "HANG", "stop_command_s": 0.04, "excluded_by_lb_after_s": 3.16, "verify": {"confirmed": 11314, "in_history": 11314, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
{"seconds": 18.4, "successful_requests": 9341, "failed_attempts": 8, "failed_statuses": [0], "successful_rps": 507.6, "longest_gap_between_successes_s": 3.062, "first_success_after_action_s": 0.0, "last_success_on_target_after_action_s": 13.4, "instances_seen": 2, "target": "b7c5235a859f", "signal": "HANG", "stop_command_s": 0.04, "excluded_by_lb_after_s": 3.46, "verify": {"confirmed": 9341, "in_history": 9341, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
PASS: подтверждённые сообщения на месте, дублей нет
+19
View File
@@ -0,0 +1,19 @@
# Поочерёдная замена реплик под нагрузкой, полные данные в rolling-update.json
# дата: 2026-10-30T18:46Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
# образы до замены
/mtusi-messenger-lab3-api-1 sha256:b20937fe39bd43979dd8d82acf328ac5f52
/mtusi-messenger-lab3-api-2 sha256:b20937fe39bd43979dd8d82acf328ac5f52
$ make rolling-update APP_VERSION=2
BASE_URL="http://localhost:8080" python3 scripts/chaos.py rolling --output evidence/rolling-update.json
{"seconds": 22.41, "successful_requests": 18344, "failed_attempts": 0, "failed_statuses": [], "successful_rps": 818.7, "longest_gap_between_successes_s": 1.007, "first_success_after_action_s": 0.003, "last_success_on_target_after_action_s": null, "instances_seen": 4, "update_seconds": 12.4, "containers_before": {"3a8c5ed61bd5": "sha256:b20937fe39bd", "b7c5235a859f": "sha256:b20937fe39bd"}, "containers_after": {"fb399bd141ea": "sha256:1cfd729d7e32", "69ad5d43951c": "sha256:1cfd729d7e32"}, "app_version": "2", "verify": {"confirmed": 18344, "in_history": 18344, "lost_confirmed": 0, "duplicate_ids": 0, "duplicate_texts": 0, "unconfirmed_but_saved": 0}}
PASS: подтверждённые сообщения на месте, дублей нет
# образы и версия после замены
/mtusi-messenger-lab3-api-3 sha256:1cfd729d7e3265f364f31481205f1a0b9a4 APP_VERSION=2
/mtusi-messenger-lab3-api-4 sha256:1cfd729d7e3265f364f31481205f1a0b9a4 APP_VERSION=2
$ docker compose logs lb | grep -c "status=5" # ответов 5xx через балансировщик за всё время жизни этого lb
5
+37
View File
@@ -0,0 +1,37 @@
# Тесты отказов: истечение сессии и ключа, остановка Redis и PostgreSQL, откат транзакции, гонки
# дата: 2026-10-30T18:50Z, commit: c8a5137
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make test-failures
BASE_URL="http://localhost:8080" python3 -m unittest discover -s student-tests/failures -v
test_postgres_down (test_dependencies.DependencyDownTest.test_postgres_down) ... ok
test_redis_down (test_dependencies.DependencyDownTest.test_redis_down) ... ok
test_uncertain_write_can_be_repeated_with_same_key (test_dependencies.DependencyDownTest.test_uncertain_write_can_be_repeated_with_same_key) ... ok
test_expires_at_matches_ttl (test_expiry.SessionExpiryTest.test_expires_at_matches_ttl) ... ok
test_idempotency_key_is_free_after_ttl (test_expiry.SessionExpiryTest.test_idempotency_key_is_free_after_ttl) ... ok
test_login_after_expiry (test_expiry.SessionExpiryTest.test_login_after_expiry) ... ok
test_requests_do_not_extend_session (test_expiry.SessionExpiryTest.test_requests_do_not_extend_session) ... ok
test_session_expires (test_expiry.SessionExpiryTest.test_session_expires) ... ok
test_chat_with_unknown_member_is_rolled_back (test_transactions.TransactionTest.test_chat_with_unknown_member_is_rolled_back) ... ok
test_failed_message_leaves_no_key (test_transactions.TransactionTest.test_failed_message_leaves_no_key) ... ok
test_migrations_can_be_repeated (test_transactions.TransactionTest.test_migrations_can_be_repeated) ... ok
test_password_is_stored_as_argon2id_hash (test_transactions.TransactionTest.test_password_is_stored_as_argon2id_hash) ... ok
test_same_key_in_parallel_creates_one_row (test_transactions.TransactionTest.test_same_key_in_parallel_creates_one_row) ... ok
test_username_race_creates_one_row (test_transactions.TransactionTest.test_username_race_creates_one_row) ... ok
test_valid_chat_is_committed_whole (test_transactions.TransactionTest.test_valid_chat_is_committed_whole) ... ok
----------------------------------------------------------------------
Ran 15 tests in 63.124s
OK
# время ответа при отказе
$ docker compose stop redis; curl /api/v1/users/me с Bearer-токеном
{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"fd1ba9633a1f45b2b32edbe8fabcdfc0"}}
HTTP 503 за 0.014943 с
$ docker compose stop postgres; curl /health/ready
{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"60cb3d48d62f46e08603858885711899"}}
HTTP 503 за 3.005406 с
$ через 4 секунды: реплики исключены, отвечает балансировщик
{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"16ca6124-f073-41f0-be0d-f510ed4c067b"}}
HTTP 503 за 0.003489 с
+81
View File
@@ -0,0 +1,81 @@
# Контейнеры: лимиты, порты, пользователи, секреты, масштабирование
# дата: 2026-10-30T18:48Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ docker compose ps --format "table {{.Service}} {{.Ports}}" # опубликован только lb
SERVICE PORTS
api 8080/tcp
api 8080/tcp
lb 127.0.0.1:8080->8080/tcp
postgres 5432/tcp
redis 6379/tcp
$ grep -c container_name compose.yaml
0
# лимиты CPU (в наносекундах на секунду) и памяти (байт)
/mtusi-messenger-lab3-api-3 cpus=1000000000 memory=268435456
/mtusi-messenger-lab3-api-4 cpus=1000000000 memory=268435456
/mtusi-messenger-lab3-lb-1 cpus=500000000 memory=134217728
/mtusi-messenger-lab3-postgres-1 cpus=1000000000 memory=536870912
/mtusi-messenger-lab3-redis-1 cpus=500000000 memory=134217728
# сети: балансировщик не видит хранилища
lb mtusi-messenger-lab3_edge
api mtusi-messenger-lab3_data mtusi-messenger-lab3_edge
postgres mtusi-messenger-lab3_data
redis mtusi-messenger-lab3_data
$ docker exec fb399bd141ea id
uid=10001(app) gid=10001(app) groups=10001(app)
$ docker exec <api> ls -l /run/secrets
total 8
-r--r--r-- 1 root root 70 Oct 30 18:46 cache_url
-r--r--r-- 1 root root 95 Oct 30 18:46 database_url
$ docker exec <api> env | grep -ci "password\|postgresql://\|redis://" # секретов в окружении нет
0
$ docker compose --env-file .env images
CONTAINER REPOSITORY TAG PLATFORM IMAGE ID SIZE CREATED
mtusi-messenger-lab3-api-3 mtusi-messenger lab3 linux/arm64 1cfd729d7e32 203MB 18 minutes ago
mtusi-messenger-lab3-api-4 mtusi-messenger lab3 linux/arm64 1cfd729d7e32 203MB 18 minutes ago
mtusi-messenger-lab3-lb-1 mtusi-messenger-lb lab3 linux/arm64 31d9bea36444 38.8MB 6 minutes ago
mtusi-messenger-lab3-migrate-1 sha256 b20937fe39bd43979dd8d82acf328ac5f52c2229fa5711acd76cacb16666703f linux/arm64 b20937fe39bd 203MB 18 minutes ago
mtusi-messenger-lab3-postgres-1 postgres 17.11-alpine linux/arm64/v8 25a89970a832 291MB 6 weeks ago
mtusi-messenger-lab3-redis-1 redis 7.4.11-alpine linux/arm64/v8 ec4f171e9ff0 39.5MB 6 weeks ago
$ docker exec <api> pip freeze
annotated-doc==0.0.5
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.143.0
h11==0.16.0
idna==3.20
opentelemetry-api==1.45.1
psycopg==3.3.6
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.1
pydantic==2.13.5
pydantic_core==2.46.5
redis==8.1.0
starlette==1.7.0
typing-inspection==0.4.4
typing_extensions==4.16.0
uvicorn==0.54.0
$ git ls-files | grep -E "^\.env$|secrets" # в Git секретов нет
(пусто)
# масштабирование до 3 реплик: балансировщик находит новую через DNS
$ docker compose up -d --no-deps --no-recreate --no-build --scale api=3 api
$ 9 раз curl /health/live, число ответов каждой реплики
3 x-instance-id: 69ad5d43951c
3 x-instance-id: fb399bd141ea
3 x-instance-id: fb7499a486c0
+12
View File
@@ -0,0 +1,12 @@
# SIGTERM через балансировщик
# дата: 2026-10-30T18:48Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ python3 scripts/sigterm_check.py
$ docker kill --signal=SIGTERM fb399bd141ea
новых запросов после SIGTERM: 20, попало на останавливаемую реплику: 0
начатые до SIGTERM запросы: ['HTTP/1.1 201 Created']
из них завершила останавливаемая реплика: 3
процесс завершился за 1.43 с, код выхода 0
PASS: остановка корректная и укладывается в 10 секунд
+87
View File
@@ -0,0 +1,87 @@
# Индекс истории: EXPLAIN (ANALYZE, BUFFERS) на 152 048 сообщениях (сид 60 000 плюс записи нагрузочных прогонов), 10 000 в исследуемом чате
# дата: 2026-10-30T18:49Z, commit: 269b449
# стенд: Apple M3 Pro, 11 CPU, 18 GB RAM, macOS 26.1, Docker 29.3.0, Compose 5.1.0
$ make explain
./scripts/explain_history.sh
== Объём данных
messages_total | messages_in_chat | table_size | index_size
----------------+------------------+------------+------------
152048 | 10000 | 16 MB | 15 MB
(1 row)
== 1. Первая страница (limit 50, запрос берёт 51 строку)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..39.54 rows=51 width=79) (actual time=0.010..0.026 rows=51 loops=1)
Buffers: shared hit=10
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..7708.63 rows=10050 width=79) (actual time=0.009..0.023 rows=51 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Buffers: shared hit=10
Planning:
Buffers: shared hit=33
Planning Time: 0.113 ms
Execution Time: 0.037 ms
(9 rows)
== 2. Страница из середины истории: keyset после 5000-го сообщения
QUERY PLAN
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.42..48.43 rows=51 width=79) (actual time=0.006..0.015 rows=51 loops=1)
Buffers: shared hit=8
-> Index Scan using messages_chat_history_idx on messages (cost=0.42..7585.63 rows=8058 width=79) (actual time=0.006..0.013 rows=51 loops=1)
Index Cond: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 10:29:04.094702+00'::timestamp with time zone, 'c58c75ac-5b55-4d4d-b27e-370b05239644'::uuid)))
Buffers: shared hit=8
Planning Time: 0.022 ms
Execution Time: 0.036 ms
(7 rows)
== 3. Та же страница через OFFSET (так делать не стали)
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=3481.50..3481.63 rows=51 width=79) (actual time=2.228..2.232 rows=51 loops=1)
Buffers: shared hit=992
-> Sort (cost=3469.00..3494.13 rows=10050 width=79) (actual time=1.984..2.116 rows=5051 loops=1)
Sort Key: created_at, id
Sort Method: quicksort Memory: 1713kB
Buffers: shared hit=992
-> Bitmap Heap Scan on messages (cost=598.31..2800.93 rows=10050 width=79) (actual time=0.339..1.164 rows=10000 loops=1)
Recheck Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Heap Blocks: exact=856
Buffers: shared hit=986
-> Bitmap Index Scan on messages_chat_history_idx (cost=0.00..595.79 rows=10050 width=0) (actual time=0.281..0.281 rows=10000 loops=1)
Index Cond: (chat_id = '00000000-0000-4000-8000-000000000100'::uuid)
Buffers: shared hit=130
Planning Time: 0.028 ms
Execution Time: 2.277 ms
(15 rows)
== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)
QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=4800.35..4806.21 rows=51 width=79) (actual time=3.835..4.779 rows=51 loops=1)
Buffers: shared hit=2092
-> Gather Merge (cost=4800.35..5345.45 rows=4740 width=79) (actual time=3.834..4.776 rows=51 loops=1)
Workers Planned: 1
Workers Launched: 1
Buffers: shared hit=2092
-> Sort (cost=3800.34..3812.19 rows=4740 width=79) (actual time=2.952..2.953 rows=39 loops=2)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 31kB
Buffers: shared hit=2092
Worker 0: Sort Method: top-N heapsort Memory: 31kB
-> Parallel Seq Scan on messages (cost=0.00..3642.20 rows=4740 width=79) (actual time=2.091..2.813 rows=2500 loops=2)
Filter: ((chat_id = '00000000-0000-4000-8000-000000000100'::uuid) AND (ROW(created_at, id) > ROW('2026-10-30 10:29:04.094702+00'::timestamp with time zone, 'c58c75ac-5b55-4d4d-b27e-370b05239644'::uuid)))
Rows Removed by Filter: 73524
Buffers: shared hit=2077
Planning:
Buffers: shared hit=4
Planning Time: 0.042 ms
Execution Time: 4.793 ms
(19 rows)
+54
View File
@@ -0,0 +1,54 @@
{
"workload": "4 клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом",
"mode": "stop",
"rounds": [
{
"seconds": 19.65,
"successful_requests": 12992,
"failed_attempts": 1,
"failed_statuses": [
502
],
"successful_rps": 661.0,
"longest_gap_between_successes_s": 1.013,
"first_success_after_action_s": 0.0,
"last_success_on_target_after_action_s": 14.65,
"instances_seen": 2,
"target": "3a8c5ed61bd5",
"signal": "SIGTERM",
"stop_command_s": 0.48,
"excluded_by_lb_after_s": 0.59,
"verify": {
"confirmed": 12992,
"in_history": 12992,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
},
{
"seconds": 19.49,
"successful_requests": 13416,
"failed_attempts": 0,
"failed_statuses": [],
"successful_rps": 688.4,
"longest_gap_between_successes_s": 1.003,
"first_success_after_action_s": 0.0,
"last_success_on_target_after_action_s": 14.488,
"instances_seen": 2,
"target": "b7c5235a859f",
"signal": "SIGTERM",
"stop_command_s": 0.5,
"excluded_by_lb_after_s": 1.32,
"verify": {
"confirmed": 13416,
"in_history": 13416,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
}
]
}
+56
View File
@@ -0,0 +1,56 @@
{
"workload": "4 клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом",
"mode": "kill",
"rounds": [
{
"seconds": 18.08,
"successful_requests": 12553,
"failed_attempts": 2,
"failed_statuses": [
502
],
"successful_rps": 694.1,
"longest_gap_between_successes_s": 1.009,
"first_success_after_action_s": 0.003,
"last_success_on_target_after_action_s": 13.081,
"instances_seen": 2,
"target": "3a8c5ed61bd5",
"signal": "SIGKILL",
"stop_command_s": 0.25,
"excluded_by_lb_after_s": 1.07,
"verify": {
"confirmed": 12553,
"in_history": 12553,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
},
{
"seconds": 19.69,
"successful_requests": 13654,
"failed_attempts": 3,
"failed_statuses": [
502
],
"successful_rps": 693.4,
"longest_gap_between_successes_s": 1.018,
"first_success_after_action_s": 0.003,
"last_success_on_target_after_action_s": 14.688,
"instances_seen": 2,
"target": "b7c5235a859f",
"signal": "SIGKILL",
"stop_command_s": 0.25,
"excluded_by_lb_after_s": 0.36,
"verify": {
"confirmed": 13654,
"in_history": 13654,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
}
]
}
+56
View File
@@ -0,0 +1,56 @@
{
"workload": "4 клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом",
"mode": "pause",
"rounds": [
{
"seconds": 18.19,
"successful_requests": 11314,
"failed_attempts": 4,
"failed_statuses": [
0
],
"successful_rps": 621.9,
"longest_gap_between_successes_s": 3.075,
"first_success_after_action_s": 0.004,
"last_success_on_target_after_action_s": 13.19,
"instances_seen": 2,
"target": "3a8c5ed61bd5",
"signal": "HANG",
"stop_command_s": 0.04,
"excluded_by_lb_after_s": 3.16,
"verify": {
"confirmed": 11314,
"in_history": 11314,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
},
{
"seconds": 18.4,
"successful_requests": 9341,
"failed_attempts": 8,
"failed_statuses": [
0
],
"successful_rps": 507.6,
"longest_gap_between_successes_s": 3.062,
"first_success_after_action_s": 0.0,
"last_success_on_target_after_action_s": 13.4,
"instances_seen": 2,
"target": "b7c5235a859f",
"signal": "HANG",
"stop_command_s": 0.04,
"excluded_by_lb_after_s": 3.46,
"verify": {
"confirmed": 9341,
"in_history": 9341,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
}
]
}
+35
View File
@@ -0,0 +1,35 @@
{
"workload": "4 клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом",
"mode": "rolling",
"rounds": [
{
"seconds": 22.41,
"successful_requests": 18344,
"failed_attempts": 0,
"failed_statuses": [],
"successful_rps": 818.7,
"longest_gap_between_successes_s": 1.007,
"first_success_after_action_s": 0.003,
"last_success_on_target_after_action_s": null,
"instances_seen": 4,
"update_seconds": 12.4,
"containers_before": {
"3a8c5ed61bd5": "sha256:b20937fe39bd",
"b7c5235a859f": "sha256:b20937fe39bd"
},
"containers_after": {
"fb399bd141ea": "sha256:1cfd729d7e32",
"69ad5d43951c": "sha256:1cfd729d7e32"
},
"app_version": "2",
"verify": {
"confirmed": 18344,
"in_history": 18344,
"lost_confirmed": 0,
"duplicate_ids": 0,
"duplicate_texts": 0,
"unconfirmed_but_saved": 0
}
}
]
}
+7
View File
@@ -0,0 +1,7 @@
FROM haproxy:3.2.26-alpine
# конфигурация внутри образа: версия балансировщика и его настройки меняются только сборкой
COPY haproxy.cfg /usr/local/etc/haproxy/haproxy.cfg
COPY errors/ /usr/local/etc/haproxy/errors/
RUN ["haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
+8
View File
@@ -0,0 +1,8 @@
HTTP/1.1 400 Bad Request
Content-Type: application/json
Content-Length: 119
Cache-Control: no-cache
Connection: close
X-Request-Id: lb-400
{"error": {"code": "invalid_request", "message": "Некорректный HTTP-запрос", "request_id": "lb-400"}}
+8
View File
@@ -0,0 +1,8 @@
HTTP/1.1 408 Request Timeout
Content-Type: application/json
Content-Length: 124
Cache-Control: no-cache
Connection: close
X-Request-Id: lb-408
{"error": {"code": "invalid_request", "message": "Запрос не получен вовремя", "request_id": "lb-408"}}
+8
View File
@@ -0,0 +1,8 @@
HTTP/1.1 414 URI Too Long
Content-Type: application/json
Content-Length: 132
Cache-Control: no-cache
Connection: close
X-Request-Id: lb-414
{"error": {"code": "invalid_request", "message": "Слишком длинный адрес запроса", "request_id": "lb-414"}}
+8
View File
@@ -0,0 +1,8 @@
HTTP/1.1 431 Request Header Fields Too Large
Content-Type: application/json
Content-Length: 140
Cache-Control: no-cache
Connection: close
X-Request-Id: lb-431
{"error": {"code": "invalid_request", "message": "Слишком большие заголовки запроса", "request_id": "lb-431"}}
+68
View File
@@ -0,0 +1,68 @@
global
log stdout format raw local0 info
maxconn 2000
defaults
mode http
log global
# в лог не попадают query string и заголовки: только путь, код, тайминги и выбранный сервер
log-format "%ci %HM %HPO status=%ST server=%s retries=%rc Tq=%TR Tw=%Tw Tc=%Tc Tr=%Tr Ta=%Ta"
# новое соединение с API на каждый запрос: остановленная реплика сразу видна как отказ соединения,
# а такой запрос до приложения не дошёл, поэтому его безопасно отправить на другую
option http-server-close
retries 2
retry-on conn-failure
option redispatch 1
timeout connect 1s
timeout http-request 10s
timeout queue 3s
# больше любого ответа API: 3 с на соединение из пула + 5 с на запрос + 2 с на Redis
timeout server 12s
timeout client 30s
timeout http-keep-alive 30s
timeout check 1s
# запрос, который не удалось разобрать: своего id у него ещё нет, поэтому ответы готовые, в формате контракта
errorfile 400 /usr/local/etc/haproxy/errors/400.http
errorfile 408 /usr/local/etc/haproxy/errors/408.http
errorfile 414 /usr/local/etc/haproxy/errors/414.http
errorfile 431 /usr/local/etc/haproxy/errors/431.http
resolvers docker
nameserver dns 127.0.0.11:53
accepted_payload_size 8192
# DNS Docker убирает остановленные контейнеры и добавляет новые, список реплик обновляется сам
timeout resolve 1s
timeout retry 1s
hold valid 2s
hold obsolete 0s
hold nx 2s
frontend api_in
bind *:8080
unique-id-format %[uuid(4)]
default_backend api
# ответы самого балансировщика в формате ошибок контракта
http-error status 500 content-type application/json lf-string '{"error":{"code":"internal_error","message":"Внутренняя ошибка сервера","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
http-error status 502 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
http-error status 503 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
http-error status 504 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Сервис временно недоступен","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
backend api
balance roundrobin
# без sticky session: любой запрос может уйти на любую реплику
option httpchk GET /health/ready
http-check expect status 200
# проверка раз в секунду, две неудачи подряд исключают реплику, две удачи возвращают
default-server check inter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
# до 6 реплик; адреса приходят из DNS по имени сервиса
server-template api 1-6 api:8080
# только внутри контейнера lb, порт не опубликован
frontend internal
bind *:8404
monitor-uri /lb-health
stats enable
stats uri /stats
stats refresh 0
no log
+39
View File
@@ -0,0 +1,39 @@
-- Пользователи, чаты, участники и сообщения.
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 now()
);
CREATE TABLE chats (
id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
user_id uuid NOT NULL REFERENCES users (id),
-- порядок участника в исходном запросе, чтобы member_ids возвращались как были переданы
position integer NOT NULL,
PRIMARY KEY (chat_id, user_id)
);
-- список чатов пользователя: поиск по user_id, первичный ключ начинается с chat_id и для этого не подходит
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 REFERENCES chats (id) ON DELETE CASCADE,
sender_id uuid NOT NULL REFERENCES users (id),
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT now()
);
-- история чата читается запросом
-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) ORDER BY created_at, id LIMIT $4
-- индекс в том же порядке даёт и фильтр, и сортировку без чтения всей истории
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
+12
View File
@@ -0,0 +1,12 @@
-- Результат отправки сообщения по Idempotency-Key. Только новая таблица: версия API без неё продолжает работать.
CREATE TABLE idempotency_keys (
user_id uuid NOT NULL REFERENCES users (id),
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
-- проверка отложена до COMMIT: ключ вставляется раньше сообщения, чтобы занять его первым
message_id uuid NOT NULL REFERENCES messages (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
created_at timestamptz NOT NULL DEFAULT now(),
-- область уникальности из контракта: пользователь + метод + путь чата + ключ
PRIMARY KEY (user_id, chat_id, key)
);
+24
View File
@@ -0,0 +1,24 @@
# Прямые зависимости
fastapi==0.143.0
uvicorn==0.54.0
psycopg[binary,pool]==3.3.6
redis==8.1.0
argon2-cffi==25.1.0
# Транзитивные, зафиксированы по pip freeze в python:3.13.16-slim-bookworm
annotated-doc==0.0.5
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi-bindings==26.1.0
cffi==2.1.1
click==8.5.0
h11==0.16.0
idna==3.20
opentelemetry-api==1.45.1
psycopg-binary==3.3.6
psycopg-pool==3.3.3
pycparser==3.1
pydantic==2.13.5
pydantic_core==2.46.5
starlette==1.7.0
typing-inspection==0.4.4
typing_extensions==4.16.0
+245
View File
@@ -0,0 +1,245 @@
#!/usr/bin/env python3
"""Нагрузка записью через балансировщик во время отказа или замены реплик.
stop — по очереди останавливает каждую реплику (SIGTERM), восстанавливая предыдущую;
kill — то же, но SIGKILL, без корректного завершения;
pause — то же, но реплика зависает (docker pause): соединения открыты, ответов нет;
rolling — запускает scripts/rolling-update.sh.
Клиент ведёт себя как в контракте: при неопределённом ответе повторяет запрос с тем же ключом.
В конце вся история сверяется с подтверждёнными сообщениями.
"""
import argparse
import json
import math
import os
import subprocess
import sys
import threading
import time
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "student-tests"))
from api import call, history, new_chat, new_user, send
WORKERS = 4
def compose(*args):
command = ["docker", "compose", "--env-file", ".env", *args]
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
def api_containers():
return compose("ps", "-q", "api").split()
def wait_ready(seconds=60):
deadline = time.monotonic() + seconds
while time.monotonic() < deadline:
try:
if call("GET", "/health/ready", timeout=2)[0] == 200:
return
except OSError:
pass
time.sleep(0.2)
raise SystemExit("стенд не стал готов")
def wait_replicas(count):
"""Ждёт, пока балансировщик начнёт отдавать запросы на count разных реплик."""
deadline = time.monotonic() + 30
while time.monotonic() < deadline:
seen = {call("GET", "/health/live", timeout=2)[2]["X-Instance-Id"] for _ in range(count * 4)}
if len(seen) >= count:
return
time.sleep(0.2)
raise SystemExit("балансировщик не видит %d реплик" % count)
class Load:
"""Несколько клиентов пишут в один чат, каждое событие сохраняется с отметкой времени."""
def __init__(self):
self.user = new_user("chaos")
self.chat = new_chat(self.user)
self.stop = threading.Event()
self.events = [] # (время, ok, реплика, статус)
self.confirmed = {}
self.lock = threading.Lock()
self.threads = [threading.Thread(target=self.worker, args=(n,)) for n in range(WORKERS)]
def worker(self, number):
index = 0
while not self.stop.is_set():
text = "worker-%d-%d-%s" % (number, index, uuid.uuid4().hex[:8])
key = uuid.uuid4().hex
index += 1
while True:
try:
status, body, headers = send(self.user, self.chat, text, key=key, timeout=3)
instance = headers.get("X-Instance-Id")
except OSError:
status, body, instance = 0, None, None
now = time.monotonic()
ok = status == 201
with self.lock:
self.events.append((now, ok, instance, status))
if ok:
self.confirmed[body["id"]] = body
if ok or self.stop.is_set():
break
time.sleep(0.05) # неопределённый результат: тот же текст и тот же ключ
def start(self):
for thread in self.threads:
thread.start()
def finish(self):
self.stop.set()
for thread in self.threads:
thread.join()
def percentile(values, p):
ordered = sorted(values)
return round(ordered[max(0, math.ceil(p * len(ordered)) - 1)], 3) if ordered else None
def summary(events, started, action_at, target=None):
"""Показатели одного интервала: от action_at считается время до восстановления записи."""
ok = [e for e in events if e[1]]
failed = [e for e in events if not e[1]]
elapsed = events[-1][0] - started
gaps = [b[0] - a[0] for a, b in zip(ok, ok[1:])]
after = [e for e in ok if e[0] >= action_at]
last_on_target = [e[0] for e in ok if target and e[2] and target.startswith(e[2])]
return {
"seconds": round(elapsed, 2),
"successful_requests": len(ok),
"failed_attempts": len(failed),
"failed_statuses": sorted({e[3] for e in failed}),
"successful_rps": round(len(ok) / elapsed, 1),
"longest_gap_between_successes_s": round(max(gaps), 3) if gaps else None,
"first_success_after_action_s": round(after[0][0] - action_at, 3) if after else None,
"last_success_on_target_after_action_s": round(last_on_target[-1] - action_at, 3)
if last_on_target and last_on_target[-1] >= action_at else None,
"instances_seen": len({e[2] for e in ok}),
}
def verify(load):
items, _ = history(load.user, load.chat, 100)
by_id = {item["id"]: item for item in items}
texts = [item["text"] for item in items]
lost = [mid for mid, message in load.confirmed.items() if by_id.get(mid) != message]
result = {
"confirmed": len(load.confirmed),
"in_history": len(items),
"lost_confirmed": len(lost),
"duplicate_ids": len(items) - len(by_id),
"duplicate_texts": len(texts) - len(set(texts)),
}
result["unconfirmed_but_saved"] = len(items) - len(load.confirmed)
return result
def replicas_up():
"""Сколько реплик балансировщик считает рабочими, по его странице статистики."""
csv = compose("exec", "-T", "lb", "wget", "-q", "-O", "-", "http://127.0.0.1:8404/stats;csv")
return sum(line.startswith("api,api") and ",UP" in line for line in csv.splitlines())
def seconds_until_excluded(replicas, since, limit=8):
while time.monotonic() - since < limit:
if replicas_up() < replicas:
return round(time.monotonic() - since, 2)
time.sleep(0.1)
return None
def replica_round(signal):
containers = api_containers()
wait_replicas(len(containers))
rounds = []
for container in containers:
load = Load()
started = time.monotonic()
load.start()
time.sleep(5)
action_at = time.monotonic()
command = {"SIGTERM": "stop", "SIGKILL": "kill", "HANG": "pause"}[signal]
subprocess.run(["docker", command, container], check=True, stdout=subprocess.DEVNULL)
stop_took = time.monotonic() - action_at
excluded_after = seconds_until_excluded(len(containers), action_at)
time.sleep(max(0, 10 - (time.monotonic() - action_at)))
command = "unpause" if signal == "HANG" else "start"
subprocess.run(["docker", command, container], check=True, stdout=subprocess.DEVNULL)
wait_replicas(len(containers))
time.sleep(2)
load.finish()
result = summary(load.events, started, action_at, container)
result.update({"target": container[:12], "signal": signal, "stop_command_s": round(stop_took, 2),
"excluded_by_lb_after_s": excluded_after})
result["verify"] = verify(load)
print(json.dumps(result, ensure_ascii=False))
rounds.append(result)
return rounds
def images():
inspect = ["docker", "inspect", "-f", "{{.Image}}"]
return {c[:12]: subprocess.check_output(inspect + [c], text=True).strip()[:19] for c in api_containers()}
def rolling_round():
before = images()
wait_replicas(len(before))
load = Load()
started = time.monotonic()
load.start()
time.sleep(5)
action_at = time.monotonic()
subprocess.run(["./scripts/rolling-update.sh"], cwd=ROOT, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
update_took = time.monotonic() - action_at
time.sleep(5)
load.finish()
after = images()
result = summary(load.events, started, action_at)
result.update({"update_seconds": round(update_took, 2), "containers_before": before, "containers_after": after,
"app_version": os.environ.get("APP_VERSION", "dev")})
result["verify"] = verify(load)
print(json.dumps(result, ensure_ascii=False))
# без этой проверки скрипт, который ничего не заменил, выглядел бы как идеальное обновление
if set(before) & set(after) or set(before.values()) & set(after.values()) or len(after) != len(before):
raise SystemExit("FAIL: реплики не заменены новым образом")
return [result]
def main():
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("mode", choices=["stop", "kill", "pause", "rolling"])
parser.add_argument("--output")
args = parser.parse_args()
wait_ready()
if args.mode == "rolling":
rounds = rolling_round()
else:
rounds = replica_round({"stop": "SIGTERM", "kill": "SIGKILL", "pause": "HANG"}[args.mode])
report = {
"workload": "%d клиента, closed loop, POST сообщений через балансировщик, повтор с тем же ключом" % WORKERS,
"mode": args.mode,
"rounds": rounds,
}
if args.output:
Path(args.output).write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n")
bad = [r for r in rounds if r["verify"]["lost_confirmed"] or r["verify"]["duplicate_ids"] or r["verify"]["duplicate_texts"]]
if bad:
raise SystemExit("FAIL: потеряны или продублированы сообщения")
print("PASS: подтверждённые сообщения на месте, дублей нет")
if __name__ == "__main__":
main()
+11
View File
@@ -0,0 +1,11 @@
#!/bin/sh
# Наполняет БД синтетической историей и печатает планы запросов пагинации.
set -eu
cd "$(dirname "$0")/.."
run_sql() {
docker compose --env-file .env exec -T postgres psql -U messenger -d messenger -v ON_ERROR_STOP=1 -q
}
run_sql < scripts/seed_history.sql
run_sql < scripts/explain_history.sql
+44
View File
@@ -0,0 +1,44 @@
\set chat '00000000-0000-4000-8000-000000000100'
\pset pager off
\echo '== Объём данных'
SELECT count(*) AS messages_total,
count(*) FILTER (WHERE chat_id = :'chat') AS messages_in_chat,
pg_size_pretty(pg_relation_size('messages')) AS table_size,
pg_size_pretty(pg_relation_size('messages_chat_history_idx')) AS index_size
FROM messages;
\echo
\echo '== 1. Первая страница (limit 50, запрос берёт 51 строку)'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat'
ORDER BY created_at, id LIMIT 51;
-- cursor на 5000-е сообщение чата, как его получил бы клиент после 100 страниц
SELECT created_at AS after_time, id AS after_id FROM messages
WHERE chat_id = :'chat' ORDER BY created_at, id OFFSET 4999 LIMIT 1 \gset
\echo
\echo '== 2. Страница из середины истории: keyset после 5000-го сообщения'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
ORDER BY created_at, id LIMIT 51;
\echo
\echo '== 3. Та же страница через OFFSET (так делать не стали)'
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat'
ORDER BY created_at, id OFFSET 5000 LIMIT 51;
\echo
\echo '== 4. Запрос из пункта 2 без индекса messages_chat_history_idx (DROP INDEX внутри транзакции с ROLLBACK)'
BEGIN;
DROP INDEX messages_chat_history_idx;
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'chat' AND (created_at, id) > (:'after_time', :'after_id')
ORDER BY created_at, id LIMIT 51;
ROLLBACK;
+25
View File
@@ -0,0 +1,25 @@
#!/bin/sh
# Создаёт .env из .env.example и дописывает в него случайные пароли. Файл .env исключён из Git.
set -eu
cd "$(dirname "$0")/.."
[ -f .env ] || cp .env.example .env
if grep -q '^POSTGRES_PASSWORD=' .env; then
# пароль PostgreSQL задаётся один раз при создании volume, новый пароль к старым данным не подойдёт
echo ".env уже содержит пароли, ничего не меняю"
exit 0
fi
postgres_password=$(openssl rand -hex 24)
redis_password=$(openssl rand -hex 24)
cat >> .env <<END
# Локальные секреты, созданы scripts/init-env.sh. Compose кладёт их в контейнеры файлами /run/secrets/*.
POSTGRES_PASSWORD=$postgres_password
REDIS_PASSWORD=$redis_password
DATABASE_URL=postgresql://messenger:$postgres_password@postgres:5432/messenger
CACHE_URL=redis://:$redis_password@redis:6379/0
END
chmod 600 .env
echo "пароли записаны в .env"
+5
View File
@@ -0,0 +1,5 @@
#!/bin/sh
# Перезапускает балансировщик, все реплики API и оба хранилища. Volumes не трогает.
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres redis api lb
+38
View File
@@ -0,0 +1,38 @@
#!/bin/sh
# Поочерёдно заменяет реплики API новым образом: сначала новая готова, потом старая останавливается.
# Миграции выполняются один раз до замены, поэтому они должны быть совместимы с работающей версией.
set -eu
cd "$(dirname "$0")/.."
compose="docker compose --env-file .env"
$compose build api
$compose run --rm migrate
old=$($compose ps -q api)
count=$(echo "$old" | wc -l | tr -d ' ')
wait_healthy() {
for attempt in $(seq 1 60); do
unhealthy=0
# переменная цикла отдельная: в sh нет локальных переменных, а $container нужен внешнему циклу
for replica in $($compose ps -q api); do
[ "$(docker inspect -f '{{.State.Health.Status}}' "$replica")" = healthy ] || unhealthy=1
done
if [ "$unhealthy" = 0 ]; then
return 0
fi
sleep 1
done
echo "новая реплика не стала healthy за 60 секунд, замена остановлена" >&2
exit 1
}
for container in $old; do
$compose up -d --no-deps --no-recreate --no-build --scale api=$((count + 1)) api
wait_healthy
# балансировщику нужно две удачные проверки с периодом 1 с, с запасом
sleep 3
docker stop "$container"
docker rm "$container"
done
echo "замена завершена, реплик: $($compose ps -q api | wc -l | tr -d ' ')"
+26
View File
@@ -0,0 +1,26 @@
-- Синтетические данные для EXPLAIN: 21 чат и 60 000 сообщений, из них 10 000 в исследуемом чате.
-- Повторный запуск ничего не добавляет. Войти под этим пользователем нельзя: вместо hash стоит заглушка.
INSERT INTO users (id, username, display_name, password_hash)
VALUES ('00000000-0000-4000-8000-000000000001', 'explain_seed', 'Данные для EXPLAIN', '!')
ON CONFLICT DO NOTHING;
INSERT INTO chats (id, title)
SELECT ('00000000-0000-4000-8000-0000000001' || lpad(n::text, 2, '0'))::uuid, 'EXPLAIN чат ' || n
FROM generate_series(0, 20) AS n
ON CONFLICT DO NOTHING;
INSERT INTO chat_members (chat_id, user_id, position)
SELECT id, '00000000-0000-4000-8000-000000000001', 0 FROM chats WHERE title LIKE 'EXPLAIN чат %'
ON CONFLICT DO NOTHING;
-- чат 00: 10 000 сообщений; чаты 01..20: по 2 500. Время идёт с шагом в секунду и перемешано между чатами.
INSERT INTO messages (chat_id, sender_id, text, created_at)
SELECT ('00000000-0000-4000-8000-0000000001' || lpad((CASE WHEN n % 6 = 0 THEN 0 ELSE 1 + n % 20 END)::text, 2, '0'))::uuid,
'00000000-0000-4000-8000-000000000001',
'сообщение ' || n,
now() - make_interval(secs => 60000 - n)
FROM generate_series(1, 60000) AS n
WHERE NOT EXISTS (SELECT 1 FROM messages WHERE chat_id = '00000000-0000-4000-8000-000000000100');
ANALYZE messages;
+82
View File
@@ -0,0 +1,82 @@
#!/usr/bin/env python3
"""Проверка SIGTERM через балансировщик: начатые запросы завершаются, новые уходят на другую реплику,
процесс выходит быстрее 10 секунд. API наружу не опубликован, поэтому незаконченные запросы открываются
на все реплики сразу: часть из них обязательно окажется на останавливаемой."""
import json
import socket
import subprocess
import sys
import time
import urllib.parse
import uuid
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "student-tests"))
from api import BASE_URL, call, new_chat, new_user
LIMIT_SECONDS = 10
OPEN_REQUESTS = 6
def main():
containers = subprocess.run(
["docker", "compose", "--env-file", ".env", "ps", "-q", "api"],
cwd=ROOT, check=True, capture_output=True, text=True,
).stdout.split()
target = containers[0]
address = urllib.parse.urlsplit(BASE_URL)
user = new_user("sigterm")
chat = new_chat(user)
# заголовки и половина тела: запрос уже начат, но ещё не закончен
body = json.dumps({"text": "сообщение, отправленное во время остановки"}).encode()
connections = []
for _ in range(OPEN_REQUESTS):
head = (
"POST /api/v1/chats/%s/messages HTTP/1.1\r\nHost: %s\r\nContent-Type: application/json\r\n"
"Content-Length: %d\r\nAuthorization: Bearer %s\r\nIdempotency-Key: %s\r\n\r\n"
% (chat["id"], address.netloc, len(body), user["token"], uuid.uuid4().hex)
).encode()
connection = socket.create_connection((address.hostname, address.port), timeout=LIMIT_SECONDS)
connection.sendall(head + body[:10])
connections.append(connection)
time.sleep(0.5)
print("$ docker kill --signal=SIGTERM", target[:12])
started = time.monotonic()
subprocess.run(["docker", "kill", "--signal=SIGTERM", target], check=True, stdout=subprocess.DEVNULL)
time.sleep(1)
served = [call("GET", "/health/live")[2]["X-Instance-Id"] for _ in range(20)]
new_on_target = sum(target.startswith(instance) for instance in served)
print("новых запросов после SIGTERM: 20, попало на останавливаемую реплику:", new_on_target)
finished_on_target = 0
statuses = []
for connection in connections:
connection.sendall(body[10:])
answer = connection.recv(65536).decode("utf-8", "replace")
connection.close()
statuses.append(answer.split("\r\n")[0])
for line in answer.split("\r\n"):
if line.lower().startswith("x-instance-id:") and target.startswith(line.split(":")[1].strip()):
finished_on_target += 1
print("начатые до SIGTERM запросы:", sorted(set(statuses)))
print("из них завершила останавливаемая реплика:", finished_on_target)
exit_code = subprocess.run(["docker", "wait", target], check=True, capture_output=True, text=True).stdout.strip()
elapsed = time.monotonic() - started
print("процесс завершился за %.2f с, код выхода %s" % (elapsed, exit_code))
# контейнер, остановленный через docker kill, сам не перезапускается: поднимаем его обратно
subprocess.run(["docker", "start", target], check=True, stdout=subprocess.DEVNULL)
good = all(" 201 " in status for status in statuses)
if not good or new_on_target or not finished_on_target or elapsed > LIMIT_SECONDS or exit_code != "0":
raise SystemExit("FAIL")
print("PASS: остановка корректная и укладывается в %d секунд" % LIMIT_SECONDS)
if __name__ == "__main__":
main()
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
# Останавливает реплику API, которая обслужила тест, и оставляет её остановленной.
# Вернуть реплику: make restore
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
cd "$(dirname "$0")/.."
# X-Instance-Id равен короткому id контейнера; ищем только среди контейнеров сервиса api этого стенда
container=$(docker compose --env-file .env ps -q api | grep "^$TARGET_INSTANCE_ID" || true)
if [ -z "$container" ]; then
echo "реплика $TARGET_INSTANCE_ID не найдена среди контейнеров сервиса api" >&2
exit 3
fi
docker stop "$container"
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Ждёт, пока /health/ready ответит 200, не дольше 60 секунд.
BASE_URL=${BASE_URL:-http://localhost:8080}
for attempt in $(seq 1 60); do
if curl -fs -o /dev/null "$BASE_URL/health/ready"; then
echo "готов: $BASE_URL"
exit 0
fi
sleep 1
done
echo "стенд не стал готов за 60 секунд: $BASE_URL" >&2
exit 1
+47
View File
@@ -0,0 +1,47 @@
import os
import socket
from pathlib import Path
HOST = os.getenv("APP_HOST", "0.0.0.0")
PORT = int(os.getenv("APP_PORT", "8080"))
ENV = os.getenv("APP_ENV", "lab")
VERSION = os.getenv("APP_VERSION", "dev")
# имя контейнера совпадает с коротким id, по нему scripts/stop-one.sh находит реплику; в lab7 заменить на alias
INSTANCE_ID = socket.gethostname()
LOG_LEVEL = os.getenv("LOG_LEVEL", "info").lower()
# docker stop по умолчанию ждёт 10 секунд, поэтому укладываемся с запасом
SHUTDOWN_TIMEOUT = int(os.getenv("SHUTDOWN_TIMEOUT", "8"))
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
SESSION_STORE = os.getenv("SESSION_STORE", "redis")
# сколько хранить результат отправки сообщения по Idempotency-Key, контракт требует не менее 24 часов
IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
# пул соединений с PostgreSQL и таймауты, всё в секундах
DB_POOL_MIN_SIZE = int(os.getenv("DB_POOL_MIN_SIZE", "2"))
DB_POOL_MAX_SIZE = int(os.getenv("DB_POOL_MAX_SIZE", "10"))
DB_POOL_TIMEOUT = float(os.getenv("DB_POOL_TIMEOUT", "3"))
DB_CONNECT_TIMEOUT = int(os.getenv("DB_CONNECT_TIMEOUT", "3"))
DB_STATEMENT_TIMEOUT = int(os.getenv("DB_STATEMENT_TIMEOUT", "5"))
CACHE_POOL_MAX_SIZE = int(os.getenv("CACHE_POOL_MAX_SIZE", "20"))
CACHE_TIMEOUT = float(os.getenv("CACHE_TIMEOUT", "2"))
def read_secret(name: str) -> str:
"""Значение берётся из файла, путь к которому лежит в NAME_FILE. Для отладки без Docker подойдёт и сама NAME."""
path = os.getenv(name + "_FILE")
if path and Path(path).is_file():
return Path(path).read_text().strip()
value = os.getenv(name)
if not value:
raise SystemExit(f"не задан {name}_FILE или {name}")
return value
def database_url() -> str:
return read_secret("DATABASE_URL")
def cache_url() -> str:
return read_secret("CACHE_URL")
+38
View File
@@ -0,0 +1,38 @@
from fastapi.responses import JSONResponse
class ApiError(Exception):
def __init__(self, status: int, code: str, message: str, headers=None):
self.status = status
self.code = code
self.message = message
self.headers = headers
def invalid(message: str) -> ApiError:
return ApiError(400, "invalid_request", message)
def bad_credentials() -> ApiError:
# один и тот же ответ для неизвестного username и неверного пароля
return ApiError(
401, "unauthorized", "Неверное имя пользователя или пароль",
{"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'},
)
def unauthorized() -> ApiError:
return ApiError(
401, "unauthorized", "Нужен действующий Bearer-токен",
{"WWW-Authenticate": 'Bearer realm="messenger"'},
)
def not_found() -> ApiError:
# одинаковый ответ для несуществующего и чужого объекта
return ApiError(404, "not_found", "Объект не найден")
def error_response(request_id: str, status: int, code: str, message: str, headers=None) -> JSONResponse:
body = {"error": {"code": code, "message": message, "request_id": request_id}}
return JSONResponse(body, status_code=status, headers=headers)
+11
View File
@@ -0,0 +1,11 @@
"""Проверка для Docker HEALTHCHECK: код 0, если /health/ready отвечает 200."""
import os
import sys
import urllib.request
port = os.getenv("APP_PORT", "8080")
try:
with urllib.request.urlopen(f"http://127.0.0.1:{port}/health/ready", timeout=4) as response:
sys.exit(0 if response.status == 200 else 1)
except Exception:
sys.exit(1)
+326
View File
@@ -0,0 +1,326 @@
import base64
import json
import logging
import re
import sys
import time
import uuid
from contextlib import asynccontextmanager
from dataclasses import dataclass
from datetime import datetime, timedelta, timezone
from typing import Annotated
from uuid import UUID
import psycopg
import redis
import uvicorn
from fastapi import Depends, FastAPI, Path, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from pydantic import ValidationError
from starlette.exceptions import HTTPException
import config
import security
from errors import ApiError, bad_credentials, error_response, invalid, not_found, unauthorized
from schemas import UUID_PATTERN, CreateChat, CreateMessage, CreateUser
from sessions import Sessions
from store import TIME_FORMAT, IdempotencyConflict, Store, UnknownMember, UsernameTaken, timestamp
logging.basicConfig(
level=config.LOG_LEVEL.upper(),
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
stream=sys.stdout,
)
log = logging.getLogger("messenger")
if config.SESSION_STORE != "redis":
sys.exit("поддерживается только SESSION_STORE=redis")
USERNAME = re.compile(r"[a-z0-9_]{3,32}")
IDEMPOTENCY_KEY = re.compile(r"[A-Za-z0-9._:-]{1,128}")
ChatId = Annotated[str, Path(pattern=UUID_PATTERN)]
store = Store(config.database_url())
sessions = Sessions(config.cache_url())
@asynccontextmanager
async def lifespan(app: FastAPI):
store.open()
log.info(
"started env=%s version=%s instance=%s listen=%s:%d session_ttl=%ds db_pool_max=%d",
config.ENV, config.VERSION, config.INSTANCE_ID, config.HOST, config.PORT,
config.SESSION_TTL_SECONDS, config.DB_POOL_MAX_SIZE,
)
yield
store.close()
sessions.close()
log.info("stopped")
app = FastAPI(title="MTUSI Messenger lab3", lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None)
@app.middleware("http")
async def request_context(request: Request, call_next):
request_id = uuid.uuid4().hex
request.state.request_id = request_id
started = time.perf_counter()
try:
response = await call_next(request)
except Exception:
log.exception("unhandled error request_id=%s", request_id)
response = error_response(request_id, 500, "internal_error", "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request_id
response.headers["X-Instance-Id"] = config.INSTANCE_ID
# балансировщик проверяет готовность каждую секунду, эти запросы видны только на уровне debug
level = logging.DEBUG if request.url.path.startswith("/health/") else logging.INFO
# в лог идут только метод, путь и код ответа: тела запросов, пароли и токены не пишем
log.log(
level, "%s %s status=%d duration_ms=%.1f request_id=%s",
request.method, request.url.path, response.status_code,
(time.perf_counter() - started) * 1000, request_id,
)
return response
@app.exception_handler(ApiError)
async def on_api_error(request: Request, exc: ApiError):
return error_response(request.state.request_id, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def on_validation_error(request: Request, exc: RequestValidationError):
first = exc.errors()[0]
where = ".".join(str(part) for part in first["loc"])
return error_response(request.state.request_id, 400, "invalid_request", f"{where}: {first['msg']}")
@app.exception_handler(HTTPException)
async def on_http_error(request: Request, exc: HTTPException):
# сюда попадают ошибки самого фреймворка: неизвестный путь, неподдерживаемый метод
if exc.status_code == 404:
code, message = "not_found", "Объект не найден"
else:
code, message = "invalid_request", "Запрос не поддерживается"
return error_response(request.state.request_id, exc.status_code, code, message, exc.headers)
# OperationalError — нет связи с PostgreSQL, не дождались соединения из пула или сработал statement_timeout
@app.exception_handler(psycopg.OperationalError)
async def on_database_down(request: Request, exc: Exception):
log.warning("postgres unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@app.exception_handler(redis.RedisError)
async def on_cache_down(request: Request, exc: Exception):
log.warning("redis unavailable: %s request_id=%s", type(exc).__name__, request.state.request_id)
return error_response(request.state.request_id, 503, "unavailable", "Сервис временно недоступен")
@dataclass
class Session:
user_id: str
token: str
def current_session(request: Request) -> Session:
# X-User-Id из lab1 здесь не читается вообще, Basic на бизнес-запросах тоже не принимается
token = security.parse_bearer(request.headers.get("Authorization"))
if token is None:
raise unauthorized()
# если Redis недоступен, здесь будет исключение и ответ 503: без проверки сессии запрос дальше не идёт
user_id = sessions.user_id(token)
if user_id is None:
raise unauthorized()
return Session(user_id, token)
def idempotency_key(request: Request) -> str:
key = request.headers.get("Idempotency-Key", "")
if not IDEMPOTENCY_KEY.fullmatch(key):
raise invalid("Нужен заголовок Idempotency-Key: 1-128 символов A-Z a-z 0-9 . _ : -")
return key
def json_body(model):
"""Разбирает тело запроса зависимостью, чтобы это происходило после проверки токена."""
async def parse(request: Request):
content_type = request.headers.get("Content-Type", "").split(";")[0].strip().lower()
if content_type != "application/json":
raise invalid("Нужен Content-Type: application/json")
try:
# decode строгий: контракт допускает только UTF-8, а json.loads сам угадал бы UTF-16
data = json.loads((await request.body()).decode("utf-8"))
except (ValueError, RecursionError):
raise invalid("Тело запроса должно быть корректным JSON в UTF-8")
try:
return model.model_validate(data)
except ValidationError as exc:
first = exc.errors()[0]
where = ".".join(str(part) for part in ("body", *first["loc"]))
raise invalid(f"{where}: {first['msg']}")
return parse
def encode_cursor(scope: str, created_at: str, item_id: str) -> str:
raw = json.dumps([scope, created_at, item_id])
return base64.urlsafe_b64encode(raw.encode()).decode()
def decode_cursor(scope: str, cursor):
"""Возвращает ключ (created_at, id) последней выданной записи или None для первой страницы."""
if cursor is None:
return None
try:
# validate=True: символ вне алфавита base64 — ошибка, а не пропускается молча
cursor_scope, created_at, item_id = json.loads(base64.b64decode(cursor, altchars=b"-_", validate=True))
# время и id принимаются только в том виде, в котором их выдаёт сам сервер
moment = datetime.strptime(created_at, TIME_FORMAT).replace(tzinfo=timezone.utc)
time_ok = moment.strftime(TIME_FORMAT) == created_at
id_ok = str(UUID(item_id)) == item_id
except (TypeError, ValueError, AttributeError):
raise invalid("Некорректный cursor")
# cursor действует только для того списка, в котором был выдан
if cursor_scope != scope or not time_ok or not id_ok:
raise invalid("Некорректный cursor")
# у одной позиции есть ровно одна запись cursor: другое оформление JSON или base64 не принимается
if encode_cursor(scope, created_at, item_id) != cursor:
raise invalid("Некорректный cursor")
return [moment, item_id]
def page(scope: str, items: list, has_more: bool) -> dict:
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if has_more else None
return {"items": items, "next_cursor": next_cursor}
@app.get("/health/live")
def liveness():
return {"status": "ok"}
@app.get("/health/ready")
def readiness():
# без PostgreSQL и Redis обязательные запросы не выполнить, поэтому обе зависимости критичны
store.ping()
sessions.ping()
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def register_user(body: CreateUser = Depends(json_body(CreateUser))):
try:
return store.create_user(body.username, body.display_name, security.hash_password(body.password))
except UsernameTaken:
raise ApiError(409, "conflict", "Такой username уже занят")
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request):
credentials = security.parse_basic(request.headers.get("Authorization"))
if credentials is None:
raise bad_credentials()
username, password = credentials
user, password_hash = None, None
# username, который не мог быть зарегистрирован, в БД не ищем, но пароль всё равно сверяем с пустышкой
if USERNAME.fullmatch(username):
user, password_hash = store.get_credentials(username)
if not security.verify_password(password_hash, password):
raise bad_credentials()
token = sessions.create(user["id"])
expires_at = datetime.now(timezone.utc) + timedelta(seconds=config.SESSION_TTL_SECONDS)
return {"token": token, "token_type": "Bearer", "expires_at": timestamp(expires_at), "user": user}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(session: Session = Depends(current_session)):
sessions.revoke(session.token)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def get_me(session: Session = Depends(current_session)):
user = store.get_user(session.user_id)
if user is None:
raise unauthorized()
return user
@app.post("/api/v1/chats", status_code=201)
def create_chat(session: Session = Depends(current_session), body: CreateChat = Depends(json_body(CreateChat))):
member_ids = [str(UUID(member)) for member in body.member_ids]
if len(set(member_ids)) != len(member_ids):
raise invalid("member_ids содержит повторы")
if session.user_id not in member_ids:
raise invalid("Создатель чата должен быть в member_ids")
try:
return store.create_chat(body.title, member_ids)
except UnknownMember:
raise invalid("В member_ids есть несуществующий пользователь")
@app.get("/api/v1/chats")
def list_chats(
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
scope = "chats:" + session.user_id
items, has_more = store.list_chats(session.user_id, decode_cursor(scope, cursor), limit)
return page(scope, items, has_more)
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: ChatId, session: Session = Depends(current_session)):
chat = store.get_chat(str(UUID(chat_id)), session.user_id)
if chat is None:
raise not_found()
return chat
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def send_message(
chat_id: ChatId,
session: Session = Depends(current_session),
key: str = Depends(idempotency_key),
body: CreateMessage = Depends(json_body(CreateMessage)),
):
# отправитель берётся из сессии, в теле запроса его нет
try:
message = store.add_message(str(UUID(chat_id)), session.user_id, body.text, key)
except IdempotencyConflict:
raise ApiError(409, "conflict", "Этот Idempotency-Key уже использован с другим сообщением")
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(
chat_id: ChatId,
limit: int = Query(50, ge=1, le=100),
cursor: str | None = Query(None, min_length=1),
session: Session = Depends(current_session),
):
chat_id = str(UUID(chat_id))
scope = "messages:" + chat_id
result = store.list_messages(chat_id, session.user_id, decode_cursor(scope, cursor), limit)
if result is None:
raise not_found()
items, has_more = result
return page(scope, items, has_more)
if __name__ == "__main__":
uvicorn.run(
app,
host=config.HOST,
port=config.PORT,
log_level=config.LOG_LEVEL,
access_log=False,
timeout_graceful_shutdown=config.SHUTDOWN_TIMEOUT,
)
+48
View File
@@ -0,0 +1,48 @@
"""Применяет SQL-миграции из каталога migrations по порядку имён. Повторный запуск ничего не меняет."""
import os
import sys
import time
from pathlib import Path
import psycopg
import config
MIGRATIONS_DIR = Path(os.getenv("MIGRATIONS_DIR", "migrations"))
LOCK_ID = 20260201 # любое постоянное число: два мигратора не должны работать одновременно
def connect(attempts=30):
for attempt in range(attempts):
try:
return psycopg.connect(config.database_url(), autocommit=True, connect_timeout=config.DB_CONNECT_TIMEOUT)
except psycopg.OperationalError:
if attempt == attempts - 1:
raise
time.sleep(1)
def main():
files = sorted(MIGRATIONS_DIR.glob("*.sql"))
if not files:
sys.exit(f"в {MIGRATIONS_DIR} нет миграций")
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 files:
if path.name in applied:
print("уже применена:", path.name)
continue
# миграция и отметка о ней в одной транзакции: либо всё, либо ничего
with conn.transaction():
conn.execute(path.read_text())
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.name,))
print("применена:", path.name)
if __name__ == "__main__":
main()
+42
View File
@@ -0,0 +1,42 @@
from typing import Annotated
from pydantic import BaseModel, ConfigDict, Field, field_validator
# только запись 8-4-4-4-12: UUID из Python принял бы ещё скобки, urn: и строку без дефисов
UUID_PATTERN = r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
Uuid = Annotated[str, Field(pattern=UUID_PATTERN)]
def not_blank(value: str) -> str:
if not value.strip():
raise ValueError("строка не может состоять только из пробелов")
# PostgreSQL не хранит символ NUL в text, а одиночные суррогаты нельзя записать в UTF-8
if "\x00" in value or any(0xD800 <= ord(char) <= 0xDFFF for char in value):
raise ValueError("строка содержит недопустимые символы")
return value
class StrictModel(BaseModel):
# лишние поля в JSON считаются ошибкой
model_config = ConfigDict(extra="forbid")
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)
_not_blank = field_validator("display_name", "password")(not_blank)
class CreateChat(StrictModel):
title: str = Field(min_length=1, max_length=100)
member_ids: list[Uuid] = Field(min_length=1, max_length=100)
_title = field_validator("title")(not_blank)
class CreateMessage(StrictModel):
text: str = Field(min_length=1, max_length=4000)
_text = field_validator("text")(not_blank)
+45
View File
@@ -0,0 +1,45 @@
import base64
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
# Argon2id, параметры из рекомендаций OWASP: 19 МиБ памяти, 2 прохода, 1 поток
hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
# с этим hash сверяется пароль, когда пользователя нет: время ответа не выдаёт, существует ли username
DUMMY_HASH = hasher.hash("no-such-user-password")
def hash_password(password: str) -> str:
return hasher.hash(password)
def verify_password(password_hash, password: str) -> bool:
try:
return hasher.verify(password_hash or DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
def parse_basic(header):
"""Разбирает Authorization: Basic base64(username:password). Возвращает пару или None."""
scheme, _, value = (header or "").partition(" ")
if scheme.lower() != "basic":
return None
try:
decoded = base64.b64decode(value.strip(), validate=True).decode("utf-8")
except ValueError:
# три случая сразу: не ASCII в заголовке (сам ValueError), неверный base64 и байты не в UTF-8
# (их исключения — подклассы ValueError)
return None
# двоеточие в пароле допустимо, поэтому делим только по первому
username, colon, password = decoded.partition(":")
if not colon:
return None
return username, password
def parse_bearer(header):
scheme, _, token = (header or "").partition(" ")
if scheme.lower() != "bearer" or not token.strip():
return None
return token.strip()
+47
View File
@@ -0,0 +1,47 @@
import hashlib
import secrets
import redis
from redis.backoff import NoBackoff
from redis.retry import Retry
import config
class Sessions:
"""Сессии лежат только в Redis: ключ session:<sha256 токена>, значение id пользователя, TTL ставит сам Redis."""
def __init__(self, url: str):
pool = redis.BlockingConnectionPool.from_url(
url,
max_connections=config.CACHE_POOL_MAX_SIZE,
timeout=config.CACHE_TIMEOUT, # ожидание свободного соединения
socket_timeout=config.CACHE_TIMEOUT,
socket_connect_timeout=config.CACHE_TIMEOUT,
decode_responses=True,
# одна повторная попытка без паузы: её хватает после перезапуска Redis, а при отказе ответ не затягивается
retry=Retry(NoBackoff(), 1),
)
self.client = redis.Redis(connection_pool=pool)
@staticmethod
def key(token: str) -> str:
# сам токен в Redis не хранится: по дампу нельзя войти от чужого имени
return "session:" + hashlib.sha256(token.encode()).hexdigest()
def create(self, user_id: str) -> str:
token = secrets.token_urlsafe(32) # 256 бит случайности
self.client.set(self.key(token), user_id, ex=config.SESSION_TTL_SECONDS)
return token
def user_id(self, token: str):
return self.client.get(self.key(token))
def revoke(self, token: str) -> None:
self.client.delete(self.key(token))
def ping(self) -> None:
self.client.ping()
def close(self) -> None:
self.client.close()
+216
View File
@@ -0,0 +1,216 @@
import uuid
from datetime import timezone
from psycopg import errors
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
import config
class UsernameTaken(Exception):
pass
class UnknownMember(Exception):
pass
class IdempotencyConflict(Exception):
pass
# ширина строки фиксированная: 6 знаков микросекунд, столько же хранит timestamptz
TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
def timestamp(value) -> str:
return value.astimezone(timezone.utc).strftime(TIME_FORMAT)
def user_json(row) -> dict:
return {
"id": str(row["id"]),
"username": row["username"],
"display_name": row["display_name"],
"created_at": timestamp(row["created_at"]),
}
def chat_json(row) -> dict:
return {
"id": str(row["id"]),
"title": row["title"],
"member_ids": [str(member) for member in row["member_ids"]],
"created_at": timestamp(row["created_at"]),
}
def message_json(row) -> dict:
return {
"id": str(row["id"]),
"chat_id": str(row["chat_id"]),
"sender_id": str(row["sender_id"]),
"text": row["text"],
"created_at": timestamp(row["created_at"]),
}
CHAT_COLUMNS = """
c.id, c.title, c.created_at,
(SELECT array_agg(m.user_id ORDER BY m.position) FROM chat_members m WHERE m.chat_id = c.id) AS member_ids
"""
class Store:
"""Все данные мессенджера в PostgreSQL. Значения в запросы попадают только через параметры %s."""
def __init__(self, url: str):
self.pool = ConnectionPool(
url,
min_size=config.DB_POOL_MIN_SIZE,
max_size=config.DB_POOL_MAX_SIZE,
timeout=config.DB_POOL_TIMEOUT, # сколько запрос ждёт свободное соединение
kwargs={
"connect_timeout": config.DB_CONNECT_TIMEOUT,
"options": f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT * 1000}",
"row_factory": dict_row,
},
# перед выдачей соединение проверяется, поэтому после перезапуска БД мёртвые соединения не достаются запросам
check=ConnectionPool.check_connection,
open=False,
)
def open(self) -> None:
# не ждём БД: если она недоступна, сервер стартует и отвечает 503
self.pool.open(wait=False)
def close(self) -> None:
self.pool.close()
def ping(self) -> None:
with self.pool.connection() as conn:
conn.execute("SELECT 1")
def create_user(self, username: str, display_name: str, password_hash: str) -> dict:
with self.pool.connection() as conn:
try:
row = conn.execute(
"INSERT INTO users (username, display_name, password_hash) VALUES (%s, %s, %s) "
"RETURNING id, username, display_name, created_at",
(username, display_name, password_hash),
).fetchone()
except errors.UniqueViolation:
# уникальность проверяет сама БД, поэтому два одновременных запроса не создадут двух пользователей
raise UsernameTaken()
return user_json(row)
def get_user(self, user_id: str):
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,)
).fetchone()
return user_json(row) if row else None
def get_credentials(self, username: str):
"""Пользователь и hash его пароля или (None, None)."""
with self.pool.connection() as conn:
row = conn.execute(
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = %s",
(username,),
).fetchone()
if row is None:
return None, None
return user_json(row), row["password_hash"]
def create_chat(self, title: str, member_ids: list) -> dict:
# блок with — одна транзакция: commit при выходе, rollback при любом исключении
with self.pool.connection() as conn:
chat = conn.execute(
"INSERT INTO chats (title) VALUES (%s) RETURNING id, title, created_at", (title,)
).fetchone()
try:
with conn.cursor() as cursor:
cursor.executemany(
"INSERT INTO chat_members (chat_id, user_id, position) VALUES (%s, %s, %s)",
[(chat["id"], member, position) for position, member in enumerate(member_ids)],
)
except errors.ForeignKeyViolation:
# участника нет в users: транзакция откатывается вместе с уже вставленным чатом
raise UnknownMember()
return chat_json({**chat, "member_ids": member_ids})
def get_chat(self, chat_id: str, user_id: str):
with self.pool.connection() as conn:
row = conn.execute(
f"SELECT {CHAT_COLUMNS} FROM chats c "
"JOIN chat_members me ON me.chat_id = c.id AND me.user_id = %s WHERE c.id = %s",
(user_id, chat_id),
).fetchone()
return chat_json(row) if row else None
def list_chats(self, user_id: str, after, limit: int):
query = f"SELECT {CHAT_COLUMNS} FROM chats c JOIN chat_members me ON me.chat_id = c.id WHERE me.user_id = %s"
params = [user_id]
if after:
query += " AND (c.created_at, c.id) > (%s, %s)"
params += after
query += " ORDER BY c.created_at, c.id LIMIT %s"
with self.pool.connection() as conn:
rows = conn.execute(query, params + [limit + 1]).fetchall()
return [chat_json(row) for row in rows[:limit]], len(rows) > limit
def add_message(self, chat_id: str, sender_id: str, text: str, key: str):
"""Отправляет сообщение один раз на ключ. Повтор с тем же текстом возвращает исходное сообщение."""
message_id = uuid.uuid4()
# ключ и сообщение пишутся в одной транзакции: при сбое не остаётся ни того, ни другого
with self.pool.connection() as conn:
if not self._is_member(conn, chat_id, sender_id):
return None
# параллельный запрос с тем же ключом ждёт здесь, пока первая транзакция не завершится;
# строка возвращается, только если ключ свободен или его срок вышел
claimed = conn.execute(
"INSERT INTO idempotency_keys (user_id, chat_id, key, message_id) VALUES (%s, %s, %s, %s) "
"ON CONFLICT (user_id, chat_id, key) DO UPDATE "
"SET message_id = EXCLUDED.message_id, created_at = now() "
"WHERE idempotency_keys.created_at < now() - make_interval(secs => %s) "
"RETURNING message_id",
(sender_id, chat_id, key, message_id, config.IDEMPOTENCY_TTL_SECONDS),
).fetchone()
if claimed:
row = conn.execute(
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) "
"RETURNING id, chat_id, sender_id, text, created_at",
(message_id, chat_id, sender_id, text),
).fetchone()
return message_json(row)
row = conn.execute(
"SELECT 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.chat_id = %s AND k.key = %s",
(sender_id, chat_id, key),
).fetchone()
if row["text"] != text:
raise IdempotencyConflict()
return message_json(row)
def list_messages(self, chat_id: str, user_id: str, after, limit: int):
query = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = %s"
params = [chat_id]
if after:
# keyset: продолжаем с записи после cursor, а не пропускаем N строк
query += " AND (created_at, id) > (%s, %s)"
params += after
query += " ORDER BY created_at, id LIMIT %s"
with self.pool.connection() as conn:
if not self._is_member(conn, chat_id, user_id):
return None
# limit + 1: лишняя строка показывает, есть ли следующая страница
rows = conn.execute(query, params + [limit + 1]).fetchall()
return [message_json(row) for row in rows[:limit]], len(rows) > limit
@staticmethod
def _is_member(conn, chat_id: str, user_id: str) -> bool:
row = conn.execute(
"SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, user_id)
).fetchone()
return row is not None
+87
View File
@@ -0,0 +1,87 @@
"""Маленький HTTP-клиент для собственных тестов. Только стандартная библиотека."""
import base64
import json
import os
import urllib.error
import urllib.parse
import urllib.request
import uuid
BASE_URL = os.environ.get("BASE_URL", "http://localhost:8080").rstrip("/")
def call(method, path, body=None, user=None, raw=None, headers=None, base_url=None, timeout=15):
"""Возвращает (код ответа, разобранный JSON или None, заголовки)."""
request_headers = {"Accept": "application/json"}
if body is not None:
raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
if raw is not None:
request_headers["Content-Type"] = "application/json"
if user is not None:
request_headers["Authorization"] = "Bearer " + user["token"]
request_headers.update(headers or {})
request = urllib.request.Request((base_url or BASE_URL) + path, data=raw, headers=request_headers, method=method)
try:
response = urllib.request.urlopen(request, timeout=timeout)
except urllib.error.HTTPError as error:
response = error
with response:
data = response.read()
return response.status, json.loads(data) if data else None, response.headers
def basic(username, password):
return {"Authorization": "Basic " + base64.b64encode((username + ":" + password).encode("utf-8")).decode()}
def login(username, password, base_url=None):
return call("POST", "/api/v1/auth/sessions", headers=basic(username, password), base_url=base_url)
def user_body(**fields):
"""Корректное тело регистрации со случайным username; поля можно переопределить."""
body = {"username": "u_" + uuid.uuid4().hex[:12], "display_name": "Тест", "password": "Pw-" + uuid.uuid4().hex}
body.update(fields)
return body
def new_user(prefix="t", base_url=None):
"""Регистрирует синтетического пользователя и сразу входит. В словаре id, username, password и token."""
body = user_body(username=prefix + "_" + uuid.uuid4().hex[:12], display_name="Тест " + prefix)
status, user, _ = call("POST", "/api/v1/users", body, base_url=base_url)
assert status == 201, status
status, session, _ = login(body["username"], body["password"], base_url=base_url)
assert status == 201, status
return {**user, "password": body["password"], "token": session["token"], "user": user}
def new_chat(owner, *others, title="Тестовый чат"):
member_ids = [owner["id"]] + [other["id"] for other in others]
status, chat, _ = call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=owner)
assert status == 201, status
return chat
def new_key():
return uuid.uuid4().hex
def send(user, chat, text, key=None, **options):
headers = {"Idempotency-Key": key or new_key()}
return call("POST", "/api/v1/chats/" + chat["id"] + "/messages", {"text": text}, user=user, headers=headers, **options)
def history(user, chat, limit):
"""Обходит всю историю чата страницами по limit, возвращает сообщения и размеры страниц."""
items, sizes, cursor = [], [], None
while True:
path = "/api/v1/chats/%s/messages?limit=%d" % (chat["id"], limit)
if cursor:
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
status, page, _ = call("GET", path, user=user)
assert status == 200, status
items += page["items"]
sizes.append(len(page["items"]))
cursor = page["next_cursor"]
if cursor is None:
return items, sizes
+46
View File
@@ -0,0 +1,46 @@
"""Управление стендом для тестов отказов: останавливает и запускает сервисы через docker compose."""
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "student-tests"))
from api import BASE_URL, call # noqa: E402
def compose(*args):
command = ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose.test.yaml", *args]
return subprocess.run(command, cwd=ROOT, check=True, capture_output=True, text=True).stdout
def sql(query):
"""Выполняет запрос через psql внутри контейнера postgres и возвращает вывод без оформления."""
return compose("exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-At", "-c", query).strip()
def wait_ready(base_url=BASE_URL, seconds=60):
"""Ждёт устойчивой готовности: балансировщик мог ещё не отметить отказ, поэтому одного ответа 200 мало."""
deadline = time.monotonic() + seconds
stable_since = None
while time.monotonic() < deadline:
try:
ready = call("GET", "/health/ready", base_url=base_url)[0] == 200
except OSError:
ready = False
if not ready:
stable_since = None
elif stable_since is None:
stable_since = time.monotonic()
elif time.monotonic() - stable_since >= 3:
return
time.sleep(0.3)
raise AssertionError("стенд не стал готов за %d секунд" % seconds)
def timed(*args, **kwargs):
"""Как call, но первым элементом возвращает время ответа в секундах."""
started = time.monotonic()
result = call(*args, **kwargs)
return (time.monotonic() - started, *result)
@@ -0,0 +1,91 @@
"""Недоступность Redis и PostgreSQL через балансировщик.
Пока реплики не признаны неготовыми, 503 отвечает API, потом сам балансировщик. Формат ошибки у них один.
"""
import unittest
from stand import call, compose, timed, wait_ready
from api import basic, history, new_chat, new_key, new_user, send, user_body
# таймауты в .env.example: 2 с на Redis, 3 с на ожидание соединения с БД; берём запас
MAX_SECONDS = 6
class DependencyDownTest(unittest.TestCase):
def setUp(self):
wait_ready()
self.user = new_user("dep")
self.chat = new_chat(self.user)
send(self.user, self.chat, "сообщение до отказа")
self.messages = "/api/v1/chats/" + self.chat["id"] + "/messages"
def assert_unavailable(self, result):
elapsed, status, body, headers = result
self.assertEqual(status, 503)
self.assertEqual(body["error"]["code"], "unavailable")
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
self.assertLess(elapsed, MAX_SECONDS)
def test_redis_down(self):
compose("stop", "redis")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "redis")
# сессию проверить нечем: запрос с настоящим токеном не выполняется, но и чужим не становится
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
self.assert_unavailable(timed("GET", self.messages, user=self.user))
key = {"Idempotency-Key": new_key()}
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user, headers=key))
# поддельный токен тоже не принимается за действующий
self.assert_unavailable(timed("GET", "/api/v1/users/me", user={"token": "x" * 43}))
# без токена Redis не нужен: API ответит 401, балансировщик без готовых реплик 503, но не данные
self.assertIn(call("GET", "/api/v1/users/me")[0], (401, 503))
self.assertIn(call("GET", self.messages)[0], (401, 503))
# новую сессию создать негде
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
headers=basic(self.user["username"], self.user["password"])))
self.assert_unavailable(timed("GET", "/health/ready"))
compose("start", "redis")
wait_ready()
# прежний токен снова работает: сессия пережила остановку Redis, а сообщение во время отказа не записалось
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
def test_uncertain_write_can_be_repeated_with_same_key(self):
compose("stop", "postgres")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "postgres")
key = new_key()
self.assertEqual(send(self.user, self.chat, "важное", key=key)[0], 503)
compose("start", "postgres")
wait_ready()
first = send(self.user, self.chat, "важное", key=key)
second = send(self.user, self.chat, "важное", key=key)
self.assertEqual((first[0], second[0]), (201, 201))
self.assertEqual(first[1], second[1])
def test_postgres_down(self):
compose("stop", "postgres")
self.addCleanup(wait_ready)
self.addCleanup(compose, "start", "postgres")
self.assert_unavailable(timed("GET", "/api/v1/users/me", user=self.user))
self.assert_unavailable(timed("GET", self.messages, user=self.user))
key = {"Idempotency-Key": new_key()}
self.assert_unavailable(timed("POST", self.messages, {"text": "во время отказа"}, user=self.user, headers=key))
self.assert_unavailable(timed("POST", "/api/v1/users", user_body()))
self.assert_unavailable(timed("POST", "/api/v1/auth/sessions",
headers=basic(self.user["username"], self.user["password"])))
self.assertIn(call("GET", "/api/v1/users/me")[0], (401, 503))
self.assert_unavailable(timed("GET", "/health/ready"))
compose("start", "postgres")
wait_ready()
self.assertEqual(call("GET", "/api/v1/users/me", user=self.user)[1], self.user["user"])
self.assertEqual([item["text"] for item in history(self.user, self.chat, 50)[0]], ["сообщение до отказа"])
self.assertEqual(send(self.user, self.chat, "после восстановления")[0], 201)
if __name__ == "__main__":
unittest.main()
+75
View File
@@ -0,0 +1,75 @@
"""Истечение сессии и ключа. Проверяется на отдельном API с TTL 2 секунды (порт 8081, только compose.test.yaml)."""
import datetime
import time
import unittest
from stand import call, compose, wait_ready
from api import login, new_key, new_user, send
SHORT_TTL_URL = "http://localhost:8081"
class SessionExpiryTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
compose("up", "-d", "--no-deps", "--no-build", "api-short-ttl")
cls.addClassCleanup(compose, "rm", "-sf", "api-short-ttl")
wait_ready(SHORT_TTL_URL)
def test_session_expires(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 200)
time.sleep(3)
status, body, headers = call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
# logout с истёкшим токеном тоже 401
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user, base_url=SHORT_TTL_URL)[0], 401)
def test_idempotency_key_is_free_after_ttl(self):
user = new_user("idem", base_url=SHORT_TTL_URL)
chat = new_chat_short(user)
key = new_key()
first = send(user, chat, "первое", key=key, base_url=SHORT_TTL_URL)
repeat = send(user, chat, "первое", key=key, base_url=SHORT_TTL_URL)
self.assertEqual((first[0], repeat[1]), (201, first[1]))
time.sleep(2.2)
# сессия живёт столько же, поэтому нужен новый вход
_, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
again = send({**user, "token": session["token"]}, chat, "уже другое", key=key, base_url=SHORT_TTL_URL)
self.assertEqual(again[0], 201)
self.assertNotEqual(again[1]["id"], first[1]["id"])
def test_expires_at_matches_ttl(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
_, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
self.assertTrue(0 < left <= 2.5, left)
def test_requests_do_not_extend_session(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
deadline = time.monotonic() + 3
while time.monotonic() < deadline:
call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)
time.sleep(0.2)
self.assertEqual(call("GET", "/api/v1/users/me", user=user, base_url=SHORT_TTL_URL)[0], 401)
def test_login_after_expiry(self):
user = new_user("ttl", base_url=SHORT_TTL_URL)
time.sleep(3)
status, session, _ = login(user["username"], user["password"], base_url=SHORT_TTL_URL)
self.assertEqual(status, 201)
self.assertEqual(call("GET", "/api/v1/users/me", user=session, base_url=SHORT_TTL_URL)[0], 200)
def new_chat_short(owner):
body = {"title": "Чат", "member_ids": [owner["id"]]}
status, chat, _ = call("POST", "/api/v1/chats", body, user=owner, base_url=SHORT_TTL_URL)
assert status == 201, status
return chat
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,90 @@
"""Проверки на уровне БД: откат составной операции, гонка регистрации, повторный запуск миграций."""
import threading
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from stand import call, compose, sql, wait_ready
from api import new_chat, new_key, new_user, send, user_body
class TransactionTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
wait_ready()
cls.alice, cls.bob = new_user("alice"), new_user("bob")
def create_chat(self, title, member_ids):
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)
def test_chat_with_unknown_member_is_rolled_back(self):
title = "rollback-" + uuid.uuid4().hex
# Алиса и Боб существуют, третьего участника нет: вставка чата и двух участников уже выполнена,
# на третьем срабатывает внешний ключ, и транзакция должна откатить всё
status, body, _ = self.create_chat(title, [self.alice["id"], self.bob["id"], str(uuid.uuid4())])
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "0")
self.assertEqual(sql("SELECT count(*) FROM chat_members m LEFT JOIN chats c ON c.id = m.chat_id WHERE c.id IS NULL"), "0")
def test_valid_chat_is_committed_whole(self):
title = "commit-" + uuid.uuid4().hex
status, chat, _ = self.create_chat(title, [self.alice["id"], self.bob["id"]])
self.assertEqual(status, 201)
self.assertEqual(sql("SELECT count(*) FROM chats WHERE title = '%s'" % title), "1")
self.assertEqual(sql("SELECT count(*) FROM chat_members WHERE chat_id = '%s'" % chat["id"]), "2")
def test_username_race_creates_one_row(self):
body = user_body(username="race_" + uuid.uuid4().hex[:8])
barrier = threading.Barrier(10)
def register(_):
barrier.wait()
return call("POST", "/api/v1/users", body)[0]
with ThreadPoolExecutor(max_workers=10) as pool:
statuses = sorted(pool.map(register, range(10)))
self.assertEqual(statuses, [201] + [409] * 9)
self.assertEqual(sql("SELECT count(*) FROM users WHERE username = '%s'" % body["username"]), "1")
def test_same_key_in_parallel_creates_one_row(self):
chat = new_chat(self.alice)
key = new_key()
barrier = threading.Barrier(20)
def post(_):
barrier.wait()
return send(self.alice, chat, "один раз", key=key)
with ThreadPoolExecutor(max_workers=20) as pool:
results = list(pool.map(post, range(20)))
self.assertEqual({status for status, _, _ in results}, {201})
self.assertEqual(len({message["id"] for _, message, _ in results}), 1)
self.assertEqual(sql("SELECT count(*) FROM messages WHERE chat_id = '%s'" % chat["id"]), "1")
self.assertEqual(sql("SELECT count(*) FROM idempotency_keys WHERE chat_id = '%s'" % chat["id"]), "1")
def test_failed_message_leaves_no_key(self):
# чужой чат: сообщение не создано, и ключ тоже не занят
eve = new_user("eve")
chat = new_chat(self.alice)
key = new_key()
self.assertEqual(send(eve, chat, "чужое", key=key)[0], 404)
self.assertEqual(sql("SELECT count(*) FROM idempotency_keys WHERE chat_id = '%s'" % chat["id"]), "0")
def test_password_is_stored_as_argon2id_hash(self):
stored = sql("SELECT password_hash FROM users WHERE id = '%s'" % self.alice["id"])
self.assertTrue(stored.startswith("$argon2id$"), stored[:12])
self.assertNotIn(self.alice["password"], stored)
def test_migrations_can_be_repeated(self):
before = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
output = compose("run", "--rm", "migrate")
self.assertIn("уже применена: 0001_init.sql", output)
self.assertIn("уже применена: 0002_idempotency.sql", output)
self.assertEqual(sql("SELECT count(*) FROM schema_migrations"), "2")
after = sql("SELECT (SELECT count(*) FROM users), (SELECT count(*) FROM chats), (SELECT count(*) FROM messages)")
self.assertEqual(before, after)
if __name__ == "__main__":
unittest.main()
+85
View File
@@ -0,0 +1,85 @@
import unittest
import uuid
from api import call, new_chat, new_user, send
class ForeignChatTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
cls.chat = new_chat(cls.alice, cls.bob)
cls.path = "/api/v1/chats/" + cls.chat["id"]
send(cls.alice, cls.chat, "секрет")
def test_outsider_gets_404_everywhere(self):
self.assertEqual(call("GET", self.path, user=self.eve)[0], 404)
self.assertEqual(call("GET", self.path + "/messages", user=self.eve)[0], 404)
status, body, _ = send(self.eve, self.chat, "я тут")
self.assertEqual(status, 404)
self.assertEqual(body["error"]["code"], "not_found")
def test_foreign_chat_looks_like_missing_chat(self):
_, foreign, _ = call("GET", self.path, user=self.eve)
_, missing, _ = call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=self.eve)
self.assertEqual(foreign["error"]["message"], missing["error"]["message"])
def test_outsider_message_is_not_saved(self):
send(self.eve, self.chat, "не должно появиться")
_, page, _ = call("GET", self.path + "/messages", user=self.alice)
self.assertNotIn("не должно появиться", [item["text"] for item in page["items"]])
def test_chat_is_not_listed_for_outsider(self):
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.eve)
self.assertNotIn(self.chat["id"], [item["id"] for item in page["items"]])
_, page, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
self.assertIn(self.chat["id"], [item["id"] for item in page["items"]])
def test_members_can_read_and_write(self):
self.assertEqual(send(self.bob, self.chat, "ответ")[0], 201)
self.assertEqual(call("GET", self.path, user=self.bob)[0], 200)
def test_bad_chat_id(self):
chat_id = self.chat["id"]
for bad in ("123", chat_id.replace("-", ""), "urn:uuid:" + chat_id):
with self.subTest(chat_id=bad):
self.assertEqual(call("GET", "/api/v1/chats/" + bad, user=self.alice)[0], 400)
self.assertEqual(call("GET", "/api/v1/chats/" + bad + "/messages", user=self.alice)[0], 400)
def test_member_id_must_be_canonical_uuid(self):
body = {"title": "Чат", "member_ids": ["urn:uuid:" + self.alice["id"]]}
self.assertEqual(call("POST", "/api/v1/chats", body, user=self.alice)[0], 400)
class CreateChatTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.bob = new_user("alice"), new_user("bob")
def create(self, member_ids, title="Чат"):
return call("POST", "/api/v1/chats", {"title": title, "member_ids": member_ids}, user=self.alice)[0]
def test_creator_must_be_member(self):
self.assertEqual(self.create([self.bob["id"]]), 400)
def test_duplicate_members(self):
self.assertEqual(self.create([self.alice["id"], self.bob["id"], self.bob["id"]]), 400)
def test_unknown_member(self):
self.assertEqual(self.create([self.alice["id"], str(uuid.uuid4())]), 400)
def test_empty_members(self):
self.assertEqual(self.create([]), 400)
def test_blank_title(self):
self.assertEqual(self.create([self.alice["id"]], title=" "), 400)
def test_failed_create_leaves_no_chat(self):
_, before, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
self.create([self.alice["id"], self.bob["id"], str(uuid.uuid4())])
_, after, _ = call("GET", "/api/v1/chats?limit=100", user=self.bob)
self.assertEqual(before, after)
if __name__ == "__main__":
unittest.main()
+144
View File
@@ -0,0 +1,144 @@
import datetime
import unittest
import uuid
from api import basic, call, login, new_user, user_body
class LoginTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.body = user_body()
_, cls.user, _ = call("POST", "/api/v1/users", cls.body)
def assert_basic_challenge(self, result):
status, body, headers = result
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Basic "))
return body
def test_login(self):
status, session, _ = login(self.body["username"], self.body["password"])
self.assertEqual(status, 201)
self.assertEqual(set(session), {"token", "token_type", "expires_at", "user"})
self.assertEqual(session["token_type"], "Bearer")
self.assertEqual(session["user"], self.user)
self.assertGreaterEqual(len(session["token"]), 32)
expires_at = datetime.datetime.fromisoformat(session["expires_at"][:-1] + "+00:00")
left = (expires_at - datetime.datetime.now(datetime.timezone.utc)).total_seconds()
self.assertTrue(300 <= left <= 3600 + 5, left)
def test_token_is_opaque_and_unique(self):
first = login(self.body["username"], self.body["password"])[1]["token"]
second = login(self.body["username"], self.body["password"])[1]["token"]
self.assertNotEqual(first, second)
for token in (first, second):
self.assertNotIn(self.user["id"], token)
self.assertNotIn(self.body["username"], token)
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": token})[0], 200)
def test_wrong_password_and_unknown_user_look_the_same(self):
wrong = self.assert_basic_challenge(login(self.body["username"], "wrong-password-123"))
unknown = self.assert_basic_challenge(login("nobody_" + uuid.uuid4().hex[:8], self.body["password"]))
self.assertEqual(wrong["error"]["message"], unknown["error"]["message"])
def test_malformed_credentials(self):
token = login(self.body["username"], self.body["password"])[1]["token"]
for header in (None, "Basic", "Basic !!!not-base64!!!", "Basic bm8tY29sb24=", "Bearer " + token, "Basic 0KU6"):
with self.subTest(header=header):
headers = {"Authorization": header} if header else {}
self.assert_basic_challenge(call("POST", "/api/v1/auth/sessions", headers=headers))
def test_garbage_after_basic_is_401_not_500(self):
# значение заголовка приходит на сервер как latin-1, поэтому после Basic может оказаться не ASCII
values = ("\u00e9", "\u00e9\u00e9\u00e9=", "\u00ff\u00fe", "//46cHc=", "=", "====", "a", " ", "A" * 5000, "Og==",
"dXNlcjpwYXNz dXNlcjpwYXNz")
for value in values:
with self.subTest(value=ascii(value[:16])):
result = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + value})
self.assert_basic_challenge(result)
def test_username_that_cannot_exist(self):
for username in ("", "Has Space", "ab\u0000cd", "имя_кириллицей"):
with self.subTest(username=username):
self.assert_basic_challenge(login(username, self.body["password"]))
def test_colon_and_unicode_in_password(self):
body = user_body(password="пароль:с:двоеточиями")
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
self.assertEqual(login(body["username"], body["password"])[0], 201)
self.assert_basic_challenge(login(body["username"], "пароль"))
class BearerTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.eve = new_user("alice"), new_user("eve")
def assert_bearer_challenge(self, result):
status, body, headers = result
self.assertEqual(status, 401)
self.assertEqual(body["error"]["code"], "unauthorized")
self.assertTrue(headers["WWW-Authenticate"].startswith("Bearer "))
def test_no_token(self):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me"))
def test_unknown_tokens(self):
for token in ("x" * 43, self.alice["id"], self.alice["username"], self.alice["token"][:-1]):
with self.subTest(token=token[:8]):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
def test_garbage_token_is_401_not_500(self):
for token in ("\u00e9", "\u00ff\u00fe", "a b", "x" * 10000):
with self.subTest(token=ascii(token[:16])):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", user={"token": token}))
def test_basic_is_not_accepted_on_business_endpoints(self):
headers = basic(self.alice["username"], self.alice["password"])
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers=headers))
self.assert_bearer_challenge(call("GET", "/api/v1/chats", headers=headers))
def test_x_user_id_gives_no_access(self):
self.assert_bearer_challenge(call("GET", "/api/v1/users/me", headers={"X-User-Id": self.alice["id"]}))
def test_x_user_id_does_not_change_identity(self):
status, me, _ = call("GET", "/api/v1/users/me", user=self.alice, headers={"X-User-Id": self.eve["id"]})
self.assertEqual(status, 200)
self.assertEqual(me, self.alice["user"])
def test_token_is_checked_before_anything_else(self):
self.assert_bearer_challenge(call("GET", "/api/v1/chats/not-a-uuid"))
self.assert_bearer_challenge(call("GET", "/api/v1/chats?limit=0"))
self.assert_bearer_challenge(call("POST", "/api/v1/chats", {"title": 5}))
class LogoutTest(unittest.TestCase):
def test_logout_revokes_only_current_session(self):
user = new_user()
other_token = login(user["username"], user["password"])[1]["token"]
status, body, _ = call("DELETE", "/api/v1/auth/sessions/current", user=user)
self.assertEqual(status, 204)
self.assertIsNone(body)
self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401)
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current", user=user)[0], 401)
# вторая сессия того же пользователя продолжает работать
self.assertEqual(call("GET", "/api/v1/users/me", user={"token": other_token})[0], 200)
def test_login_again_after_logout(self):
user = new_user()
call("DELETE", "/api/v1/auth/sessions/current", user=user)
status, session, _ = login(user["username"], user["password"])
self.assertEqual(status, 201)
self.assertNotEqual(session["token"], user["token"])
self.assertEqual(call("GET", "/api/v1/users/me", user=session)[0], 200)
def test_logout_requires_token(self):
self.assertEqual(call("DELETE", "/api/v1/auth/sessions/current")[0], 401)
if __name__ == "__main__":
unittest.main()
+94
View File
@@ -0,0 +1,94 @@
import json
import socket
import unittest
import urllib.parse
import uuid
from api import BASE_URL, basic, call, history, new_chat, new_user, send
class ErrorsFromBalancerTest(unittest.TestCase):
"""Запросы, которые до API не доходят: ответ всё равно в формате контракта."""
def assert_contract_error(self, raw_request):
address = urllib.parse.urlsplit(BASE_URL)
with socket.create_connection((address.hostname, address.port), timeout=5) as connection:
connection.sendall(raw_request)
data = b""
while chunk := connection.recv(65536):
data += chunk
head, _, body = data.partition(b"\r\n\r\n")
lines = head.decode("latin-1").split("\r\n")
headers = {line.split(":")[0].lower(): line.split(":", 1)[1].strip() for line in lines[1:]}
self.assertEqual(headers["content-type"], "application/json")
error = json.loads(body)["error"]
self.assertEqual(error["request_id"], headers["x-request-id"])
self.assertEqual(error["code"], "invalid_request")
return int(lines[0].split()[1])
def test_invalid_http(self):
self.assertEqual(self.assert_contract_error(b"GET /a b HTTP/1.1\r\nHost: x\r\n\r\n"), 400)
def test_too_long_uri(self):
self.assertEqual(self.assert_contract_error(b"GET /" + b"a" * 20000 + b" HTTP/1.1\r\nHost: x\r\n\r\n"), 414)
def test_too_large_headers(self):
raw = b"GET /x HTTP/1.1\r\nHost: x\r\nX-Big: " + b"a" * 20000 + b"\r\n\r\n"
self.assertEqual(self.assert_contract_error(raw), 431)
class ReplicasTest(unittest.TestCase):
def test_every_answer_has_instance_id(self):
user = new_user()
answers = (
call("GET", "/health/live"),
call("GET", "/health/ready"),
call("GET", "/api/v1/users/me"),
call("GET", "/api/v1/users/me", user=user),
call("GET", "/api/v1/chats/" + str(uuid.uuid4()), user=user),
call("GET", "/nowhere"),
call("POST", "/api/v1/users", raw=b"{"),
)
for status, _, headers in answers:
with self.subTest(status=status):
self.assertTrue(headers["X-Instance-Id"])
self.assertTrue(headers["X-Request-Id"])
def test_one_session_is_served_by_different_replicas(self):
user = new_user()
instances = set()
for _ in range(20):
status, me, headers = call("GET", "/api/v1/users/me", user=user)
self.assertEqual((status, me), (200, user["user"]))
instances.add(headers["X-Instance-Id"])
self.assertGreaterEqual(len(instances), 2)
def test_session_created_on_one_replica_works_on_all(self):
user = new_user()
for _ in range(6):
status, session, _ = call("POST", "/api/v1/auth/sessions", headers=basic(user["username"], user["password"]))
self.assertEqual(status, 201)
seen = {call("GET", "/api/v1/users/me", user=session)[2]["X-Instance-Id"] for _ in range(4)}
self.assertGreaterEqual(len(seen), 2)
def test_read_after_write_on_any_replica(self):
user = new_user()
chat = new_chat(user)
for number in range(20):
_, message, _ = send(user, chat, "запись %d" % number)
items, _ = history(user, chat, 100)
self.assertEqual(items[-1], message)
def test_logout_works_on_all_replicas(self):
user = new_user()
call("DELETE", "/api/v1/auth/sessions/current", user=user)
for _ in range(4):
self.assertEqual(call("GET", "/api/v1/users/me", user=user)[0], 401)
def test_no_sticky_cookie(self):
_, _, headers = call("GET", "/health/live")
self.assertIsNone(headers.get("Set-Cookie"), BASE_URL)
if __name__ == "__main__":
unittest.main()
+63
View File
@@ -0,0 +1,63 @@
"""Проверка гонок: 10 клиентов параллельно отправляют 100 сообщений в один чат."""
import threading
import unittest
import uuid
from concurrent.futures import ThreadPoolExecutor
from api import call, history, new_chat, new_user, send, user_body
CLIENTS = 10
MESSAGES_PER_CLIENT = 10
class ConcurrencyTest(unittest.TestCase):
def test_100_messages_from_10_clients(self):
users = [new_user("c%d" % number) for number in range(CLIENTS)]
chat = new_chat(users[0], *users[1:])
barrier = threading.Barrier(CLIENTS)
def client(number):
barrier.wait() # все потоки стартуют одновременно
results = []
for index in range(MESSAGES_PER_CLIENT):
results.append(send(users[number], chat, "клиент %d сообщение %d" % (number, index)))
return results
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
results = [result for chunk in pool.map(client, range(CLIENTS)) for result in chunk]
total = CLIENTS * MESSAGES_PER_CLIENT
self.assertEqual([status for status, _, _ in results], [201] * total)
confirmed = {message["id"]: message for _, message, _ in results}
self.assertEqual(len(confirmed), total)
items, _ = history(users[0], chat, limit=7)
self.assertEqual(len(items), total)
self.assertEqual(len({item["id"] for item in items}), total)
self.assertEqual(len({item["text"] for item in items}), total)
# каждое подтверждённое сообщение есть в истории без изменений
self.assertEqual({item["id"]: item for item in items}, confirmed)
keys = [(item["created_at"], item["id"]) for item in items]
self.assertEqual(keys, sorted(keys))
# сообщения одного клиента идут в том порядке, в котором он их отправлял
for number in range(CLIENTS):
own = [item["text"] for item in items if item["sender_id"] == users[number]["id"]]
self.assertEqual(own, ["клиент %d сообщение %d" % (number, index) for index in range(MESSAGES_PER_CLIENT)])
print("\nотправлено %d, подтверждено %d, в истории %d, уникальных id %d"
% (total, len(confirmed), len(items), len({item["id"] for item in items})))
def test_same_username_registered_once(self):
body = user_body(username="race_" + uuid.uuid4().hex[:8])
barrier = threading.Barrier(CLIENTS)
def register(_):
barrier.wait()
return call("POST", "/api/v1/users", body)[0]
with ThreadPoolExecutor(max_workers=CLIENTS) as pool:
statuses = sorted(pool.map(register, range(CLIENTS)))
self.assertEqual(statuses, [201] + [409] * (CLIENTS - 1))
if __name__ == "__main__":
unittest.main()
+98
View File
@@ -0,0 +1,98 @@
import threading
import unittest
from concurrent.futures import ThreadPoolExecutor
from api import call, history, new_chat, new_key, new_user, send
class IdempotencyTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.alice, cls.bob, cls.eve = new_user("alice"), new_user("bob"), new_user("eve")
cls.chat = new_chat(cls.alice, cls.bob)
cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages"
def test_key_is_required(self):
status, body, _ = call("POST", self.path, {"text": "без ключа"}, user=self.alice)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
def test_bad_keys(self):
for key in ("", "a" * 129, "с пробелом", "кириллица", "a/b", "a,b"):
with self.subTest(key=key[:12]):
headers = {"Idempotency-Key": key.encode("utf-8").decode("latin-1")}
self.assertEqual(call("POST", self.path, {"text": "x"}, user=self.alice, headers=headers)[0], 400)
def test_good_key_alphabet(self):
for key in ("a", "A.b_c:d-1", "x" * 128):
with self.subTest(key=key[:12]):
self.assertEqual(send(self.alice, self.chat, "ключ " + key, key=key)[0], 201)
def test_repeat_returns_same_message(self):
key = new_key()
first = send(self.alice, self.chat, "Привет 👋", key=key)
second = send(self.alice, self.chat, "Привет 👋", key=key)
self.assertEqual((first[0], second[0]), (201, 201))
self.assertEqual(first[1], second[1])
def test_key_order_in_json_does_not_matter(self):
key = new_key()
headers = {"Idempotency-Key": key}
first = call("POST", self.path, {"text": "порядок"}, user=self.alice, headers=headers)
second = call("POST", self.path, raw=' { "text" : "порядок" } '.encode(), user=self.alice, headers=headers)
self.assertEqual(first[1], second[1])
def test_other_text_with_same_key_is_409(self):
key = new_key()
first = send(self.alice, self.chat, "первый текст", key=key)
status, body, _ = send(self.alice, self.chat, "другой текст", key=key)
self.assertEqual(status, 409)
self.assertEqual(body["error"]["code"], "conflict")
# конфликт ничего не меняет: исходный текст по-прежнему возвращается
self.assertEqual(send(self.alice, self.chat, "первый текст", key=key)[1], first[1])
def test_same_key_for_other_user_and_other_chat(self):
key = new_key()
other_chat = new_chat(self.alice)
first = send(self.alice, self.chat, "общий ключ", key=key)[1]
by_bob = send(self.bob, self.chat, "общий ключ", key=key)[1]
in_other_chat = send(self.alice, other_chat, "общий ключ", key=key)[1]
self.assertEqual(len({first["id"], by_bob["id"], in_other_chat["id"]}), 3)
self.assertEqual(by_bob["sender_id"], self.bob["id"])
def test_repeat_checks_access_again(self):
key = new_key()
send(self.alice, self.chat, "только участникам", key=key)
self.assertEqual(send(self.eve, self.chat, "только участникам", key=key)[0], 404)
self.assertEqual(send({"token": "x" * 43}, self.chat, "только участникам", key=key)[0], 401)
def test_invalid_body_does_not_take_key(self):
key = new_key()
self.assertEqual(send(self.alice, self.chat, "", key=key)[0], 400)
self.assertEqual(send(self.alice, self.chat, "теперь верно", key=key)[0], 201)
def test_parallel_repeat_through_different_replicas(self):
user = new_user("idem")
chat = new_chat(user)
instances = set()
for round_number in range(10):
key = new_key()
barrier = threading.Barrier(8)
def post(_):
barrier.wait()
return send(user, chat, "сообщение %d" % round_number, key=key)
with ThreadPoolExecutor(max_workers=8) as pool:
results = list(pool.map(post, range(8)))
self.assertEqual({status for status, _, _ in results}, {201})
self.assertEqual(len({message["id"] for _, message, _ in results}), 1)
instances |= {headers["X-Instance-Id"] for _, _, headers in results}
self.assertGreaterEqual(len(instances), 2, "запросы не дошли до разных реплик")
items, _ = history(user, chat, 100)
self.assertEqual(len(items), 10)
print("\n10 ключей по 8 параллельных запросов: реплик %d, сообщений в истории %d" % (len(instances), len(items)))
if __name__ == "__main__":
unittest.main()
+145
View File
@@ -0,0 +1,145 @@
import base64
import json
import unittest
import urllib.parse
from api import call, history, new_chat, new_user, send
class MessagePaginationTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.user = new_user()
cls.chat = new_chat(cls.user)
cls.sent = [send(cls.user, cls.chat, "сообщение %d" % number)[1] for number in range(25)]
cls.path = "/api/v1/chats/" + cls.chat["id"] + "/messages"
def test_walk_several_pages(self):
items, sizes = history(self.user, self.chat, limit=10)
self.assertEqual(sizes, [10, 10, 5])
self.assertEqual(items, self.sent)
def test_no_duplicates_and_order(self):
items, _ = history(self.user, self.chat, limit=7)
ids = [item["id"] for item in items]
self.assertEqual(len(ids), len(set(ids)))
keys = [(item["created_at"], item["id"]) for item in items]
self.assertEqual(keys, sorted(keys))
def test_exact_page_has_no_cursor(self):
_, page, _ = call("GET", self.path + "?limit=25", user=self.user)
self.assertEqual(len(page["items"]), 25)
self.assertIsNone(page["next_cursor"])
def test_default_limit(self):
_, page, _ = call("GET", self.path, user=self.user)
self.assertEqual(len(page["items"]), 25)
def test_limit_can_change_between_pages(self):
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
cursor = urllib.parse.quote(first["next_cursor"], safe="")
_, second, _ = call("GET", self.path + "?limit=100&cursor=" + cursor, user=self.user)
self.assertEqual(first["items"] + second["items"], self.sent)
def test_bad_limit(self):
for limit in ("0", "101", "-1", "abc", "1.5", ""):
with self.subTest(limit=limit):
self.assertEqual(call("GET", self.path + "?limit=" + limit, user=self.user)[0], 400)
def test_bad_cursor(self):
for cursor in ("garbage", "", "e30=", "%D0%B9"):
with self.subTest(cursor=cursor):
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
def test_cursor_format_is_checked(self):
_, first, _ = call("GET", self.path + "?limit=3", user=self.user)
good = first["next_cursor"]
scope, created_at, item_id = json.loads(base64.urlsafe_b64decode(good))
def encode(value, **options):
return base64.urlsafe_b64encode(json.dumps(value, **options).encode()).decode()
# тест знает внутренний формат cursor: собранный заново правильный cursor совпадает с выданным
self.assertEqual(encode([scope, created_at, item_id]), good)
bad = {
"посторонний символ внутри base64": good[:5] + "!" + good[5:],
"пробел внутри base64": good[:5] + " " + good[5:],
"перевод строки в конце": good + "\n",
"лишний знак =": good + "=",
"обрезанный": good[:-4],
"время не в формате сервера": encode([scope, "вчера", item_id]),
"время без микросекунд": encode([scope, created_at[:19] + "Z", item_id]),
"время с неполными микросекундами": encode([scope, created_at[:21] + "Z", item_id]),
"время со смещением вместо Z": encode([scope, created_at[:-1] + "+00:00", item_id]),
"несуществующая дата": encode([scope, "2026-13-45T25:61:61.000000Z", item_id]),
"число вместо времени": encode([scope, 1234567890, item_id]),
"id не UUID": encode([scope, created_at, "abc"]),
"UUID в верхнем регистре": encode([scope, created_at, item_id.upper()]),
"UUID без дефисов": encode([scope, created_at, item_id.replace("-", "")]),
"null вместо id": encode([scope, created_at, None]),
"лишний элемент": encode([scope, created_at, item_id, "x"]),
"не хватает элемента": encode([scope, created_at]),
"объект вместо списка": encode({"scope": scope, "created_at": created_at, "id": item_id}),
"тот же JSON без пробелов": encode([scope, created_at, item_id], separators=(",", ":")),
"пустой список": encode([]),
}
for name, cursor in bad.items():
with self.subTest(name):
path = self.path + "?cursor=" + urllib.parse.quote(cursor, safe="")
status, body, _ = call("GET", path, user=self.user)
self.assertEqual(status, 400)
self.assertEqual(body["error"]["code"], "invalid_request")
# правильный cursor при этом продолжает работать
self.assertEqual(call("GET", self.path + "?cursor=" + urllib.parse.quote(good, safe=""), user=self.user)[0], 200)
def test_cursor_from_another_chat(self):
other = new_chat(self.user, title="Другой чат")
send(self.user, other, "раз")
send(self.user, other, "два")
_, page, _ = call("GET", "/api/v1/chats/" + other["id"] + "/messages?limit=1", user=self.user)
cursor = urllib.parse.quote(page["next_cursor"], safe="")
self.assertEqual(call("GET", self.path + "?cursor=" + cursor, user=self.user)[0], 400)
def test_new_message_appears_after_last_page(self):
user = new_user()
chat = new_chat(user)
send(user, chat, "раз")
send(user, chat, "два")
path = "/api/v1/chats/" + chat["id"] + "/messages"
_, first, _ = call("GET", path + "?limit=1", user=user)
_, created, _ = send(user, chat, "три")
cursor = urllib.parse.quote(first["next_cursor"], safe="")
_, rest, _ = call("GET", path + "?limit=100&cursor=" + cursor, user=user)
self.assertEqual([item["text"] for item in rest["items"]], ["два", "три"])
self.assertEqual(rest["items"][-1], created)
class ChatPaginationTest(unittest.TestCase):
def test_walk_chat_list(self):
user = new_user()
created = [new_chat(user, title="Чат %d" % number) for number in range(5)]
items, cursor = [], None
while True:
path = "/api/v1/chats?limit=2"
if cursor:
path += "&cursor=" + urllib.parse.quote(cursor, safe="")
status, page, _ = call("GET", path, user=user)
self.assertEqual(status, 200)
self.assertLessEqual(len(page["items"]), 2)
items += page["items"]
cursor = page["next_cursor"]
if cursor is None:
break
self.assertEqual(items, created)
def test_chat_cursor_belongs_to_user(self):
alice, bob = new_user("alice"), new_user("bob")
for number in range(2):
new_chat(alice, bob, title="Общий %d" % number)
_, page, _ = call("GET", "/api/v1/chats?limit=1", user=alice)
cursor = urllib.parse.quote(page["next_cursor"], safe="")
self.assertEqual(call("GET", "/api/v1/chats?cursor=" + cursor, user=bob)[0], 400)
if __name__ == "__main__":
unittest.main()
+149
View File
@@ -0,0 +1,149 @@
import unittest
from api import call, login, new_chat, new_key, new_user, send, user_body
class ErrorFormatTest(unittest.TestCase):
def assert_error(self, result, status, code):
got_status, body, headers = result
self.assertEqual(got_status, status)
self.assertEqual(set(body), {"error"})
self.assertEqual(set(body["error"]), {"code", "message", "request_id"})
self.assertEqual(body["error"]["code"], code)
self.assertTrue(body["error"]["message"])
self.assertEqual(body["error"]["request_id"], headers["X-Request-Id"])
class InvalidJsonTest(ErrorFormatTest):
def test_malformed_json(self):
self.assert_error(call("POST", "/api/v1/users", raw=b'{"username": "abc", '), 400, "invalid_request")
def test_not_an_object(self):
self.assert_error(call("POST", "/api/v1/users", raw=b'["abc"]'), 400, "invalid_request")
def test_extra_field(self):
self.assert_error(call("POST", "/api/v1/users", user_body(is_admin=True)), 400, "invalid_request")
def test_wrong_type(self):
self.assert_error(call("POST", "/api/v1/users", user_body(username=12345)), 400, "invalid_request")
def test_missing_field(self):
body = user_body()
del body["password"]
self.assert_error(call("POST", "/api/v1/users", body), 400, "invalid_request")
def test_malformed_json_in_message(self):
user = new_user()
chat = new_chat(user)
path = "/api/v1/chats/" + chat["id"] + "/messages"
headers = {"Idempotency-Key": new_key()}
self.assert_error(call("POST", path, raw=b"{text: no quotes}", user=user, headers=headers), 400, "invalid_request")
def test_only_utf8_is_accepted(self):
user = new_user()
chat = new_chat(user)
path = "/api/v1/chats/" + chat["id"] + "/messages"
text = '{"text": "привет"}'
for raw in (text.encode("utf-16"), text.encode("utf-32"), b"\xef\xbb\xbf" + text.encode(), text.encode("cp1251")):
with self.subTest(start=raw[:4]):
headers = {"Idempotency-Key": new_key()}
self.assert_error(call("POST", path, raw=raw, user=user, headers=headers), 400, "invalid_request")
def test_content_type_must_be_json(self):
body = str(user_body()).replace("'", '"').encode()
for content_type in ("text/plain", "application/xml"):
with self.subTest(content_type=content_type):
headers = {"Content-Type": content_type}
self.assert_error(call("POST", "/api/v1/users", raw=body, headers=headers), 400, "invalid_request")
def test_deeply_nested_json(self):
self.assert_error(call("POST", "/api/v1/users", raw=b"[" * 100000), 400, "invalid_request")
def test_broken_json_without_token_is_401(self):
# сначала проверяется токен, и только потом разбирается тело
status, _, _ = call("POST", "/api/v1/chats", raw=b"{broken")
self.assertEqual(status, 401)
class UserValidationTest(ErrorFormatTest):
def test_bad_usernames(self):
for username in ("ab", "a" * 33, "Alice", "with space", "имя", "abc\n", ""):
with self.subTest(username=username):
self.assert_error(call("POST", "/api/v1/users", user_body(username=username)), 400, "invalid_request")
def test_bad_display_names(self):
for display_name in ("", " ", "\t\n", "я" * 101, "имя\u0000"):
with self.subTest(display_name=display_name):
result = call("POST", "/api/v1/users", user_body(display_name=display_name))
self.assert_error(result, 400, "invalid_request")
def test_display_name_length_is_counted_in_code_points(self):
# 100 эмодзи это 400 байт в UTF-8, но ровно 100 code points
status, user, _ = call("POST", "/api/v1/users", user_body(display_name="🙂" * 100))
self.assertEqual(status, 201)
self.assertEqual(user["display_name"], "🙂" * 100)
def test_bad_passwords(self):
for password in ("short-11-ch", "x" * 129, " " * 12, "", 123456789012, None):
with self.subTest(password=password):
self.assert_error(call("POST", "/api/v1/users", user_body(password=password)), 400, "invalid_request")
def test_password_length_limits(self):
for password in ("exactly-12-c", "x" * 128, "пароль🙂пароль"):
with self.subTest(length=len(password)):
body = user_body(password=password)
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
self.assertEqual(login(body["username"], password)[0], 201)
def test_password_is_never_returned(self):
body = user_body()
status, user, _ = call("POST", "/api/v1/users", body)
self.assertEqual(status, 201)
self.assertEqual(set(user), {"id", "username", "display_name", "created_at"})
_, session, _ = login(body["username"], body["password"])
self.assertNotIn(body["password"], str(session))
def test_duplicate_username(self):
body = user_body(display_name="Первый")
self.assertEqual(call("POST", "/api/v1/users", body)[0], 201)
body["display_name"] = "Второй"
self.assert_error(call("POST", "/api/v1/users", body), 409, "conflict")
class MessageValidationTest(ErrorFormatTest):
@classmethod
def setUpClass(cls):
cls.user = new_user()
cls.chat = new_chat(cls.user)
def test_empty_message(self):
self.assert_error(send(self.user, self.chat, ""), 400, "invalid_request")
def test_whitespace_message(self):
for text in (" ", " \n\t ", "  "):
with self.subTest(text=repr(text)):
self.assert_error(send(self.user, self.chat, text), 400, "invalid_request")
def test_nul_character(self):
self.assert_error(send(self.user, self.chat, "до\u0000после"), 400, "invalid_request")
def test_text_limit(self):
self.assertEqual(send(self.user, self.chat, "ы" * 4000)[0], 201)
self.assert_error(send(self.user, self.chat, "ы" * 4001), 400, "invalid_request")
def test_sender_id_is_not_accepted(self):
path = "/api/v1/chats/" + self.chat["id"] + "/messages"
body = {"text": "привет", "sender_id": self.user["id"]}
headers = {"Idempotency-Key": new_key()}
self.assert_error(call("POST", path, body, user=self.user, headers=headers), 400, "invalid_request")
def test_unicode_is_kept(self):
text = "Привет 👋 你好 مرحبا\nвторая строка"
status, message, _ = send(self.user, self.chat, text)
self.assertEqual(status, 201)
self.assertEqual(message["text"], text)
self.assertEqual(message["sender_id"], self.user["id"])
if __name__ == "__main__":
unittest.main()