diff --git a/.dockerignore b/.dockerignore index bc16e556..93f3500f 100644 --- a/.dockerignore +++ b/.dockerignore @@ -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 diff --git a/.env.example b/.env.example index d32b9be0..9379a99d 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..f4609ace --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +*.sh text eol=lf +*.cmd text eol=crlf diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..f7d33194 --- /dev/null +++ b/.github/workflows/app.yml @@ -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 diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..5ac5014f --- /dev/null +++ b/Dockerfile @@ -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"] diff --git a/Makefile b/Makefile index 5d86d171..ee7fcb85 100644 --- a/Makefile +++ b/Makefile @@ -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) diff --git a/REPORT.md b/REPORT.md index c2679005..e853854e 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 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//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 `. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..0d1380ff --- /dev/null +++ b/compose.yaml @@ -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 diff --git a/evidence/README.md b/evidence/README.md index 8df70015..801b3074 100644 --- a/evidence/README.md +++ b/evidence/README.md @@ -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 | diff --git a/evidence/expiry.txt b/evidence/expiry.txt new file mode 100644 index 00000000..67f78c83 --- /dev/null +++ b/evidence/expiry.txt @@ -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 diff --git a/evidence/failover-series.json b/evidence/failover-series.json new file mode 100644 index 00000000..951d3947 --- /dev/null +++ b/evidence/failover-series.json @@ -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 + } + } + ] +} \ No newline at end of file diff --git a/evidence/failover-series.txt b/evidence/failover-series.txt new file mode 100644 index 00000000..14389e57 --- /dev/null +++ b/evidence/failover-series.txt @@ -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 diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..9b09cf0e --- /dev/null +++ b/evidence/failover.txt @@ -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 diff --git a/evidence/failure.txt b/evidence/failure.txt new file mode 100644 index 00000000..21fa3987 --- /dev/null +++ b/evidence/failure.txt @@ -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 обработаны diff --git a/evidence/load.json b/evidence/load.json new file mode 100644 index 00000000..46924937 --- /dev/null +++ b/evidence/load.json @@ -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." +} diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..a5cefc2a --- /dev/null +++ b/evidence/persistence.txt @@ -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 diff --git a/evidence/rolling-update.json b/evidence/rolling-update.json new file mode 100644 index 00000000..b76e1928 --- /dev/null +++ b/evidence/rolling-update.json @@ -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)" + ] +} \ No newline at end of file diff --git a/evidence/rolling-update.txt b/evidence/rolling-update.txt new file mode 100644 index 00000000..a2d26312 --- /dev/null +++ b/evidence/rolling-update.txt @@ -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 diff --git a/evidence/sigterm.txt b/evidence/sigterm.txt new file mode 100644 index 00000000..db35b4ec --- /dev/null +++ b/evidence/sigterm.txt @@ -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] diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..f697945d --- /dev/null +++ b/evidence/smoke.txt @@ -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. diff --git a/evidence/student-tests.txt b/evidence/student-tests.txt new file mode 100644 index 00000000..03117373 --- /dev/null +++ b/evidence/student-tests.txt @@ -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 diff --git a/evidence/topology.txt b/evidence/topology.txt new file mode 100644 index 00000000..2ce804ba --- /dev/null +++ b/evidence/topology.txt @@ -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 diff --git a/infra/haproxy/haproxy.cfg b/infra/haproxy/haproxy.cfg new file mode 100644 index 00000000..5d9fac78 --- /dev/null +++ b/infra/haproxy/haproxy.cfg @@ -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 diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..44c4ed38 --- /dev/null +++ b/migrations/0001_init.sql @@ -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); diff --git a/migrations/0002_unicode_text.sql b/migrations/0002_unicode_text.sql new file mode 100644 index 00000000..bf25a000 --- /dev/null +++ b/migrations/0002_unicode_text.sql @@ -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); diff --git a/migrations/0003_session_revocations.sql b/migrations/0003_session_revocations.sql new file mode 100644 index 00000000..c2bcb84c --- /dev/null +++ b/migrations/0003_session_revocations.sql @@ -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); diff --git a/migrations/0004_idempotency_keys.sql b/migrations/0004_idempotency_keys.sql new file mode 100644 index 00000000..e4db9257 --- /dev/null +++ b/migrations/0004_idempotency_keys.sql @@ -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); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..0313e9df --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/scripts/init_secrets.py b/scripts/init_secrets.py new file mode 100644 index 00000000..74c4503b --- /dev/null +++ b/scripts/init_secrets.py @@ -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() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..713107fb --- /dev/null +++ b/scripts/restart.cmd @@ -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 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..e269cef9 --- /dev/null +++ b/scripts/restart.sh @@ -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 diff --git a/scripts/rolling_update.py b/scripts/rolling_update.py new file mode 100644 index 00000000..dcd76906 --- /dev/null +++ b/scripts/rolling_update.py @@ -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()) diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..ea9641bb --- /dev/null +++ b/scripts/stop-one.cmd @@ -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 diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..20a5f14c --- /dev/null +++ b/scripts/stop-one.sh @@ -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 diff --git a/src/app.py b/src/app.py new file mode 100644 index 00000000..93325a35 --- /dev/null +++ b/src/app.py @@ -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) diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..9af4a6d6 --- /dev/null +++ b/src/auth.py @@ -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 diff --git a/src/cache.py b/src/cache.py new file mode 100644 index 00000000..bdc3e275 --- /dev/null +++ b/src/cache.py @@ -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) diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..53039211 --- /dev/null +++ b/src/config.py @@ -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() diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..e4f2d5d1 --- /dev/null +++ b/src/db.py @@ -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') diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..5cbdbba5 --- /dev/null +++ b/src/errors.py @@ -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) diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..088b97b0 --- /dev/null +++ b/src/main.py @@ -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() diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..7ac81bac --- /dev/null +++ b/src/migrate.py @@ -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() diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..a1dab270 --- /dev/null +++ b/src/models.py @@ -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) diff --git a/src/pagination.py b/src/pagination.py new file mode 100644 index 00000000..81b08760 --- /dev/null +++ b/src/pagination.py @@ -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} diff --git a/src/store.py b/src/store.py new file mode 100644 index 00000000..f295157e --- /dev/null +++ b/src/store.py @@ -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) diff --git a/student-tests/expiry_check.py b/student-tests/expiry_check.py new file mode 100644 index 00000000..7bde51ec --- /dev/null +++ b/student-tests/expiry_check.py @@ -0,0 +1,56 @@ +"""Usage (стенд уже запущен через docker compose up -d): + python student-tests/expiry_check.py --ttl 2 + +Скрипт пересоздаёт только api с SESSION_TTL_SECONDS=, проверяет истечение сессии, +затем возвращает 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() diff --git a/student-tests/failover_series.py b/student-tests/failover_series.py new file mode 100644 index 00000000..bbe15e39 --- /dev/null +++ b/student-tests/failover_series.py @@ -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() diff --git a/student-tests/failure_check.py b/student-tests/failure_check.py new file mode 100644 index 00000000..a6ffa7ce --- /dev/null +++ b/student-tests/failure_check.py @@ -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() diff --git a/student-tests/helpers.py b/student-tests/helpers.py new file mode 100644 index 00000000..8c577953 --- /dev/null +++ b/student-tests/helpers.py @@ -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} diff --git a/student-tests/rolling_update_check.py b/student-tests/rolling_update_check.py new file mode 100644 index 00000000..eabfedcc --- /dev/null +++ b/student-tests/rolling_update_check.py @@ -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() diff --git a/student-tests/sigterm_check.py b/student-tests/sigterm_check.py new file mode 100644 index 00000000..5d09b0ee --- /dev/null +++ b/student-tests/sigterm_check.py @@ -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() diff --git a/student-tests/test_api.py b/student-tests/test_api.py new file mode 100644 index 00000000..be589b60 --- /dev/null +++ b/student-tests/test_api.py @@ -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() diff --git a/student-tests/test_auth.py b/student-tests/test_auth.py new file mode 100644 index 00000000..3a56ee20 --- /dev/null +++ b/student-tests/test_auth.py @@ -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() diff --git a/student-tests/test_concurrency.py b/student-tests/test_concurrency.py new file mode 100644 index 00000000..4d258446 --- /dev/null +++ b/student-tests/test_concurrency.py @@ -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() diff --git a/student-tests/test_db.py b/student-tests/test_db.py new file mode 100644 index 00000000..5997fd83 --- /dev/null +++ b/student-tests/test_db.py @@ -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() diff --git a/student-tests/test_idempotency.py b/student-tests/test_idempotency.py new file mode 100644 index 00000000..4ed9185b --- /dev/null +++ b/student-tests/test_idempotency.py @@ -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() diff --git a/student-tests/test_replicas.py b/student-tests/test_replicas.py new file mode 100644 index 00000000..84149108 --- /dev/null +++ b/student-tests/test_replicas.py @@ -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()