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