diff --git a/.env.example b/.env.example index d32b9be0..6734cd3b 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,14 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 +# Скопируйте в .env. Файл .env не коммитить. +# Пароль ниже — учебная заглушка локального стенда, не боевой секрет. APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +SESSION_STORE=valkey +POSTGRES_USER=messenger +POSTGRES_PASSWORD=local-only-change-me +POSTGRES_DB=messenger API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 +DRAIN_SECONDS=3 +# Не задавайте INSTANCE_ID: иначе все реплики получат один X-Instance-Id. +# DATABASE_URL и REDIS_URL собирает compose.yaml и передаёт только api/migrate. +# DATABASE_URL_FILE и CACHE_URL_FILE приложение тоже умеет читать, если файл есть. diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..04901310 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +*.sh text eol=lf +*.cfg text eol=lf +compose.yaml text eol=lf +Dockerfile text eol=lf +.env.example text eol=lf diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index e6e63eb2..c1d6e5c0 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,18 +1,18 @@ ## Лабораторная 3 -Автор / группа: TODO -Целевая оценка (3/4/5): TODO -Трек 5, если заявлен: TODO +Автор / группа: Самсонов Александр, БВТ2303 +Целевая оценка (3/4/5): 4 +Трек 5, если заявлен: нет -Что реализовано и что перенесено: TODO -Команды запуска из чистого clone: TODO -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO -Источники и использование ИИ: TODO +Что реализовано и что перенесено: из lab2 перенесены PostgreSQL, Valkey-сессии, scrypt и миграции. Добавлены Traefik, две реплики API без опубликованных портов, общий Idempotency-Key, drain по SIGTERM, scripts/stop-one.sh, scripts/restart.sh и scripts/rolling-update.sh. +Команды запуска из чистого clone: см. REPORT.md +Результаты проверок и ссылка на REPORT.md: make check, smoke, persistence и failover прошли; цифры отказа и rolling update в REPORT.md и evidence/ +Ограничения / известные ошибки: см. раздел ограничений в REPORT.md +Источники и использование ИИ: PostgreSQL advisory lock, Traefik Docker provider, RFC 7617, hashlib.scrypt, psycopg 3, redis-py. Реализацию помог собрать ИИ в Cursor. -- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. -- [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. -- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. -- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. +- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. +- [x] Контракт и публичные тесты не ослаблены. +- [x] make check и make test выполнены; приложен реальный вывод. +- [x] Сценарии отказов/безопасности своего уровня воспроизведены. +- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. +- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..3cae81ee --- /dev/null +++ b/Dockerfile @@ -0,0 +1,32 @@ +# syntax=docker/dockerfile:1.7 +FROM python:3.12.6-slim-bookworm + +RUN groupadd --system --gid 10001 app \ + && useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app + +WORKDIR /app +COPY requirements.txt /app/requirements.txt +RUN pip install --no-cache-dir -r /app/requirements.txt + +COPY --chown=app:app src/ /app/ +COPY --chown=app:app migrations/ /app/migrations/ + +USER app + +ENV PYTHONUNBUFFERED=1 \ + PYTHONDONTWRITEBYTECODE=1 \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab + +EXPOSE 8080 + +ARG BUILD_ID=dev +LABEL lab.build-id=$BUILD_ID + +STOPSIGNAL SIGTERM + +HEALTHCHECK --interval=10s --timeout=3s --start-period=8s --retries=5 \ + CMD python3 -c "import urllib.request,sys; urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2); sys.exit(0)" + +CMD ["python3", "/app/server.py"] diff --git a/REPORT.md b/REPORT.md index c2679005..56012f74 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,166 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO +- Автор, группа: Самсонов Александр, БВТ2303 +- Целевая оценка: 4 - Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Использованные источники, библиотеки и помощь ИИ: PostgreSQL advisory lock, Traefik Docker provider, RFC 7617, hashlib.scrypt, psycopg 3, redis-py. Реализацию сервера, Compose и проверок помог собрать ИИ в Cursor. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Engine 24+ с Compose v2 и Python 3.9+ для публичных тестов. Приложение в контейнере — Python 3.12.6. Проверка ниже выполнена в WSL Ubuntu 22.04: Docker 29.1.3, Compose 2.40.3, Python 3.10. На Windows у `python` без `PYTHONUTF8=1` публичный `make check` может не прочитать `openapi.json` в кодировке cp1251; в Linux/WSL это не требуется. + +```sh +git clone +cd mtusi2026lab3 +cp .env.example .env +# в .env учебный POSTGRES_PASSWORD, файл не коммитить +chmod +x scripts/up.sh scripts/restart.sh scripts/stop-one.sh scripts/restore-api.sh scripts/rolling-update.sh +docker compose --env-file .env -f compose.yaml config --quiet +docker compose --env-file .env -f compose.yaml up -d --build --scale api=2 --remove-orphans +``` + +Тот же запуск одной командой: `sh scripts/up.sh`. + +Готовность: `GET http://127.0.0.1:8080/health/ready` возвращает `{"status":"ok"}`. Порт 8080 опубликован только у `lb` и только на 127.0.0.1. Миграции применяет одноразовый сервис `migrate` до старта реплик. Повторный запуск не вставляет данные второй раз: версии лежат в `schema_migrations` (`001_init.sql`, `002_idempotency.sql`). + +Проверки: + +```sh +python3 scripts/check_contract.py +python3 tests/smoke.py --base-url http://127.0.0.1:8080 +python3 tests/student_level4.py --base-url http://127.0.0.1:8080 +python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 +python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080 +python3 scripts/grade4_probe.py +``` + +После failover одна реплика остаётся остановленной. Вернуть её: + +```sh +sh scripts/restore-api.sh +``` + +Остановка без удаления данных: + +```sh +docker compose --env-file .env -f compose.yaml stop +``` + +Удаление учебных данных вместе с volumes: + +```sh +docker compose --env-file .env -f compose.yaml down -v +``` + +Образы закреплены тегами: `python:3.12.6-slim-bookworm`, `postgres:16.6-bookworm`, `valkey/valkey:8.0.2`, `traefik:v3.7.16`. Зависимости Python закреплены в `requirements.txt`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент --HTTP--> Traefik (lb) --HTTP--> API ×2 (src/server.py) + |--SQL--> PostgreSQL + +--сессия--> Valkey (AOF + volume) +``` + +Из lab2 перенесены пользователи, чаты, членство, сообщения, keyset-пагинация, формат ошибок, `X-Request-Id`, Basic/Bearer, scrypt и сессии в Valkey. Локальной памяти, от которой зависит корректность, у API нет: сессии в общем Valkey, сообщения и ключи идемпотентности в общем PostgreSQL. `X-Instance-Id` — hostname контейнера, стабильный на время жизни процесса. В Compose hostname совпадает с коротким id контейнера, поэтому `scripts/stop-one.sh` находит реплику по `TARGET_INSTANCE_ID`. + +Sticky cookie нет. Traefik распределяет запросы по живым контейнерам сервиса `api`. Адреса он берёт из Docker API и обновляет по событиям start/die, а не из одного закэшированного DNS-ответа. Сокет Docker смонтирован только в `lb` и только на чтение. + +### Соответствие .env + +| Переменная | Куда попадает | +| --- | --- | +| `POSTGRES_USER`, `POSTGRES_PASSWORD`, `POSTGRES_DB` | `postgres`; из них же `DATABASE_URL` у `migrate` и `api` | +| `SESSION_TTL_SECONDS` | API, TTL сессии в Valkey | +| `IDEMPOTENCY_TTL_SECONDS` | API, окно повторного ключа, по умолчанию 86400 | +| `DRAIN_SECONDS` | API, пауза после SIGTERM до закрытия сокета, по умолчанию 3 | +| `API_REPLICAS` | `scripts/up.sh` и `scripts/restore-api.sh`, масштаб сервиса `api` | +| `REDIS_URL` | задаёт compose только сервису `api`: `redis://valkey:6379/0` | + +`INSTANCE_ID` в окружение реплик не передаётся: иначе обе получили бы один и тот же заголовок. `DATABASE_URL_FILE` и `CACHE_URL_FILE` приложение читает, если файл есть; этот стенд передаёт URL переменными и только тем сервисам, которым они нужны. Пароль Valkey нет: порт 6379 наружу не опубликован. Это учебное упрощение локального стенда. + +### Идемпотентность + +Область ключа: пользователь + `POST` + путь `/api/v1/chats/{id}/messages` + `Idempotency-Key`. Канонический вид тела — JSON с отсортированными ключами, где отсутствующий `attachment_ids` равен `[]`. В lab3 схема `CreateMessage` принимает только `text`; лишнее поле отклоняется с 400 до записи ключа, поэтому порядок ключей у валидного тела не создаёт второе сообщение. + +Одинаковый ключ сериализуется `pg_advisory_xact_lock`. `INSERT` сообщения и `INSERT` в `idempotency_keys` — одна транзакция. Обрыв до COMMIT не оставляет ни сообщения, ни «окончательного» результата, поэтому тот же ключ можно безопасно повторить. Повтор того же канонического тела в течение TTL возвращает тот же 201 и ту же строку `messages`. Другое тело — 409. На повторе снова проверяются сессия и членство в чате. Чужой чат и пустой текст ключ не занимают. + +### Миграции + +Их запускает только `migrate` (`python3 /app/migrate.py`), один процесс, под `pg_advisory_lock`. Реплики API миграции не выполняют. `002_idempotency.sql` добавляет таблицу и совместим с уже работающим кодом lab2: старый процесс эту таблицу не читает. Rolling update схему не меняет. Ломающее изменение колонки при ещё живых старых репликах этот стенд не поддерживает. + +### Health, таймауты, SIGTERM + +| Узел | Настройка | +| --- | --- | +| API `/health/live` | 200, пока процесс жив, в том числе во время drain | +| API `/health/ready` | 200, если не идёт остановка и доступны PostgreSQL и Valkey; иначе 503 | +| Traefik healthcheck | `GET /health/ready` каждые 1 с, timeout 1 с | +| Исключение backend | одна неуспешная проверка убирает реплику из балансировки | +| Верхняя оценка обнаружения | 1 с до следующей проверки + 1 с timeout = 2 с | +| Клиент и upstream Traefik | dial 1 с, ответ 8 с, idle 5 с / 1 с | +| SIGTERM API | сразу 503 на `/health/ready` и на новые бизнес-запросы; сокет закрывается через `DRAIN_SECONDS` (3 с) | +| `stop_grace_period` API | 10 с; `scripts/stop-one.sh` вызывает `docker stop -t 8` | +| Docker healthcheck API | `/health/ready`, интервал 2 с | + +Пока реплика уже отдаёт 503, но ещё не вышла, Traefik перестаёт слать ей новые запросы. Краткие обрывы до этого момента возможны и измеряются ниже. `restart: unless-stopped` поднимает контейнер после падения процесса и не поднимает его после `docker stop`. + +### Лимиты и порты + +Проверено `docker inspect` во время `scripts/grade4_probe.py` (`evidence/grade4.json`, поле `container_limits`): + +| Сервис | CPU | RAM | Порт на хосте | +| --- | --- | --- | --- | +| api | 0.50 | 256 MiB | нет | +| lb | 0.25 | 128 MiB | 127.0.0.1:8080 | +| postgres | 0.75 | 512 MiB | нет | +| valkey | 0.25 | 128 MiB | нет | +| migrate | 0.50 | 256 MiB | нет, одноразовый контейнер | + +`container_name` нет, сервис `api` масштабируется `--scale`. ## Доказательства критериев +Стенд: WSL2, 20 CPU на машине, лимиты контейнеров — из таблицы выше. Нагрузка — closed-loop POST, concurrency 4, timeout клиента 3 с, без повторов на клиенте. Это подтверждения HTTP, не замер предела БД. Дата прогона: 2026-10-23. + | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `python3 tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | evidence/smoke.txt | +| Offline-структура | `python3 scripts/check_contract.py` | PASS | вывод в той же сессии, контракт не менялся | +| Две реплики, один вход, общая БД и сессии | `docker compose ps`, 30 GET `/users/me` | Два разных `X-Instance-Id` на одной сессии. Порт только у lb. Postgres и Valkey без портов на хосте | evidence/level4.txt, evidence/grade4.json | +| Отказ одной реплики ≤ 10 с | `tests/resilience.py --mode failover --action-script scripts/stop-one.sh` | 2 реплики до отказа; 139 успешных записей; 4 ошибки; первое успешное восстановление 3.56 с. `api-3` остался Exited, `api-4` healthy | evidence/failover.txt | +| Идемпотентность, в том числе гонка | `tests/student_level4.py` и блок parallel в probe | 8 параллельных POST, один id сообщения, оба instance id. Другое тело — 409. История без дубля | evidence/level4.txt, evidence/grade4.json | +| Сохранность токена и сообщений | `tests/resilience.py --mode persistence --action-script scripts/restart.sh` | PASS. Перезапущены api, postgres, valkey. Volumes `mtusi-lab3_pgdata` и `mtusi-lab3_valkeydata` на месте | evidence/persistence.txt | +| Health/readiness и SIGTERM согласованы, LB убирает backend | конфиг `infra/traefik.yml`, drain в `src/server.py`, probe | Период проверки 1 с, максимум обнаружения 2 с. Hook `docker stop` вернулся за 3.70 с и 3.81 с. После возврата hook целевой id в успешных ответах отсутствует | evidence/grade4.json | +| По очереди остановить каждую реплику, собрать RPS и ошибки | `python3 scripts/grade4_probe.py` | База: 397 rps, 0 ошибок, p50 4.3 мс, p95 59 мс. Отказ первой: 171 rps, 154 ошибки за 9.7 с, чужая реплика ответила через 0.034 с, свой id вернулся через 5.3 с после start. Отказ второй: 172 rps, 40 ошибок, чужая реплика через 0.003 с, восстановление id 6.1 с | evidence/grade4.json | +| Параллельный один ключ через разные реплики | 8 потоков в probe и student_level4 | `unique_message_ids=1`, оба instance id | evidence/grade4.json | +| CPU/RAM, нет обхода LB, нет container_name | `docker inspect` внутри probe | Лимиты из таблицы выше. У API `8080/tcp` без HostPort | evidence/grade4.json | +| Rolling update под нагрузкой | `scripts/rolling-update.sh` во время той же нагрузки | exit 0, 34.9 с, 12894 успеха, 80 ошибок (0.6%), 370 rps. Образ сменился с `sha256:d1cb2d180884` на `sha256:3ba24670218f`. В окне видны и старые, и новые id | evidence/grade4.json | +| Миграции один раз и совместимы | `select version from schema_migrations` | Две строки: `001_init.sql`, `002_idempotency.sql`. API миграции не запускает. 002 только добавляет таблицу | этот отчёт | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Гипотеза: при остановке одной из двух реплик живая продолжит чтение и запись быстрее чем за 10 с, а один `Idempotency-Key` не создаст второе сообщение даже при параллельных POST. + +Профиль: closed-loop POST сообщений, 4 потока, timeout 3 с, без клиентских retry. Прогрев — 8 с baseline. Окно отказа — время `docker stop` плюс 6 с. Rolling шёл под той же нагрузкой 35 с. Повтор одного прогона. Аппаратные лимиты — таблица сервисов, не вся машина (20 CPU, память WSL около 16 GiB). | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Baseline, обе реплики | Оба id, ошибки около нуля | 3182 успеха, 0 ошибок, 397 rps, p50/p95/p99 = 4.3/59/68 мс | — | +| `stop-one.sh` для `4cd3b03e049d` | Запись продолжается на второй реплике, ключ не двоит | 1664 успеха, 154 ошибки (8.5%), 171 rps. После возврата hook целевого id в успехах нет | Успех на другой реплике через 0.034 с от старта stop. Тот же id снова виден через 5.3 с после restore. Потери подтверждённых сообщений нет | +| `stop-one.sh` для `ee551154827e` | То же для второй реплики | 1693 успеха, 40 ошибок (2.3%), 172 rps | 0.003 с до чужой реплики, 6.1 с до возврата своего id | +| Публичный failover | ≥2 id до отказа, восстановление ≤ 10 с, остановленная реплика не обслуживает | 2 id, 139 успехов, 4 ошибки, first_recovery 3.56 с. `api-3` Exited, `api-4` healthy | 3.56 с от старта hook. Подтверждённые сообщения и сессия на месте | +| Rolling update под нагрузкой | Поочерёдная замена, сервис остаётся доступен | exit 0, 80 ошибок на 12894 успеха, образ сменился | Окно 34.9 с, rps 370. Дублей из-за замены не измерялось отдельно: каждая запись нагрузки имеет свой ключ | +| Рестарт api+postgres+valkey | Старый токен и сообщение живы, volume на месте | PASS публичного persistence | Volumes не удалялись | + +Падение rps примерно вдвое при одной реплике совпадает с тем, что упор этого профиля — CPU API, а не отказ LB. 154 ошибки в первом отказе — запросы, которые попали в реплику в первые секунды drain, пока Traefik ещё не снял её с балансировки. Клиент их не повторял; в публичном тесте неопределённый POST повторяется с тем же ключом, дубля нет. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Выдерживается остановка одного процесса API при живых LB, PostgreSQL и Valkey. Не выдерживается отказ узла, отказ самого LB и отказ PostgreSQL: это одна машина и одна БД. Падение Valkey делает `/health/ready` равным 503, потому что без общего хранилища сессий реплики разошлись бы. + +Valkey без пароля и пароль БД в переменных compose — упрощение локального стенда. Сокет Docker у Traefik даёт балансировщику право читать состояние контейнеров; наружу этот сокет не публикуется. + +Просроченные ключи идемпотентности удаляются при следующем использовании того же ключа, а не фоновой уборкой. `scripts/rolling-update.sh` вызывает `docker build`; на Docker 29 этот путь печатает предупреждение про legacy builder, образ при этом собирается и подменяется, что видно по смене sha256. Схема во время rolling не мигрирует. + +397 rps — closed-loop с четырьмя потоками на localhost, с coordinated omission. Это не предел стенда и не результат трека 5. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..d163bcc9 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,154 @@ +# Локальный стенд lab3: клиент → Traefik → API ×2 → PostgreSQL + Valkey. +# Публичный порт только у lb. У API нет ports и нет container_name. +# Миграции выполняет одноразовый сервис migrate, не каждая реплика. +name: mtusi-lab3 + +services: + postgres: + image: postgres:16.6-bookworm + environment: + POSTGRES_USER: ${POSTGRES_USER:-messenger} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?set POSTGRES_PASSWORD in .env} + POSTGRES_DB: ${POSTGRES_DB:-messenger} + volumes: + - pgdata:/var/lib/postgresql/data + shm_size: 128mb + healthcheck: + test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"] + interval: 2s + timeout: 3s + retries: 20 + start_period: 5s + restart: unless-stopped + stop_grace_period: 20s + networks: [lab] + deploy: + resources: + limits: + cpus: "0.75" + memory: 512M + + valkey: + image: valkey/valkey:8.0.2 + command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec", "--save", "60", "1"] + volumes: + - valkeydata:/data + healthcheck: + test: ["CMD", "valkey-cli", "ping"] + interval: 2s + timeout: 3s + retries: 20 + start_period: 3s + restart: unless-stopped + stop_grace_period: 10s + networks: [lab] + deploy: + resources: + limits: + cpus: "0.25" + memory: 128M + + migrate: + build: . + image: mtusi-messenger:lab3 + command: ["python3", "/app/migrate.py"] + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger} + depends_on: + postgres: + condition: service_healthy + restart: "no" + networks: [lab] + deploy: + resources: + limits: + cpus: "0.50" + memory: 256M + + api: + build: . + image: mtusi-messenger:lab3 + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: ${APP_ENV:-lab} + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + SESSION_STORE: valkey + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DRAIN_SECONDS: ${DRAIN_SECONDS:-3} + DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-messenger} + REDIS_URL: redis://valkey:6379/0 + depends_on: + migrate: + condition: service_completed_successfully + valkey: + condition: service_healthy + expose: + - "8080" + labels: + - traefik.enable=true + - traefik.docker.network=mtusi-lab3-net + - traefik.http.routers.messenger.rule=PathPrefix(`/`) + - traefik.http.routers.messenger.entrypoints=web + - traefik.http.services.messenger.loadbalancer.server.port=8080 + - traefik.http.services.messenger.loadbalancer.healthcheck.path=/health/ready + - traefik.http.services.messenger.loadbalancer.healthcheck.interval=1s + - traefik.http.services.messenger.loadbalancer.healthcheck.timeout=1s + - traefik.http.services.messenger.loadbalancer.healthcheck.scheme=http + - traefik.http.services.messenger.loadbalancer.passhostheader=true + healthcheck: + test: + - CMD + - python3 + - -c + - import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2) + interval: 2s + timeout: 2s + retries: 8 + start_period: 8s + init: true + restart: unless-stopped + stop_grace_period: 10s + stop_signal: SIGTERM + networks: [lab] + deploy: + replicas: 2 + resources: + limits: + cpus: "0.50" + memory: 256M + + lb: + image: traefik:v3.7.16 + command: ["--configFile=/etc/traefik/traefik.yml"] + volumes: + - ./infra/traefik.yml:/etc/traefik/traefik.yml:ro + - /var/run/docker.sock:/var/run/docker.sock:ro + ports: + - "127.0.0.1:8080:8080" + depends_on: + api: + condition: service_healthy + healthcheck: + test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8082/ping"] + interval: 2s + timeout: 2s + retries: 8 + start_period: 3s + restart: unless-stopped + stop_grace_period: 5s + networks: [lab] + deploy: + resources: + limits: + cpus: "0.25" + memory: 128M + +networks: + lab: + name: mtusi-lab3-net + driver: bridge + +volumes: + pgdata: + valkeydata: diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..5a8b93a0 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,18 @@ +Дата: 2026-10-23 +Команда: + +python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080 + +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 139, "failed_attempts": 4, "first_recovery_seconds": 3.56} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. + +Сразу после теста: +mtusi-lab3-api-3 Exited (0) — остановлен hook и оставлен остановленным +mtusi-lab3-api-4 Up (healthy) — продолжал обслуживать LB + +X-Instance-Id совпадает с hostname контейнера. stop-one.sh ищет контейнер сервиса api +с этим hostname или с коротким id и вызывает docker stop -t 8. +restart: unless-stopped после docker stop контейнер сам не поднимает. + +Поочерёдный отказ каждой реплики и цифры RPS — в evidence/grade4.json. diff --git a/evidence/grade4.json b/evidence/grade4.json new file mode 100644 index 00000000..1c565cef --- /dev/null +++ b/evidence/grade4.json @@ -0,0 +1,169 @@ +{ + "date": "2026-10-22T21:59:17Z", + "platform": "Linux-6.18.54.1-microsoft-standard-WSL2-x86_64-with-glibc2.35", + "cpu_count": 20, + "workload": "closed-loop POST, concurrency 4, client timeout 3s, no client retry", + "observed_instances": [ + "4cd3b03e049d", + "ee551154827e" + ], + "parallel_idempotency": { + "requests": 8, + "unique_message_ids": 1, + "instances": [ + "4cd3b03e049d", + "ee551154827e" + ] + }, + "baseline": { + "seconds": 8.009, + "successful_requests": 3182, + "failed_requests": 0, + "successful_rps": 397.291, + "error_ratio": 0.0, + "success_latency_ms": { + "p50": 4.299, + "p95": 59.098, + "p99": 67.737 + }, + "instances": [ + "4cd3b03e049d", + "ee551154827e" + ] + }, + "failovers": [ + { + "target": "4cd3b03e049d", + "stop_hook_exit": 0, + "stop_hook_seconds": 3.703, + "window": { + "seconds": 9.706, + "successful_requests": 1664, + "failed_requests": 154, + "successful_rps": 171.446, + "error_ratio": 0.084708, + "success_latency_ms": { + "p50": 8.807, + "p95": 75.37, + "p99": 93.708 + }, + "instances": [ + "4cd3b03e049d", + "ee551154827e" + ] + }, + "first_other_replica_success_seconds": 0.034, + "target_seen_after_hook_returned": false, + "instances_after_hook": [ + "ee551154827e" + ], + "restore_until_target_seen_seconds": 5.324, + "instances_after_restore": [ + "4cd3b03e049d", + "ee551154827e" + ], + "restore_command_seconds": 7.031 + }, + { + "target": "ee551154827e", + "stop_hook_exit": 0, + "stop_hook_seconds": 3.812, + "window": { + "seconds": 9.816, + "successful_requests": 1693, + "failed_requests": 40, + "successful_rps": 172.474, + "error_ratio": 0.023081, + "success_latency_ms": { + "p50": 10.399, + "p95": 74.827, + "p99": 96.476 + }, + "instances": [ + "4cd3b03e049d", + "ee551154827e" + ] + }, + "first_other_replica_success_seconds": 0.003, + "target_seen_after_hook_returned": false, + "instances_after_hook": [ + "4cd3b03e049d" + ], + "restore_until_target_seen_seconds": 6.064, + "instances_after_restore": [ + "4cd3b03e049d", + "ee551154827e" + ], + "restore_command_seconds": 7.79 + } + ], + "images_before_roll": [ + "sha256:d1cb2d180884" + ], + "images_after_roll": [ + "sha256:3ba24670218f" + ], + "rolling_under_load": { + "seconds": 34.863, + "successful_requests": 12894, + "failed_requests": 80, + "successful_rps": 369.843, + "error_ratio": 0.006166, + "success_latency_ms": { + "p50": 4.665, + "p95": 59.016, + "p99": 77.441 + }, + "instances": [ + "11f3266202c8", + "210b73040413", + "4cd3b03e049d", + "ee551154827e" + ], + "exit": 0, + "stderr_tail": "PRECATED: The legacy builder is deprecated and will be removed in a future release.\n Install the buildx component to build images with BuildKit:\n https://docs.docker.com/go/buildx/\n\n Container mtusi-lab3-api-1 Running\n Container mtusi-lab3-api-2 Running\n Container mtusi-lab3-api-3 Creating\n Container mtusi-lab3-api-3 Created\n Container mtusi-lab3-api-3 Starting\n Container mtusi-lab3-api-3 Started\n Container mtusi-lab3-api-2 Running\n Container mtusi-lab3-api-3 Running\n Container mtusi-lab3-api-2 Running\n Container mtusi-lab3-api-3 Running\n Container mtusi-lab3-api-4 Creating\n Container mtusi-lab3-api-4 Created\n Container mtusi-lab3-api-4 Starting\n Container mtusi-lab3-api-4 Started\n Container mtusi-lab3-api-3 Running\n Container mtusi-lab3-api-4 Running\n" + }, + "container_limits": [ + { + "name": "mtusi-lab3-api-3", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "published": "{\"8080/tcp\":null}" + }, + { + "name": "mtusi-lab3-api-4", + "nano_cpus": 500000000, + "memory_bytes": 268435456, + "published": "{\"8080/tcp\":null}" + }, + { + "name": "mtusi-lab3-lb-1", + "nano_cpus": 250000000, + "memory_bytes": 134217728, + "published": "{\"80/tcp\":null,\"8080/tcp\":[{\"HostIp\":\"127.0.0.1\",\"HostPort\":\"8080\"}]}" + }, + { + "name": "mtusi-lab3-postgres-1", + "nano_cpus": 750000000, + "memory_bytes": 536870912, + "published": "{\"5432/tcp\":null}" + }, + { + "name": "mtusi-lab3-valkey-1", + "nano_cpus": 250000000, + "memory_bytes": 134217728, + "published": "{\"6379/tcp\":null}" + } + ], + "lb_timeouts": { + "check_interval_seconds": 1, + "unhealthy_after_failures": 1, + "check_timeout_seconds": 1, + "max_detection_seconds": 2, + "connect_timeout_seconds": 1, + "server_timeout_seconds": 8, + "client_timeout_seconds": 8, + "drain_seconds": 3, + "stop_grace_seconds": 10 + } +} diff --git a/evidence/level4.txt b/evidence/level4.txt new file mode 100644 index 00000000..6e81b9e4 --- /dev/null +++ b/evidence/level4.txt @@ -0,0 +1,14 @@ +Дата: 2026-10-23 +Команда: + +python3 tests/student_level4.py --base-url http://127.0.0.1:8080 + +PASS: level4 spread=4cd3b03e049d,ee551154827e parallel_instances=4cd3b03e049d,ee551154827e + +8 параллельных POST с одним Idempotency-Key и одним телом дали одно сообщение. +Оба запроса дошли до разных реплик. Повтор с другим телом — 409. +Одинаковый ключ у двух пользователей создал два разных сообщения. + +После rolling update тот же тест: + +PASS: level4 spread=11f3266202c8,210b73040413 parallel_instances=11f3266202c8,210b73040413 diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..33372c89 --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,18 @@ +Дата: 2026-10-23 +Команда: + +python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 + +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. + +scripts/restart.sh выполняет: +docker compose --env-file .env -f compose.yaml restart api postgres valkey + +Volumes не удаляются. После теста на месте: +mtusi-lab3_pgdata +mtusi-lab3_valkeydata + +docker compose ps после hook: api-1 и api-2 Up (healthy), postgres Up (healthy), valkey Up (healthy). +Контейнеры те же (CREATED не сброшен), процессы перезапущены (Up несколько секунд). +Migrate повторно данные не заливает. diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..cd3dc33d --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,8 @@ +Дата: 2026-10-23 +Команда (WSL Ubuntu, Python 3.10, стенд уже поднят): + +python3 tests/smoke.py --base-url http://127.0.0.1:8080 + +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. + +Повтор после смены статического конфига Traefik (aliasHeadersStrategy) — тот же PASS. diff --git a/infra/traefik.yml b/infra/traefik.yml new file mode 100644 index 00000000..3c70b5f0 --- /dev/null +++ b/infra/traefik.yml @@ -0,0 +1,44 @@ +# Traefik 3.7.16. Без sticky cookie. +# Адреса API Traefik берёт из Docker и обновляет по событиям start/die, +# поэтому новая реплика и остановленная не зависят от кэша одного DNS-ответа. +# Healthcheck: период 1s, timeout 1s, одна неуспешная проверка исключает backend. +# Верхняя оценка обнаружения отказа: 1s до следующей проверки + 1s timeout = 2s. +# Таймауты клиента и upstream согласованы с drain API (3s) и stop_grace_period (10s). + +global: + checkNewVersion: false + sendAnonymousUsage: false + +entryPoints: + web: + address: ":8080" + http: + aliasHeadersStrategy: reject + transport: + respondingTimeouts: + readTimeout: 8s + writeTimeout: 8s + idleTimeout: 5s + ping: + address: "127.0.0.1:8082" + http: + aliasHeadersStrategy: delete + +ping: + entryPoint: ping + +providers: + docker: + endpoint: unix:///var/run/docker.sock + exposedByDefault: false + network: mtusi-lab3-net + watch: true + +serversTransport: + forwardingTimeouts: + dialTimeout: 1s + responseHeaderTimeout: 8s + idleConnTimeout: 1s + +log: + level: INFO diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..3c2cc42f --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,49 @@ +-- Пользователи, чаты, участники, сообщения. +-- Сессии здесь не хранятся: их источник истины — Valkey (AOF + volume). +-- Идемпотентность отправки — в 002_idempotency.sql. +-- +-- Транзакции приложения: +-- регистрация — один INSERT, уникальность username держит UNIQUE +-- создание чата — одна транзакция: чат и все chat_members, иначе откат +-- сообщение и запись идемпотентности — одна транзакция +-- +-- Индекс истории messages_history_idx покрывает keyset-запрос +-- WHERE chat_id = $1 AND (created_at, id) > ($2, $3) +-- ORDER BY created_at, id +-- LIMIT $4 + +CREATE TABLE users ( + id uuid PRIMARY KEY, + username text NOT NULL, + display_name text NOT NULL, + password_hash text NOT NULL, + created_at timestamptz NOT NULL, + CONSTRAINT users_username_unique UNIQUE (username) +); + +CREATE TABLE chats ( + id uuid PRIMARY KEY, + title text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE INDEX chats_created_idx ON chats (created_at, id); + +CREATE TABLE chat_members ( + chat_id uuid NOT NULL REFERENCES chats (id), + user_id uuid NOT NULL REFERENCES users (id), + position integer NOT NULL, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id); + +CREATE TABLE messages ( + id uuid PRIMARY KEY, + chat_id uuid NOT NULL REFERENCES chats (id), + sender_id uuid NOT NULL REFERENCES users (id), + text text NOT NULL, + created_at timestamptz NOT NULL +); + +CREATE INDEX messages_history_idx ON messages (chat_id, created_at, id); diff --git a/migrations/002_idempotency.sql b/migrations/002_idempotency.sql new file mode 100644 index 00000000..bab92309 --- /dev/null +++ b/migrations/002_idempotency.sql @@ -0,0 +1,18 @@ +-- Общий результат POST сообщения. +-- Область: user_id + http_method + path + idem_key. +-- Строка пишется в той же транзакции, что и messages, поэтому 5xx +-- до COMMIT не оставляет ни сообщения, ни «окончательного» ключа. +-- Повтор с другим request_hash в пределах TTL — отказ без второй вставки. + +CREATE TABLE idempotency_keys ( + user_id uuid NOT NULL REFERENCES users (id), + http_method text NOT NULL, + path text NOT NULL, + idem_key text NOT NULL, + request_hash text NOT NULL, + message_id uuid NOT NULL REFERENCES messages (id), + created_at timestamptz NOT NULL, + PRIMARY KEY (user_id, http_method, path, idem_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..656df564 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +psycopg[binary]==3.2.3 +psycopg-pool==3.2.3 +redis==5.1.1 diff --git a/scripts/grade4_probe.py b/scripts/grade4_probe.py new file mode 100644 index 00000000..c0d00929 --- /dev/null +++ b/scripts/grade4_probe.py @@ -0,0 +1,325 @@ +#!/usr/bin/env python3 +"""Нагрузка, поочерёдный отказ каждой реплики и rolling update. Токены не печатает.""" +from __future__ import annotations + +import json +import os +import platform +import subprocess +import sys +import threading +import time +import uuid +from concurrent.futures import ThreadPoolExecutor +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "tests")) + +from client import Client, Failure # noqa: E402 + + +def run(cmd, env=None, check=True): + return subprocess.run( + cmd, + cwd=ROOT, + env=env, + check=check, + text=True, + capture_output=True, + ) + + +def compose(*args): + return run(["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", *args]) + + +def api_ids(): + proc = compose("ps", "-q", "api") + return [line.strip() for line in proc.stdout.splitlines() if line.strip()] + + +def inspect(cid, fmt): + return run(["docker", "inspect", "-f", fmt, cid]).stdout.strip() + + +def percentile(values, p): + if not values: + return None + ordered = sorted(values) + index = max(0, int(round((len(ordered) - 1) * p))) + return round(ordered[index] * 1000, 3) + + +class Load: + def __init__(self, base, actor, chat, concurrency=4): + self.base = base + self.actor = actor + self.chat = chat + self.concurrency = concurrency + self.events = [] + self._stop = threading.Event() + self._origin = time.monotonic() + self._pool = None + self._futures = [] + + def now(self): + return time.monotonic() - self._origin + + def start(self): + def worker(worker_id): + local = Client(self.base, timeout=3) + index = 0 + while not self._stop.is_set(): + stamp = self.now() + try: + response = local.message( + self.actor, + self.chat, + "load-%s-%s-%s" % (worker_id, index, uuid.uuid4().hex[:8]), + ) + self.events.append({ + "ok": True, + "t": stamp, + "dt": self.now() - stamp, + "instance": response["headers"].get("X-Instance-Id"), + }) + except Failure: + self.events.append({ + "ok": False, + "t": stamp, + "dt": self.now() - stamp, + "instance": None, + }) + index += 1 + + self._pool = ThreadPoolExecutor(max_workers=self.concurrency) + self._futures = [self._pool.submit(worker, i) for i in range(self.concurrency)] + + def stop(self): + self._stop.set() + for future in self._futures: + future.result() + self._pool.shutdown(wait=True) + + def summary(self, start, end): + window = [item for item in self.events if start <= item["t"] < end] + ok = [item for item in window if item["ok"]] + bad = [item for item in window if not item["ok"]] + elapsed = max(end - start, 0.001) + return { + "seconds": round(end - start, 3), + "successful_requests": len(ok), + "failed_requests": len(bad), + "successful_rps": round(len(ok) / elapsed, 3), + "error_ratio": round(len(bad) / len(window), 6) if window else None, + "success_latency_ms": { + "p50": percentile([item["dt"] for item in ok], 0.50), + "p95": percentile([item["dt"] for item in ok], 0.95), + "p99": percentile([item["dt"] for item in ok], 0.99), + }, + "instances": sorted({item["instance"] for item in ok if item["instance"]}), + } + + +def wait_ready(base, timeout=90): + deadline = time.monotonic() + timeout + while True: + try: + Client(base, timeout=2).call("GET", "/health/ready", schema="Health") + return + except Failure: + if time.monotonic() > deadline: + raise SystemExit("API did not become ready") + time.sleep(0.5) + + +def wait_instance(base, actor, wanted, timeout): + started = time.monotonic() + seen = set() + while time.monotonic() - started < timeout: + try: + seen.add( + Client(base, timeout=2).call( + "GET", "/api/v1/users/me", actor=actor, schema="User" + )["headers"]["X-Instance-Id"] + ) + except Failure: + pass + if wanted in seen: + return round(time.monotonic() - started, 3), sorted(seen) + time.sleep(0.2) + return None, sorted(seen) + + +def container_limits(): + rows = [] + proc = compose("ps", "-q") + for cid in [line.strip() for line in proc.stdout.splitlines() if line.strip()]: + rows.append({ + "name": inspect(cid, "{{.Name}}").lstrip("/"), + "nano_cpus": int(inspect(cid, "{{.HostConfig.NanoCpus}}") or "0"), + "memory_bytes": int(inspect(cid, "{{.HostConfig.Memory}}") or "0"), + "published": inspect(cid, "{{json .NetworkSettings.Ports}}"), + }) + return rows + + +def main(): + base = os.environ.get("BASE_URL", "http://localhost:8080") + wait_ready(base) + client = Client(base, timeout=10) + alice, _bob, _eve, chat = client.bootstrap() + spread = [ + client.call("GET", "/api/v1/users/me", actor=alice, schema="User")["headers"]["X-Instance-Id"] + for _ in range(30) + ] + observed = sorted(set(spread)) + if len(observed) < 2: + raise SystemExit("need two instance ids, saw %s" % observed) + + key = "probe-" + uuid.uuid4().hex + text = "параллельный ключ " + key + barrier = threading.Barrier(8) + + def once(_n): + local = Client(base, timeout=10) + barrier.wait() + response = local.message(alice, chat, text, key=key) + return response["json"]["id"], response["headers"]["X-Instance-Id"] + + with ThreadPoolExecutor(max_workers=8) as pool: + parallel = list(pool.map(once, range(8))) + parallel_ids = sorted({item[0] for item in parallel}) + parallel_instances = sorted({item[1] for item in parallel}) + if len(parallel_ids) != 1: + raise SystemExit("parallel idempotency created %s messages" % len(parallel_ids)) + + load = Load(base, alice, chat) + load.start() + time.sleep(8) + baseline_end = load.now() + baseline = load.summary(0, baseline_end) + + failovers = [] + for target in observed: + time.sleep(1) + mark = load.now() + env = os.environ.copy() + env["TARGET_INSTANCE_ID"] = target + started = time.monotonic() + proc = run([str(ROOT / "scripts" / "stop-one.sh")], env=env, check=False) + stop_s = round(time.monotonic() - started, 3) + stopped_at = load.now() + time.sleep(6) + window_end = load.now() + after = [item for item in load.events if item["t"] >= stopped_at and item["ok"]] + served = sorted({item["instance"] for item in after if item["instance"]}) + first = None + for item in load.events: + if item["t"] >= mark and item["ok"] and item["instance"] and item["instance"] != target: + first = round(item["t"] - mark, 3) + break + restore_started = time.monotonic() + run([str(ROOT / "scripts" / "restore-api.sh")]) + back_s, seen_after = wait_instance(base, alice, target, 40) + failovers.append({ + "target": target, + "stop_hook_exit": proc.returncode, + "stop_hook_seconds": stop_s, + "window": load.summary(mark, window_end), + "first_other_replica_success_seconds": first, + "target_seen_after_hook_returned": target in served, + "instances_after_hook": served, + "restore_until_target_seen_seconds": back_s, + "instances_after_restore": seen_after, + "restore_command_seconds": round(time.monotonic() - restore_started, 3), + }) + if proc.returncode != 0: + load.stop() + raise SystemExit("stop-one failed for %s\n%s" % (target, proc.stderr)) + if first is None or first > 10 or target in served: + load.stop() + raise SystemExit("failover criteria failed for %s" % target) + + images_before = sorted({inspect(cid, "{{.Image}}")[:19] for cid in api_ids()}) + roll_mark = load.now() + holder = {} + + def run_roll(): + proc = run([str(ROOT / "scripts" / "rolling-update.sh")], check=False) + holder["code"] = proc.returncode + holder["err"] = (proc.stderr or "")[-800:] + holder["out"] = (proc.stdout or "")[-800:] + + roller = threading.Thread(target=run_roll) + roller.start() + roller.join() + roll_end = load.now() + load.stop() + images_after = sorted({inspect(cid, "{{.Image}}")[:19] for cid in api_ids()}) + rolling = load.summary(roll_mark, roll_end) + rolling["exit"] = holder.get("code") + rolling["stderr_tail"] = holder.get("err") + if holder.get("code") != 0: + raise SystemExit("rolling update failed: %s\n%s" % (holder.get("err"), holder.get("out"))) + + report = { + "date": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), + "platform": platform.platform(), + "cpu_count": os.cpu_count(), + "workload": "closed-loop POST, concurrency 4, client timeout 3s, no client retry", + "observed_instances": observed, + "parallel_idempotency": { + "requests": 8, + "unique_message_ids": len(parallel_ids), + "instances": parallel_instances, + }, + "baseline": baseline, + "failovers": failovers, + "images_before_roll": images_before, + "images_after_roll": images_after, + "rolling_under_load": rolling, + "container_limits": container_limits(), + "lb_timeouts": { + "check_interval_seconds": 1, + "unhealthy_after_failures": 1, + "check_timeout_seconds": 1, + "max_detection_seconds": 2, + "connect_timeout_seconds": 1, + "server_timeout_seconds": 8, + "client_timeout_seconds": 8, + "drain_seconds": 3, + "stop_grace_seconds": 10, + }, + } + dest = ROOT / "evidence" / "grade4.json" + dest.write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print(json.dumps({ + "observed_instances": observed, + "parallel_unique_messages": len(parallel_ids), + "parallel_instances": parallel_instances, + "baseline_rps": baseline["successful_rps"], + "baseline_errors": baseline["failed_requests"], + "failovers": [ + { + "target": item["target"], + "stop_s": item["stop_hook_seconds"], + "first_other_s": item["first_other_replica_success_seconds"], + "errors": item["window"]["failed_requests"], + "rps": item["window"]["successful_rps"], + "target_seen_after_hook": item["target_seen_after_hook_returned"], + "restore_s": item["restore_until_target_seen_seconds"], + } + for item in failovers + ], + "rolling_exit": rolling["exit"], + "rolling_errors": rolling["failed_requests"], + "rolling_rps": rolling["successful_rps"], + "images_changed": images_before != images_after, + "evidence": "evidence/grade4.json", + }, ensure_ascii=False, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..0631e15c --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Перезапуск API и хранилищ. Volumes не удаляются, схема и данные остаются. +docker compose --env-file .env -f compose.yaml restart api postgres valkey diff --git a/scripts/restore-api.sh b/scripts/restore-api.sh new file mode 100755 index 00000000..902ae572 --- /dev/null +++ b/scripts/restore-api.sh @@ -0,0 +1,8 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +replicas=$(sed -n 's/^API_REPLICAS=//p' .env | tr -d '\r') +if [ -z "${replicas}" ]; then + replicas=2 +fi +docker compose --env-file .env -f compose.yaml up -d --no-deps --scale "api=${replicas}" --no-recreate api diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..194f92f5 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,56 @@ +#!/bin/sh +# Поочерёдная замена API: сначала поднимается новая реплика, затем останавливается старая. +set -eu +cd "$(dirname "$0")/.." + +compose() { + docker compose --env-file .env -f compose.yaml "$@" +} + +bid=$(date +%s) +docker build --build-arg "BUILD_ID=${bid}" -t mtusi-messenger:lab3 . + +old=$(compose ps -q api) +if [ -z "$old" ]; then + echo "no running api replicas" >&2 + exit 1 +fi + +healthy_count() { + n=0 + for id in $(compose ps -q api); do + status=$(docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}none{{end}}' "$id") + if [ "$status" = "healthy" ]; then + n=$((n + 1)) + fi + done + printf '%s' "$n" +} + +wait_healthy() { + want=$1 + i=0 + while [ "$i" -lt 45 ]; do + n=$(healthy_count) + if [ "$n" -ge "$want" ]; then + return 0 + fi + i=$((i + 1)) + sleep 1 + done + echo "wanted ${want} healthy api, saw $(healthy_count)" >&2 + return 1 +} + +for cid in $old; do + echo "replacement before stop ${cid}" + compose up -d --no-deps --scale api=3 --no-recreate api + wait_healthy 3 + docker stop -t 8 "$cid" >/dev/null + docker rm "$cid" >/dev/null + compose up -d --no-deps --scale api=2 --no-recreate api + wait_healthy 2 +done + +echo "rolling update done" +compose ps api diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..1bfd2812 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,22 @@ +#!/bin/sh +set -eu +: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID is required}" +cd "$(dirname "$0")/.." + +found="" +for cid in $(docker compose --env-file .env -f compose.yaml ps -q api); do + host=$(docker inspect -f '{{.Config.Hostname}}' "$cid") + short=$(printf '%s' "$cid" | cut -c1-12) + if [ "$host" = "$TARGET_INSTANCE_ID" ] || [ "$short" = "$TARGET_INSTANCE_ID" ]; then + found=$cid + break + fi +done + +if [ -z "$found" ]; then + echo "API replica was not found" >&2 + exit 1 +fi + +# docker stop + restart: unless-stopped оставляет реплику выключенной. +docker stop -t 8 "$found" >/dev/null diff --git a/scripts/up.sh b/scripts/up.sh new file mode 100755 index 00000000..5d111aa2 --- /dev/null +++ b/scripts/up.sh @@ -0,0 +1,12 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +if [ ! -f .env ]; then + echo "Copy .env.example to .env" >&2 + exit 1 +fi +replicas=$(sed -n 's/^API_REPLICAS=//p' .env | tr -d '\r') +if [ -z "${replicas}" ]; then + replicas=2 +fi +docker compose --env-file .env -f compose.yaml up -d --build --scale "api=${replicas}" --remove-orphans diff --git a/src/db.py b/src/db.py new file mode 100644 index 00000000..c6e3ca37 --- /dev/null +++ b/src/db.py @@ -0,0 +1,451 @@ +"""PostgreSQL: пользователи, чаты, участники, сообщения, идемпотентность.""" +from __future__ import annotations + +import hashlib +import os +import time +import uuid +from contextlib import contextmanager +from datetime import datetime, timezone +from pathlib import Path + +import psycopg +from psycopg.errors import UniqueViolation +from psycopg_pool import ConnectionPool, PoolTimeout + +from errors import ApiError + +_pool: ConnectionPool | None = None + + +def migrations_dir() -> Path: + here = Path(__file__).resolve().parent + for candidate in (here / "migrations", here.parent / "migrations"): + if candidate.is_dir(): + return candidate + return here.parent / "migrations" + + +def database_url() -> str: + path = os.environ.get("DATABASE_URL_FILE", "").strip() + if path and Path(path).is_file(): + return Path(path).read_text(encoding="utf-8").strip() + return os.environ.get("DATABASE_URL", "").strip() + + +def idempotency_ttl() -> int: + raw = os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400") + try: + value = int(raw) + except ValueError: + return 86400 + return value if value >= 1 else 86400 + + +def init() -> None: + global _pool + url = database_url() + if not url: + raise RuntimeError("database is not configured") + _pool = ConnectionPool( + url, + min_size=0, + max_size=12, + timeout=3, + open=True, + kwargs={ + "connect_timeout": 3, + "autocommit": False, + "options": "-c statement_timeout=5000", + }, + ) + + +def migrate_with_retry() -> None: + last = None + for _ in range(30): + try: + migrate() + return + except Exception as exc: + last = exc + time.sleep(1) + raise RuntimeError("migrations failed") from last + + +def migrate() -> None: + url = database_url() + if not url: + raise RuntimeError("database is not configured") + with psycopg.connect(url, connect_timeout=3, autocommit=False) as conn: + conn.execute("SELECT pg_advisory_lock(%s)", (842021,)) + conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version text PRIMARY KEY, + applied_at timestamptz NOT NULL DEFAULT now() + ) + """ + ) + conn.commit() + applied = { + row[0] + for row in conn.execute("SELECT version FROM schema_migrations").fetchall() + } + for path in sorted(migrations_dir().glob("*.sql")): + if path.name in applied: + continue + sql = path.read_text(encoding="utf-8") + with conn.transaction(): + for statement in sql.split(";"): + if statement.strip(): + conn.execute(statement) + conn.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", + (path.name,), + ) + + +@contextmanager +def connection(): + if _pool is None: + raise ApiError(503, "unavailable", "База данных недоступна") + try: + with _pool.connection() as conn: + yield conn + except ApiError: + raise + except (PoolTimeout, psycopg.OperationalError, psycopg.InterfaceError) as exc: + raise ApiError(503, "unavailable", "База данных недоступна") from exc + + +def ping() -> bool: + try: + with connection() as conn: + conn.execute("SELECT 1") + return True + except ApiError: + return False + + +def close() -> None: + if _pool is not None: + _pool.close() + + +def user_json(row) -> dict: + return { + "id": str(row[0]), + "username": row[1], + "display_name": row[2], + "created_at": format_ts(row[3]), + } + + +def format_ts(value: datetime) -> str: + value = value.astimezone(timezone.utc) + return value.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" + + +def create_user(username: str, display_name: str, password_hash: str, created: datetime) -> dict: + uid = uuid.uuid4() + try: + with connection() as conn: + with conn.transaction(): + row = conn.execute( + """ + INSERT INTO users (id, username, display_name, password_hash, created_at) + VALUES (%s, %s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (uid, username, display_name, password_hash, created), + ).fetchone() + except UniqueViolation as exc: + raise ApiError(409, "conflict", "username занят") from exc + return user_json(row) + + +def user_for_login(username: str): + with connection() as conn: + return conn.execute( + """ + SELECT id, username, display_name, password_hash, created_at + FROM users + WHERE username = %s + """, + (username,), + ).fetchone() + + +def get_user(user_id: str) -> dict | None: + with connection() as conn: + row = conn.execute( + """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = %s + """, + (uuid.UUID(user_id),), + ).fetchone() + if row is None: + return None + return user_json(row) + + +def create_chat(title: str, member_ids: list[str], created: datetime) -> dict: + cid = uuid.uuid4() + members = [uuid.UUID(item) for item in member_ids] + with connection() as conn: + with conn.transaction(): + conn.execute( + "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)", + (cid, title, created), + ) + found = conn.execute( + "SELECT id FROM users WHERE id = ANY(%s::uuid[])", + (members,), + ).fetchall() + if {row[0] for row in found} != set(members): + raise ApiError(400, "invalid_request", "неизвестный участник") + for position, member in enumerate(members): + conn.execute( + """ + INSERT INTO chat_members (chat_id, user_id, position) + VALUES (%s, %s, %s) + """, + (cid, member, position), + ) + return { + "id": str(cid), + "title": title, + "member_ids": list(member_ids), + "created_at": format_ts(created), + } + + +def _chat_row(row) -> dict: + return { + "id": str(row[0]), + "title": row[1], + "created_at": format_ts(row[2]), + "member_ids": [str(item) for item in row[3]], + } + + +def get_chat(chat_id: str, user_id: str) -> dict: + with connection() as conn: + row = conn.execute( + """ + SELECT c.id, c.title, c.created_at, + array_agg(cm.user_id ORDER BY cm.position) + FROM chats c + JOIN chat_members mine + ON mine.chat_id = c.id AND mine.user_id = %s + JOIN chat_members cm ON cm.chat_id = c.id + WHERE c.id = %s + GROUP BY c.id + """, + (uuid.UUID(user_id), uuid.UUID(chat_id)), + ).fetchone() + if row is None: + raise ApiError(404, "not_found", "Чат не найден") + chat = _chat_row(row) + return { + "id": chat["id"], + "title": chat["title"], + "member_ids": chat["member_ids"], + "created_at": chat["created_at"], + } + + +def list_chats(user_id: str, limit: int, cursor) -> dict: + params: list = [uuid.UUID(user_id)] + where = "" + if cursor is not None: + created, chat_id = cursor + where = "WHERE (c.created_at, c.id) > (%s, %s)" + params.extend([created, uuid.UUID(chat_id)]) + params.append(limit + 1) + sql = f""" + SELECT c.id, c.title, c.created_at, + array_agg(cm.user_id ORDER BY cm.position) + FROM chats c + JOIN chat_members mine + ON mine.chat_id = c.id AND mine.user_id = %s + JOIN chat_members cm ON cm.chat_id = c.id + {where} + GROUP BY c.id + ORDER BY c.created_at, c.id + LIMIT %s + """ + with connection() as conn: + rows = conn.execute(sql, params).fetchall() + page = rows[:limit] + next_cursor = None + if len(rows) > limit and page: + last = page[-1] + next_cursor = (last[2], str(last[0])) + return { + "items": [ + { + "id": str(row[0]), + "title": row[1], + "member_ids": [str(item) for item in row[3]], + "created_at": format_ts(row[2]), + } + for row in page + ], + "next_cursor_parts": next_cursor, + } + + +def _lock_key(scope: str) -> int: + digest = hashlib.sha256(scope.encode("utf-8")).digest() + return int.from_bytes(digest[:8], "big", signed=True) + + +def _is_member(conn, chat_id: str, user_id: str) -> bool: + row = conn.execute( + """ + SELECT 1 FROM chat_members + WHERE chat_id = %s AND user_id = %s + """, + (uuid.UUID(chat_id), uuid.UUID(user_id)), + ).fetchone() + return row is not None + + +def _load_message(conn, message_id) -> dict: + row = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE id = %s + """, + (message_id,), + ).fetchone() + if row is None: + raise ApiError(500, "internal_error", "Внутренняя ошибка") + return message_json(row) + + +def create_message_idempotent( + chat_id: str, + sender_id: str, + text: str, + created: datetime, + method: str, + path: str, + idem_key: str, + request_hash: str, +) -> dict: + """Один ключ — одно сообщение, в том числе при гонке двух реплик. + + pg_advisory_xact_lock сериализует одинаковую область. + INSERT сообщения и INSERT ключа коммитятся вместе. + """ + scope = "%s|%s|%s|%s" % (sender_id, method, path, idem_key) + ttl = idempotency_ttl() + with connection() as conn: + with conn.transaction(): + conn.execute("SELECT pg_advisory_xact_lock(%s::bigint)", (_lock_key(scope),)) + existing = conn.execute( + """ + SELECT request_hash, message_id, created_at + FROM idempotency_keys + WHERE user_id = %s AND http_method = %s AND path = %s AND idem_key = %s + """, + (uuid.UUID(sender_id), method, path, idem_key), + ).fetchone() + if existing is not None: + age = conn.execute("SELECT now()").fetchone()[0] - existing[2] + if age.total_seconds() > ttl: + conn.execute( + """ + DELETE FROM idempotency_keys + WHERE user_id = %s AND http_method = %s AND path = %s AND idem_key = %s + """, + (uuid.UUID(sender_id), method, path, idem_key), + ) + existing = None + if existing is not None: + if existing[0] != request_hash: + raise ApiError(409, "conflict", "повторный ключ с другим сообщением") + if not _is_member(conn, chat_id, sender_id): + raise ApiError(404, "not_found", "Чат не найден") + return _load_message(conn, existing[1]) + if not _is_member(conn, chat_id, sender_id): + raise ApiError(404, "not_found", "Чат не найден") + mid = uuid.uuid4() + row = conn.execute( + """ + INSERT INTO messages (id, chat_id, sender_id, text, created_at) + VALUES (%s, %s, %s, %s, %s) + RETURNING id, chat_id, sender_id, text, created_at + """, + (mid, uuid.UUID(chat_id), uuid.UUID(sender_id), text, created), + ).fetchone() + conn.execute( + """ + INSERT INTO idempotency_keys ( + user_id, http_method, path, idem_key, request_hash, message_id, created_at + ) + VALUES (%s, %s, %s, %s, %s, %s, %s) + """, + (uuid.UUID(sender_id), method, path, idem_key, request_hash, mid, created), + ) + return message_json(row) + + +def list_messages(chat_id: str, user_id: str, limit: int, cursor) -> dict: + params: list = [uuid.UUID(chat_id), uuid.UUID(chat_id), uuid.UUID(user_id)] + cursor_sql = "" + if cursor is not None: + created, message_id = cursor + cursor_sql = "AND (m.created_at, m.id) > (%s, %s)" + params.extend([created, uuid.UUID(message_id)]) + params.append(limit + 1) + sql = f""" + SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at + FROM messages m + WHERE m.chat_id = %s + AND EXISTS ( + SELECT 1 FROM chat_members + WHERE chat_id = %s AND user_id = %s + ) + {cursor_sql} + ORDER BY m.created_at, m.id + LIMIT %s + """ + with connection() as conn: + rows = conn.execute(sql, params).fetchall() + if not rows: + with connection() as conn: + member = conn.execute( + """ + SELECT 1 FROM chat_members + WHERE chat_id = %s AND user_id = %s + """, + (uuid.UUID(chat_id), uuid.UUID(user_id)), + ).fetchone() + if member is None: + raise ApiError(404, "not_found", "Чат не найден") + page = rows[:limit] + next_cursor = None + if len(rows) > limit and page: + last = page[-1] + next_cursor = (last[4], str(last[0])) + return { + "items": [message_json(row) for row in page], + "next_cursor_parts": next_cursor, + } + + +def message_json(row) -> dict: + return { + "id": str(row[0]), + "chat_id": str(row[1]), + "sender_id": str(row[2]), + "text": row[3], + "created_at": format_ts(row[4]), + } diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..595498ed --- /dev/null +++ b/src/errors.py @@ -0,0 +1,8 @@ +"""Ошибки API. Текст не содержит SQL, паролей и токенов.""" + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str): + self.status = status + self.code = code + self.message = message diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..6ae5a613 --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,14 @@ +#!/usr/bin/env python3 +"""Однократные миграции. Реплики API этот файл не запускают.""" +import sys + +import db + + +def main() -> None: + db.migrate_with_retry() + sys.stderr.write("migrations applied\n") + + +if __name__ == "__main__": + main() diff --git a/src/passwords.py b/src/passwords.py new file mode 100644 index 00000000..305eb35c --- /dev/null +++ b/src/passwords.py @@ -0,0 +1,43 @@ +"""Пароли: scrypt из hashlib. Не bcrypt — он режет пароль на 72 байтах.""" +from __future__ import annotations + +import base64 +import hashlib +import hmac +import secrets + +N = 2**14 +R = 8 +P = 1 +DKLEN = 32 + + +def hash_password(password: str) -> str: + salt = secrets.token_bytes(16) + digest = hashlib.scrypt( + password.encode("utf-8"), salt=salt, n=N, r=R, p=P, dklen=DKLEN, + maxmem=64 * 1024 * 1024) + return "scrypt$%d$%d$%d$%s$%s" % ( + N, R, P, + base64.b64encode(salt).decode("ascii"), + base64.b64encode(digest).decode("ascii"), + ) + + +def verify_password(password: str, stored: str) -> bool: + try: + algo, n, r, p, salt_b64, digest_b64 = stored.split("$") + if algo != "scrypt": + return False + salt = base64.b64decode(salt_b64) + expected = base64.b64decode(digest_b64) + actual = hashlib.scrypt( + password.encode("utf-8"), salt=salt, n=int(n), r=int(r), p=int(p), + dklen=len(expected), maxmem=64 * 1024 * 1024) + except (ValueError, TypeError): + return False + return hmac.compare_digest(actual, expected) + + +# Одинаковая стоимость проверки, когда пользователя нет. +DUMMY_HASH = hash_password("dummy-password-not-used") diff --git a/src/server.py b/src/server.py new file mode 100644 index 00000000..0c53dff9 --- /dev/null +++ b/src/server.py @@ -0,0 +1,543 @@ +#!/usr/bin/env python3 +"""Messenger lab3. Общие PostgreSQL и Valkey, несколько реплик за Traefik.""" +from __future__ import annotations + +import base64 +import hashlib +import json +import os +import re +import secrets +import signal +import socket +import socketserver +import sys +import threading +import time +import uuid +from datetime import datetime, timedelta, timezone +from http.server import BaseHTTPRequestHandler +from urllib.parse import parse_qs, urlparse + +import db +import passwords +import sessions +from errors import ApiError + +APP_HOST = os.environ.get("APP_HOST", "0.0.0.0") +APP_PORT = int(os.environ.get("APP_PORT", "8080")) +APP_ENV = os.environ.get("APP_ENV", "lab") +INSTANCE_ID = os.environ.get("INSTANCE_ID", "").strip() or socket.gethostname() + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}\Z") +UUID_RE = re.compile( + r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-" + r"[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\Z") +TIMESTAMP_RE = re.compile( + r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,6})?Z\Z") +IDEMPOTENCY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}\Z") +MAX_BODY = 16 * 1024 * 1024 + +_draining = threading.Event() +_inflight = 0 +_inflight_lock = threading.Lock() + + +def drain_seconds() -> float: + raw = os.environ.get("DRAIN_SECONDS", "3") + try: + value = float(raw) + except ValueError: + return 3.0 + if value < 0: + return 0.0 + if value > 6: + return 6.0 + return value + + +def now_utc() -> datetime: + current = datetime.now(timezone.utc) + return current.replace(microsecond=(current.microsecond // 1000) * 1000) + + +def is_blank(value: str) -> bool: + return value.strip() == "" + + +def require_object(body): + if not isinstance(body, dict): + raise ApiError(400, "invalid_request", "Тело должно быть JSON-объектом") + + +def reject_extra(body: dict, allowed: set): + extra = set(body) - allowed + if extra: + raise ApiError(400, "invalid_request", + "Лишние поля: " + ", ".join(sorted(extra))) + + +def parse_uuid(value, field: str) -> str: + if not isinstance(value, str) or not UUID_RE.match(value): + raise ApiError(400, "invalid_request", f"Некорректный UUID: {field}") + return value.lower() + + +def parse_display_name(value) -> str: + if not isinstance(value, str): + raise ApiError(400, "invalid_request", "display_name должен быть строкой") + if not (1 <= len(value) <= 100): + raise ApiError(400, "invalid_request", "display_name: 1..100 code points") + if is_blank(value): + raise ApiError(400, "invalid_request", "display_name не может быть пустым") + return value + + +def parse_username(value) -> str: + if not isinstance(value, str) or not USERNAME_RE.match(value): + raise ApiError(400, "invalid_request", "username: ^[a-z0-9_]{3,32}$") + return value + + +def parse_password(value) -> str: + if not isinstance(value, str): + raise ApiError(400, "invalid_request", "password должен быть строкой") + if not (12 <= len(value) <= 128): + raise ApiError(400, "invalid_request", "password: 12..128 code points") + if is_blank(value): + raise ApiError(400, "invalid_request", "password не может быть пустым") + return value + + +def parse_title(value) -> str: + if not isinstance(value, str): + raise ApiError(400, "invalid_request", "title должен быть строкой") + if not (1 <= len(value) <= 100): + raise ApiError(400, "invalid_request", "title: 1..100 code points") + if is_blank(value): + raise ApiError(400, "invalid_request", "title не может быть пустым") + return value + + +def parse_text(value) -> str: + if not isinstance(value, str): + raise ApiError(400, "invalid_request", "text должен быть строкой") + if not (1 <= len(value) <= 4000): + raise ApiError(400, "invalid_request", "text: 1..4000 code points") + if is_blank(value): + raise ApiError(400, "invalid_request", "text не может быть пустым") + return value + + +def parse_member_ids(value) -> list: + if not isinstance(value, list): + raise ApiError(400, "invalid_request", "member_ids должен быть массивом") + if not (1 <= len(value) <= 100): + raise ApiError(400, "invalid_request", "member_ids: 1..100") + seen = set() + result = [] + for item in value: + uid = parse_uuid(item, "member_ids[]") + if uid in seen: + raise ApiError(400, "invalid_request", "member_ids содержит дубликаты") + seen.add(uid) + result.append(uid) + return result + + +def parse_limit(raw, default=50) -> int: + if raw is None: + return default + if isinstance(raw, str) and raw.strip() == "": + raise ApiError(400, "invalid_request", "limit должен быть целым") + try: + value = int(raw) + except (TypeError, ValueError): + raise ApiError(400, "invalid_request", "limit должен быть целым") + if not (1 <= value <= 100): + raise ApiError(400, "invalid_request", "limit: 1..100") + return value + + +def parse_optional_cursor(raw): + if raw is None: + return None + if not isinstance(raw, str) or raw.strip() == "": + raise ApiError(400, "invalid_request", "Некорректный cursor") + return raw + + +def parse_cursor_timestamp(value: str) -> datetime: + if not isinstance(value, str) or not TIMESTAMP_RE.match(value): + raise ApiError(400, "invalid_request", "Некорректный cursor") + try: + parsed = datetime.fromisoformat(value.replace("Z", "+00:00")) + except ValueError as exc: + raise ApiError(400, "invalid_request", "Некорректный cursor") from exc + return parsed + + +def parse_idempotency_key(headers) -> str: + raw = headers.get("Idempotency-Key") + if not isinstance(raw, str) or not IDEMPOTENCY_RE.match(raw): + raise ApiError(400, "invalid_request", "Некорректный Idempotency-Key") + return raw + + +def canonical_hash(text: str) -> str: + # Порядок ключей не важен. Отсутствующий attachment_ids равен []. + # В lab3 схема ещё не принимает attachment_ids: лишнее поле — 400 до хеша. + payload = {"attachment_ids": [], "text": text} + raw = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + return hashlib.sha256(raw.encode("utf-8")).hexdigest() + + +def challenge_for(path: str) -> str: + if path == "/api/v1/auth/sessions": + return 'Basic realm="messenger", charset="UTF-8"' + return 'Bearer realm="messenger"' + + +def bearer_token(headers) -> str: + auth = headers.get("Authorization") or "" + parts = auth.split(None, 1) + if len(parts) != 2 or parts[0].lower() != "bearer" or not parts[1].strip(): + raise ApiError(401, "unauthorized", "Требуется Bearer") + return parts[1].strip() + + +def current_user(headers) -> dict: + token = bearer_token(headers) + user = db.get_user(sessions.user_id(token)) + if user is None: + raise ApiError(401, "unauthorized", "Сессия недействительна") + return user + + +def basic_credentials(headers) -> tuple[str, str]: + auth = headers.get("Authorization") or "" + parts = auth.split(None, 1) + if len(parts) != 2 or parts[0].lower() != "basic" or not parts[1].strip(): + raise ApiError(401, "unauthorized", "Требуется Basic") + try: + decoded = base64.b64decode(parts[1].strip(), validate=True).decode("utf-8") + except (ValueError, UnicodeDecodeError) as exc: + raise ApiError(401, "unauthorized", "Неверные учётные данные") from exc + if ":" not in decoded: + raise ApiError(401, "unauthorized", "Неверные учётные данные") + username, password = decoded.split(":", 1) + return username, password + + +def encode_cursor(chat_id: str, created_at: str, msg_id: str) -> str: + raw = f"{chat_id}|{created_at}|{msg_id}".encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(cursor: str, chat_id: str): + pad = "=" * (-len(cursor) % 4) + try: + raw = base64.urlsafe_b64decode(cursor + pad).decode("utf-8") + except Exception as exc: + raise ApiError(400, "invalid_request", "Некорректный cursor") from exc + parts = raw.split("|") + if len(parts) != 3: + raise ApiError(400, "invalid_request", "Некорректный cursor") + c_chat, c_created, c_id = parts + if not UUID_RE.match(c_chat): + raise ApiError(400, "invalid_request", "Некорректный cursor") + if c_chat.lower() != chat_id: + raise ApiError(400, "invalid_request", "cursor от другого чата") + return parse_cursor_timestamp(c_created), parse_uuid(c_id, "cursor") + + +def encode_chat_cursor(created_at: str, chat_id: str) -> str: + raw = f"chat|{created_at}|{chat_id}".encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_chat_cursor(cursor: str): + pad = "=" * (-len(cursor) % 4) + try: + raw = base64.urlsafe_b64decode(cursor + pad).decode("utf-8") + except Exception as exc: + raise ApiError(400, "invalid_request", "Некорректный cursor") from exc + parts = raw.split("|") + if len(parts) != 3 or parts[0] != "chat": + raise ApiError(400, "invalid_request", "Некорректный cursor") + return parse_cursor_timestamp(parts[1]), parse_uuid(parts[2], "cursor") + + +def create_user(body) -> dict: + require_object(body) + reject_extra(body, {"username", "display_name", "password"}) + username = parse_username(body.get("username")) + display_name = parse_display_name(body.get("display_name")) + password = parse_password(body.get("password")) + return db.create_user(username, display_name, passwords.hash_password(password), now_utc()) + + +def create_session(headers) -> dict: + username, password = basic_credentials(headers) + row = None + try: + row = db.user_for_login(username) + except ApiError: + raise + stored = row[3] if row is not None else passwords.DUMMY_HASH + password_ok = passwords.verify_password(password, stored) + if row is None or not password_ok: + raise ApiError(401, "unauthorized", "Неверные учётные данные") + token = secrets.token_urlsafe(32) + ttl = sessions.session_ttl() + expires = now_utc() + timedelta(seconds=ttl) + sessions.create(token, str(row[0]), ttl) + return { + "token": token, + "token_type": "Bearer", + "expires_at": db.format_ts(expires), + "user": db.user_json((row[0], row[1], row[2], row[4])), + } + + +def logout(headers) -> None: + token = bearer_token(headers) + sessions.user_id(token) + sessions.revoke(token) + + +def create_chat(body, actor: dict) -> dict: + require_object(body) + reject_extra(body, {"title", "member_ids"}) + title = parse_title(body.get("title")) + member_ids = parse_member_ids(body.get("member_ids")) + if actor["id"] not in member_ids: + raise ApiError(400, "invalid_request", "вызывающий должен быть в member_ids") + return db.create_chat(title, member_ids, now_utc()) + + +def list_chats(actor: dict, limit: int, cursor) -> dict: + decoded = decode_chat_cursor(cursor) if cursor else None + page = db.list_chats(actor["id"], limit, decoded) + next_cursor = None + if page["next_cursor_parts"] is not None: + created, chat_id = page["next_cursor_parts"] + next_cursor = encode_chat_cursor(db.format_ts(created), chat_id) + return {"items": page["items"], "next_cursor": next_cursor} + + +def create_message(chat_id: str, body, actor: dict, idem_key: str) -> dict: + cid = parse_uuid(chat_id, "chat_id") + require_object(body) + reject_extra(body, {"text"}) + text = parse_text(body.get("text")) + path = "/api/v1/chats/%s/messages" % cid + return db.create_message_idempotent( + cid, actor["id"], text, now_utc(), "POST", path, idem_key, canonical_hash(text), + ) + + +def list_messages(chat_id: str, actor: dict, limit: int, cursor) -> dict: + cid = parse_uuid(chat_id, "chat_id") + decoded = decode_cursor(cursor, cid) if cursor else None + page = db.list_messages(cid, actor["id"], limit, decoded) + next_cursor = None + if page["next_cursor_parts"] is not None: + created, message_id = page["next_cursor_parts"] + next_cursor = encode_cursor(cid, db.format_ts(created), message_id) + return {"items": page["items"], "next_cursor": next_cursor} + + +class FastThreadingHTTPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): + daemon_threads = True + block_on_close = False + allow_reuse_address = True + request_queue_size = 256 + + +class Handler(BaseHTTPRequestHandler): + server_version = "mtusi-messenger/3.0" + protocol_version = "HTTP/1.0" + + def log_message(self, fmt, *args): + return + + def _request_id(self) -> str: + return self.headers.get("X-Request-Id") or str(uuid.uuid4()) + + def _send_json(self, status: int, payload, request_id: str, extra_headers=None): + body = b"" + if status != 204: + body = json.dumps(payload, ensure_ascii=False).encode("utf-8") + self.send_response(status) + if status != 204: + self.send_header("Content-Type", "application/json; charset=utf-8") + self.send_header("Content-Length", str(len(body))) + self.send_header("X-Request-Id", request_id) + self.send_header("X-Instance-Id", INSTANCE_ID) + self.send_header("Connection", "close") + for key, value in (extra_headers or {}).items(): + self.send_header(key, value) + self.end_headers() + if body: + self.wfile.write(body) + + def _send_error(self, status: int, code: str, message: str, request_id: str, extra_headers=None): + self._send_json( + status, + {"error": {"code": code, "message": message, "request_id": request_id}}, + request_id, + extra_headers, + ) + + def _read_body(self): + length = self.headers.get("Content-Length") + if not length: + return None + try: + size = int(length) + except ValueError as exc: + raise ApiError(400, "invalid_request", "Некорректный Content-Length") from exc + if size > MAX_BODY: + raise ApiError(413, "payload_too_large", "Тело слишком большое") + raw = self.rfile.read(size) + ctype = (self.headers.get("Content-Type") or "").split(";")[0].strip() + if ctype and ctype != "application/json": + raise ApiError(415, "unsupported_media_type", "Ожидается application/json") + if not raw: + raise ApiError(400, "invalid_request", "Пустое тело") + try: + return json.loads(raw.decode("utf-8")) + except (UnicodeDecodeError, json.JSONDecodeError) as exc: + raise ApiError(400, "invalid_request", "Malformed JSON") from exc + + def do_GET(self): + self._dispatch("GET") + + def do_POST(self): + self._dispatch("POST") + + def do_DELETE(self): + self._dispatch("DELETE") + + def _dispatch(self, method: str): + global _inflight + with _inflight_lock: + _inflight += 1 + rid = self._request_id() + parsed = urlparse(self.path) + path = parsed.path.rstrip("/") or "/" + query = parse_qs(parsed.query, keep_blank_values=True) + try: + self._route(method, path, query, rid) + except ApiError as exc: + headers = {} + if exc.status == 401: + headers["WWW-Authenticate"] = challenge_for(path) + self._send_error(exc.status, exc.code, exc.message, rid, headers) + except BrokenPipeError: + pass + except Exception: + sys.stderr.write("internal error on %s %s\n" % (method, path)) + self._send_error(500, "internal_error", "Внутренняя ошибка", rid) + finally: + with _inflight_lock: + _inflight -= 1 + + def _route(self, method: str, path: str, query: dict, rid: str): + if method == "GET" and path == "/health/live": + return self._send_json(200, {"status": "ok"}, rid) + if method == "GET" and path == "/health/ready": + if _draining.is_set(): + raise ApiError(503, "unavailable", "Реплика останавливается") + if db.ping() and sessions.ping(): + return self._send_json(200, {"status": "ok"}, rid) + raise ApiError(503, "unavailable", "Зависимость недоступна") + if _draining.is_set(): + raise ApiError(503, "unavailable", "Реплика останавливается") + + if method == "POST" and path == "/api/v1/users": + return self._send_json(201, create_user(self._read_body()), rid) + if method == "POST" and path == "/api/v1/auth/sessions": + return self._send_json(201, create_session(self.headers), rid) + if method == "DELETE" and path == "/api/v1/auth/sessions/current": + logout(self.headers) + return self._send_json(204, None, rid) + if method == "GET" and path == "/api/v1/users/me": + return self._send_json(200, current_user(self.headers), rid) + + if method == "POST" and path == "/api/v1/chats": + actor = current_user(self.headers) + return self._send_json(201, create_chat(self._read_body(), actor), rid) + if method == "GET" and path == "/api/v1/chats": + actor = current_user(self.headers) + limit = parse_limit(query.get("limit", [None])[0]) + cursor = parse_optional_cursor(query.get("cursor", [None])[0]) + return self._send_json(200, list_chats(actor, limit, cursor), rid) + + match = re.fullmatch(r"/api/v1/chats/([^/]+)", path) + if match and method == "GET": + actor = current_user(self.headers) + return self._send_json(200, db.get_chat(parse_uuid(match.group(1), "chat_id"), actor["id"]), rid) + + match = re.fullmatch(r"/api/v1/chats/([^/]+)/messages", path) + if match and method == "POST": + actor = current_user(self.headers) + idem_key = parse_idempotency_key(self.headers) + body = create_message(match.group(1), self._read_body(), actor, idem_key) + return self._send_json(201, body, rid) + if match and method == "GET": + actor = current_user(self.headers) + limit = parse_limit(query.get("limit", [None])[0]) + cursor = parse_optional_cursor(query.get("cursor", [None])[0]) + return self._send_json(200, list_messages(match.group(1), actor, limit, cursor), rid) + + raise ApiError(404, "not_found", "Маршрут не найден") + + +def _inflight_now() -> int: + with _inflight_lock: + return _inflight + + +def main(): + try: + db.init() + except Exception: + sys.stderr.write("database is not configured\n") + try: + sessions.init() + except Exception: + sys.stderr.write("session store is not configured\n") + + server = FastThreadingHTTPServer((APP_HOST, APP_PORT), Handler) + + def drain_and_stop(): + time.sleep(drain_seconds()) + deadline = time.monotonic() + 2 + while time.monotonic() < deadline and _inflight_now() > 0: + time.sleep(0.05) + server.shutdown() + + def shutdown(signum, frame): + if _draining.is_set(): + return + _draining.set() + sys.stderr.write("SIGTERM instance=%s stop accepting\n" % INSTANCE_ID) + threading.Thread(target=drain_and_stop, daemon=True).start() + + signal.signal(signal.SIGTERM, shutdown) + signal.signal(signal.SIGINT, shutdown) + sys.stderr.write( + "listening on %s:%s env=%s instance=%s\n" % (APP_HOST, APP_PORT, APP_ENV, INSTANCE_ID) + ) + try: + server.serve_forever(poll_interval=0.1) + finally: + server.server_close() + db.close() + sys.stderr.write("stopped instance=%s\n" % INSTANCE_ID) + + +if __name__ == "__main__": + main() diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 00000000..6e7bc918 --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,85 @@ +"""Сессии в Valkey. Ключ — SHA-256 токена, TTL равен остатку жизни сессии. + +Источник истины сессий — общий Valkey, не память процесса API. +AOF и volume сохраняют ключ при перезапуске хранилища. +""" +from __future__ import annotations + +import hashlib +import os +from pathlib import Path + +import redis + +from errors import ApiError + +_client: redis.Redis | None = None + + +def session_ttl() -> int: + raw = os.environ.get("SESSION_TTL_SECONDS", "3600") + try: + value = int(raw) + except ValueError: + return 3600 + return value if value >= 1 else 1 + + +def redis_url() -> str: + path = os.environ.get("CACHE_URL_FILE", "").strip() + if path and Path(path).is_file(): + return Path(path).read_text(encoding="utf-8").strip() + return os.environ.get("REDIS_URL", "").strip() + + +def init() -> None: + global _client + url = redis_url() + if not url: + _client = None + return + _client = redis.Redis.from_url( + url, socket_connect_timeout=0.5, socket_timeout=0.5, + decode_responses=True) + + +def _key(token: str) -> str: + digest = hashlib.sha256(token.encode("utf-8")).hexdigest() + return "session:" + digest + + +def _require() -> redis.Redis: + if _client is None: + raise ApiError(503, "unavailable", "Хранилище сессий недоступно") + return _client + + +def ping() -> bool: + try: + return bool(_require().ping()) + except (ApiError, redis.RedisError): + return False + + +def create(token: str, user_id: str, ttl: int) -> None: + try: + _require().set(_key(token), user_id, ex=ttl) + except (ApiError, redis.RedisError) as exc: + raise ApiError(503, "unavailable", "Хранилище сессий недоступно") from exc + + +def user_id(token: str) -> str: + try: + value = _require().get(_key(token)) + except (ApiError, redis.RedisError) as exc: + raise ApiError(503, "unavailable", "Хранилище сессий недоступно") from exc + if not value: + raise ApiError(401, "unauthorized", "Сессия недействительна") + return value + + +def revoke(token: str) -> None: + try: + _require().delete(_key(token)) + except (ApiError, redis.RedisError) as exc: + raise ApiError(503, "unavailable", "Хранилище сессий недоступно") from exc diff --git a/tests/student_level4.py b/tests/student_level4.py new file mode 100644 index 00000000..e3e6b4f0 --- /dev/null +++ b/tests/student_level4.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +"""Проверки уровня 4, которые не входят в публичный smoke: разнос реплик и гонка ключа.""" +import threading +import uuid +from concurrent.futures import ThreadPoolExecutor + +from client import Client, arguments, check, run + + +def instances_of(c, actor, n=24): + seen = [] + for _ in range(n): + seen.append(c.call("GET", "/api/v1/users/me", actor=actor, schema="User")["headers"]["X-Instance-Id"]) + return seen + + +def main(): + args = arguments("Lab3 level-4: two instances and concurrent idempotency") + c = Client(args.base_url, args.ca_file) + alice, bob, eve, chat = c.bootstrap() + seen = instances_of(c, alice) + uniq = sorted(set(seen)) + check(len(uniq) >= 2, "LB did not spread one session across two API replicas: %s" % uniq) + + key = "same-" + uuid.uuid4().hex + text = "общий ключ " + key + workers = 8 + barrier = threading.Barrier(workers) + + def once(_n): + local = Client(args.base_url, args.ca_file, timeout=10) + barrier.wait() + return local.message(alice, chat, text, key=key) + + with ThreadPoolExecutor(max_workers=workers) as pool: + results = list(pool.map(once, range(workers))) + ids = {item["json"]["id"] for item in results} + bodies = {item["json"]["text"] for item in results} + served = sorted({item["headers"]["X-Instance-Id"] for item in results}) + check(len(ids) == 1, "concurrent idempotency created more than one message") + check(bodies == {text}, "concurrent replay changed text") + check(len(served) >= 2, "concurrent posts did not hit two replicas: %s" % served) + replay = c.message(alice, chat, text, key=key)["json"] + check(replay == results[0]["json"], "sequential replay differs") + c.call( + "POST", + "/api/v1/chats/" + chat["id"] + "/messages", + 409, + actor=alice, + body={"text": "другой текст " + key}, + headers={"Idempotency-Key": key}, + ) + shared = "shared-" + uuid.uuid4().hex + left = c.message(alice, chat, "алиса " + shared, key=shared)["json"] + right = c.message(bob, chat, "боб " + shared, key=shared)["json"] + check(left["id"] != right["id"], "same key must be independent per user") + page = c.call("GET", "/api/v1/chats/" + chat["id"] + "/messages?limit=100", actor=bob, schema="MessagePage")["json"] + copies = [item for item in page["items"] if item["text"] == text] + check(len(copies) == 1, "history contains duplicate of the idempotent message") + print("PASS: level4 spread=%s parallel_instances=%s" % (",".join(uniq), ",".join(served))) + + +if __name__ == "__main__": + run(main)