ЛР 3 — БВТ2303 — Самсонов — на 4 #36

Closed
Samsonov_BVT2303 wants to merge 1 commits from Samsonov_BVT2303/mtusi2026lab3:main into main
28 changed files with 2335 additions and 37 deletions
+10 -9
View File
@@ -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 приложение тоже умеет читать, если файл есть.
+5
View File
@@ -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
+14 -14
View File
@@ -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 содержит инструкцию именно моего решения.
+32
View File
@@ -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"]
+143 -14
View File
@@ -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 <url-этого-форка>
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.
+154
View File
@@ -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:
+18
View File
@@ -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.
+169
View File
@@ -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
}
}
+14
View File
@@ -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
+18
View File
@@ -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 повторно данные не заливает.
+8
View File
@@ -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.
+44
View File
@@ -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
+49
View File
@@ -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);
+18
View File
@@ -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);
+3
View File
@@ -0,0 +1,3 @@
psycopg[binary]==3.2.3
psycopg-pool==3.2.3
redis==5.1.1
+325
View File
@@ -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()
+5
View File
@@ -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
+8
View File
@@ -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
+56
View File
@@ -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
+22
View File
@@ -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
Executable
+12
View File
@@ -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
+451
View File
@@ -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]),
}
+8
View File
@@ -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
+14
View File
@@ -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()
+43
View File
@@ -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")
+543
View File
@@ -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()
+85
View File
@@ -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
+64
View File
@@ -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)