ЛР 3 — БПИ2303 — Щербаков — на 3 #148

Closed
Exodia wants to merge 2 commits from Exodia/mtusi2026lab3:solution/BPI2303-Scherbakov into main
31 changed files with 1511 additions and 39 deletions
+4 -10
View File
@@ -1,13 +1,7 @@
# 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
# Public LB port on localhost. Internal APIs always use 8080.
APP_PORT=8080
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
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
# scripts/bootstrap.py generates .env and secrets/ locally.
# Sessions and message keys are in PostgreSQL; key TTL is fixed at 24 hours.
# Two explicit services api1/api2; no unused replica-count setting.
+5
View File
@@ -0,0 +1,5 @@
*.sh text eol=lf
*.cmd text eol=crlf
*.py text eol=lf
*.sql text eol=lf
*.yaml text eol=lf
+61 -15
View File
@@ -1,18 +1,64 @@
## Лабораторная 3
## ЛР 3 — БПИ2303 — Щербаков — на 3
Автор / группа: TODO
Целевая оценка (3/4/5): TODO
Трек 5, если заявлен: TODO
Автор / группа: Щербаков Марк Игоревич / БПИ2303.
Целевая оценка (3/4/5): **3**.
Трек 5, если заявлен: не заявляется.
Что реализовано и что перенесено: TODO
Команды запуска из чистого clone: TODO
Результаты проверок и ссылка на REPORT.md: TODO
Ограничения / известные ошибки: TODO
Источники и использование ИИ: TODO
Что реализовано и что перенесено: из собственной lab2 перенесены Python API,
PostgreSQL, постоянные сессии, миграции, пагинация и собственные тесты.
Добавлены две API-реплики за HAProxy, X-Instance-Id, общая идемпотентность
сообщений с TTL 24 часа, отдельный migration job и scripts остановки/перезапуска.
Сообщение и ключ сохраняются одной транзакцией, повтор через другую реплику
возвращает прежний результат без создания дубля.
- [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [ ] Контракт и публичные тесты не ослаблены.
- [ ] make check и make test выполнены; приложен реальный вывод.
- [ ] Сценарии отказов/безопасности своего уровня воспроизведены.
- [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
Команды запуска из чистого clone, из корня репозитория:
```sh
python scripts/bootstrap.py
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
python scripts/check_contract.py
python tests/smoke.py --base-url http://localhost:8080
```
На проверенном Windows-хосте порт 8080 недоступен: в `.env` установлен
`APP_PORT=18083`, адрес тестов — `http://127.0.0.1:18083`.
Для воспроизведения всех сценариев:
```sh
# Linux/macOS: предварительно chmod +x scripts/restart.sh scripts/stop-one.sh
python scripts/verify.py --base-url http://127.0.0.1:18083 --output evidence/grade3-checks.txt
```
Результаты проверок: публичный smoke, 14 собственных тестов, persistence,
повтор миграций и failover каждой из двух API-реплик прошли. Конкурентные
12 повторов одного ключа через две реплики создали одно сообщение.
При остановке api1/api2 первое успешное POST после завершения hook наблюдалось
через 3,359/3,016 с от его запуска, подтверждённые данные и сессии сохранены.
Переходные ошибки учтены в протоколе; после проверки обе реплики восстановлены.
Полная валидация OpenAPI также прошла.
Инструкция и разбор: [REPORT.md](../REPORT.md).
Протокол: [grade3-checks.txt](../evidence/grade3-checks.txt).
Валидация контракта: [contracts.txt](../evidence/contracts.txt).
На Windows Make отсутствует: выполнены эквивалентные Python-команды его целей.
Linux hooks и Make включены в CI; удалённый CI не запускался.
Ограничения / известные ошибки: один Docker-host, один LB и PostgreSQL —
точки единого отказа. Проверен отказ одной API при доступной БД, полный
рестарт проверен на сохранность данных. Нет HA БД, backup, защиты от потери
volume/host, автоматического масштабирования и rolling update. Требуется
очистка старых сессий/ключей. HTTP предназначен для локальных учебных данных.
Уровни 4/5 не заявляются.
Источники и использование ИИ: собственные lab1/lab2, контракт текущей работы,
официальная документация HAProxy, Docker Compose, PostgreSQL и psycopg
(ссылки в REPORT.md). OpenAI Codex использован для изучения материалов,
реализации, тестов и отчёта.
- [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами.
- [x] Контракт и публичные тесты не ослаблены.
- [x] Эквивалентные Python-команды make check и make test выполнены; приложен реальный вывод.
- [x] Сценарии отказов своего уровня воспроизведены.
- [x] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens.
- [x] README задания сохранён, REPORT.md содержит инструкцию именно моего решения.
+24
View File
@@ -0,0 +1,24 @@
name: Application
on: [push, pull_request]
permissions:
contents: read
jobs:
application:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: python scripts/bootstrap.py
- run: chmod +x scripts/restart.sh scripts/stop-one.sh
- run: docker compose --env-file .env up -d --build --wait
- run: make check test PYTHON=python
- run: python scripts/verify.py --output evidence/grade3-checks.txt
- if: always()
uses: actions/upload-artifact@v4
with:
name: grade3-evidence
path: evidence/grade3-checks.txt
- if: always()
run: docker compose down
+14
View File
@@ -0,0 +1,14 @@
FROM python:3.12.12-slim-bookworm
ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 APP_HOST=0.0.0.0 APP_PORT=8080
WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt \
&& groupadd --gid 10001 messenger \
&& useradd --uid 10001 --gid messenger --no-create-home --shell /usr/sbin/nologin messenger
COPY --chown=10001:10001 src/ ./src/
COPY --chown=10001:10001 migrations/ ./migrations/
USER 10001:10001
EXPOSE 8080
STOPSIGNAL SIGTERM
HEALTHCHECK --interval=5s --timeout=5s --start-period=10s --retries=5 CMD ["python", "-m", "src.healthcheck"]
CMD ["python", "-m", "src.server"]
+208 -14
View File
@@ -1,37 +1,231 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор: Щербаков Марк Игоревич, БПИ2303.
- Целевая оценка: **«3»**. Уровни 4/5 не заявляются.
- Ветка решения: `solution/BPI2303-Scherbakov`. PR создаётся отдельно после push.
- Помощь ИИ: OpenAI Codex — изучение предыдущих работ, реализация, проверки и отчёт.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Docker с Linux-контейнерами, Compose v2 и Python 3.12 для проверок.
Из корня этой лабораторной, без зависимости от соседних каталогов:
```sh
python scripts/bootstrap.py
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
python scripts/check_contract.py
python tests/smoke.py --base-url http://localhost:8080
```
Bootstrap создаёт `.env` из `.env.example`, случайный пароль учебной БД
в `secrets/postgres_password` и DSN в `secrets/database_url`. Существующие
файлы сохраняются. Секреты исключены из Git и Docker build context.
Миграции автоматически выполняет сервис `migrate` после готовности PostgreSQL,
до запуска API. Его завершение `Exited (0)` — норма.
`APP_PORT` в `.env` задаёт публичный порт LB. На проверенном Windows-хосте
привязка 8080 была запрещена, поэтому использован **APP_PORT=18083**.
Для повторения результатов установите эту строку перед запуском и используйте
`http://127.0.0.1:18083` в тестах. При HTTP proxy добавьте localhost и 127.0.0.1
в NO_PROXY.
Полная проверка с реальными перезапусками и остановкой реплик:
```sh
python scripts/verify.py --base-url http://127.0.0.1:18083 --output evidence/grade3-checks.txt
```
Windows использует hooks `restart.cmd` и `stop-one.cmd`. Linux/macOS требуют:
```sh
chmod +x scripts/restart.sh scripts/stop-one.sh
make check test PYTHON=python BASE_URL=http://localhost:18083
make test-persistence PYTHON=python BASE_URL=http://localhost:18083 ACTION_SCRIPT=scripts/restart.sh
make test-failover PYTHON=python BASE_URL=http://localhost:18083 ACTION_SCRIPT=scripts/stop-one.sh
# После отдельного failover восстановить реплику:
docker compose --env-file .env up -d --wait api1 api2
```
Без Make на Windows, эквивалентные команды публичных сценариев:
```powershell
python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:18083
python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:18083
docker compose --env-file .env up -d --wait api1 api2
$env:BASE_URL = 'http://127.0.0.1:18083'
python -m unittest discover -s student-tests -v
```
Полная валидация спецификации, отдельно от HTTP-проверок:
```powershell
python -m venv .venv
.\.venv\Scripts\python.exe -m pip install -r requirements-dev.txt
.\.venv\Scripts\python.exe scripts/validate_openapi.py
```
Linux: `.venv/bin/python` вместо `.venv\Scripts\python.exe`.
Штатная остановка: `docker compose down`, именованный volume сохраняется.
**Только для намеренного удаления всех учебных данных:** `docker compose down -v`.
В hooks и проверках эта команда не используется.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```mermaid
flowchart LR
C[Клиенты] --> LB[HAProxy / localhost:APP_PORT]
LB --> A1[api1 / Python]
LB --> A2[api2 / Python]
A1 --> PG[(Общий PostgreSQL)]
A2 --> PG
M[Одноразовый migrate] --> PG
PG --> V[postgres_data volume]
```
Из lab2 перенесены HTTP API, scrypt, сессии, HMAC cursor, pool, первая
миграция, Dockerfile и собственные тесты. Lab2 уже сохраняла сессии
в PostgreSQL, поэтому Redis/Valkey для уровня 3 не требуется. Из lab1
унаследованы HTTP-транспорт, валидация, пагинация и обработка SIGTERM.
Папки lab1/lab2 не изменялись; контракт и публичные tests lab3 сохранены.
Добавлены HAProxy, две API-реплики, отдельный migration job, X-Instance-Id,
таблица ключей сообщений и action scripts. В памяти API нет пользователей,
чатов, истории, сессий или результатов POST. Пул соединений, копия общего
ключа cursor и флаг остановки локальны; источник истины — PostgreSQL.
| Роль | Service / версия | Готовность | Состояние и доступ |
| --- | --- | --- | --- |
| Балансировщик | lb / haproxy:3.0.11-alpine | Активные HTTP-проверки backend | Единственный публичный порт, только localhost |
| API 1 и 2 | api1, api2 / python:3.12.12-slim-bookworm | /health/ready: Docker каждые 5 с, LB каждую 1 с | Отдельные процессы; без volume/публикации порта; DSN через secret |
| Миграции | migrate / тот же Dockerfile | Завершение с кодом 0 | Отдельная команда python -m src.database |
| БД и сессии | postgres / postgres:16.10-bookworm | pg_isready каждые 2 с; API проверяет схему/таблицы | postgres_data; только внутренняя сеть; пароль через secret |
Runtime-зависимости закреплены в requirements.txt: psycopg и psycopg-pool
3.2.6, typing_extensions 4.16.0. API: по 1 CPU / 256 MiB; PostgreSQL:
1 CPU / 256 MiB; LB: 0,5 CPU / 128 MiB; migrate: 0,5 CPU / 128 MiB.
API работает как UID 10001 с read-only FS.
APP_ENV — метка стартового лога; SESSION_TTL_SECONDS — абсолютный срок сессии,
по умолчанию 3600 с. Внутренние APP_HOST=0.0.0.0, APP_PORT=8080,
DATABASE_URL_FILE и INSTANCE_ID задаёт Compose. Внутренний порт не зависит
от опубликованного. Для прямого запуска поддерживается DATABASE_URL.
Неиспользуемые настройки Redis/числа реплик удалены из .env.example:
здесь два явных сервиса, добавление третьего требует изменить Compose и LB.
### Балансировка и остановка
Round robin без sticky session. Процесс один раз генерирует alias
api1-<random> или api2-<random>, неизменный до остановки. X-Instance-Id
формирует API для успешных ответов, ошибок и health. После рестарта alias меняется.
HAProxy проверяет GET /health/ready: inter 1s, fall 2, rise 1, timeout check 1s.
При неизменной доступности DNS расчётный бюджет исключения зависшего backend —
примерно до 4 с; это не гарантия для любого перегруженного хоста.
TCP connect timeout 500 мс, backend timeout 5 с. Docker DNS 127.0.0.11
перепроверяется с hold valid 1s, поэтому LB обновляет IP заменённого контейнера.
Readiness проверяет миграцию lab3 и доступность общих таблиц; критическая
зависимость — PostgreSQL. Liveness проверяет процесс.
LB повторяет только ошибку установления соединения (conn-failure), с redispatch.
Переданные POST чата/сессии прозрачно не повторяются. Неопределённый результат
отправки сообщения клиент повторяет с исходным ключом. При SIGTERM API закрывает
listener, отвечает 503 при наблюдаемом флаге остановки и ждёт потоки до 5 с;
Compose даёт 7 с, stop hook — 6 с.
stop_one.py принимает только alias вида api[12]-<12 hex>, сопоставляет его
с сервисом, через внутренний health сверяет текущий alias процесса и выполняет
docker compose stop. Реплика остаётся остановленной. БД/LB hook не трогает.
TARGET_INSTANCE_ID передаёт публичный тест; вручную нужен alias из ответа API.
### Идемпотентность и транзакции
002_idempotency.sql создаёт message_keys: PK (user_id, chat_id, key), FK на
сообщение, expires_at = часы БД + 24 ч. Таблица используется только для
POST /api/v1/chats/{chat_id}/messages, поэтому метод и канонический путь
однозначно заданы назначением таблицы и chat_id. Пользователи/чаты независимы.
Сначала проверяются Bearer и членство. POST блокирует строку чата FOR UPDATE,
валидирует ключ [A-Za-z0-9._:-]{1,128} и JSON. Под блокировкой проверяется общий
ключ: прежний text возвращает **201 и прежний Message**, другой text — 409.
Сравнение декодированного text делает JSON whitespace/escape несущественными.
OpenAPI lab3 содержит только text; вложения появляются в lab4.
Если действующего ключа нет, INSERT сообщения и ключа выполняются в одной
транзакции. HTTP 201 отправляется после COMMIT. Сбой до COMMIT откатывает оба
INSERT, потеря ответа после COMMIT позволяет найти прежний результат на другой
реплике. READ COMMITTED после ожидания блокировки видит предыдущий COMMIT.
Ошибки не сохраняются как окончательный результат.
При следующем использовании истёкшего ключа старая запись ключа удаляется,
сообщение остаётся; ключ можно применить для новой отправки. Массовой очистки нет.
Порядок истории и подписанный cursor lab2 сохранены. Миграции под advisory lock,
с checksum и без seed; API схему не меняют. Подробнее: [infra/schema.md](infra/schema.md).
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Воспроизводимый стенд | bootstrap, compose up --build --wait, config --quiet | Два реальных API, LB, БД, отдельный migrate | compose.yaml; BEFORE_RESTART в протоколе |
| Публичный smoke | python tests/smoke.py --base-url http://127.0.0.1:18083 | PASS lab3 | evidence/grade3-checks.txt |
| Общая сессия | verify: одна сессия, ≥2 alias через LB | Один пользователь на обеих репликах | OBSERVED_INSTANCES |
| Конкурентная идемпотентность | test_same_key_concurrent_across_replicas | 12 одинаковых ответов 201 через 2 реплики; одна запись | Протокол собственных тестов |
| Конфликт body и область ключа | test_conflicting_bodies_race, test_key_scope_and_access | 201+409; независимость пользователей/чатов; доступ при replay | 14 собственных тестов, OK |
| Отказ любой API | Два публичных failover + параллельный reader | api1, затем api2 exited; новые записи за <10 с | FAILOVER_RUN, AFTER_FAILOVER, CONCURRENT_READS |
| Сохранность и retry | Публичный failover, повтор restart-key | Подтверждённые сообщения не потеряны, дублей нет | PASS failover; проверка прежнего Message |
| Полный рестарт | Публичный persistence + inspect | StartedAt четырёх контейнеров изменился; volume, токен и cursor сохранены | BEFORE_RESTART / AFTER_RESTART |
| Ключ после рестарта | Повтор restart-key | Прежний Message и 201 | PASS four containers restarted |
| Согласованные миграции | Два повторных запуска migrate | Семь счётчиков не изменились | PASS repeated migrations |
| Полная схема | scripts/validate_openapi.py | PASS | evidence/contracts.txt |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Полный протокол: [evidence/grade3-checks.txt](evidence/grade3-checks.txt).
На Windows Make отсутствует: выполнены те же Python-команды. Linux hooks и
Make включены в CI, удалённый CI не запускался.
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Проверки проведены **13 ноября 2026**. Протокол содержит UTC, Москва UTC+3.
Клиент: Windows / Python 3.12.0. Docker Engine 29.5.3; Linux VM: 8 CPU,
2 967 707 648 байт RAM; лимиты сервисов приведены выше. Адрес: localhost:18083.
Гипотеза: остановка любого API не уничтожает сессию или подтверждённое сообщение,
общий ключ делает безопасным повтор на оставшейся реплике. Проверены readiness,
smoke, 14 собственных тестов, повтор миграций, полный рестарт и два отказа.
Конкурентный сценарий: 12 синхронизированных клиентов с одним ключом;
другой сценарий: 40 разных сообщений от 8 потоков. Это проверки корректности.
При каждом failover один последовательный writer с паузой 100 мс работает
15 секунд, повторяет неопределённый POST с прежним ключом. Отдельный reader
с паузой 100 мс работает также во время подготовки/сбора inspect: его числа
относятся к более длинному интервалу. Специального прогрева нет.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| Полный restart API, БД и LB | Данные/сессия сохраняются | PASS persistence; прежний cursor и replay | Без потерь; в бюджете публичного теста 90 с |
| Остановка api1 | Работа через api2 | 97 успешных POST / 0 ошибок, чтения 139 / 1 ошибка | Первое успешное POST после hook: 3,359 с от его запуска; без потерь |
| Восстановление api1, остановка api2 | Работа через api1 | 95 успешных POST / 1 ошибка, чтения 130 / 0 ошибок | Первое успешное POST после hook: 3,016 с от его запуска; без потерь |
first_recovery — не длительность полного простоя: часть запросов обслуживается
всё время. Метрика включает запуск hook, Docker CLI, проверку alias и остановку.
Допустимые переходные ошибки учтены; retry не создал дубль. Inspect доказывает
реальную остановку выбранных процессов, а не только смену заголовка.
После проверки обе API восстановлены. PostgreSQL подтверждает локальный COMMIT/WAL,
это не репликация/backup. Предельный RPS, p50/p95/p99, rolling update и CPU/RAM
под нагрузкой не исследовались и для оценки 3 не заявляются.
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
Один Docker-host, один LB и один PostgreSQL — точки единого отказа.
Выдерживается остановка одной API при работающей второй и доступной БД.
Полный рестарт проверен на сохранность, а не на непрерывную доступность.
Нет защиты от потери volume/host, репликации БД, backup, многоузлового failover,
автоматического масштабирования и rolling update. Поток на запрос и сериализация
отправок внутри чата ограничивают производительность. Требуется очистка старых
сессий/ключей. HTTP предназначен для локальных синтетических данных.
Источники: [контракт](contracts/README.md),
[HAProxy 3.0 configuration](https://docs.haproxy.org/3.0/configuration.html),
[HAProxy retries](https://www.haproxy.com/documentation/haproxy-configuration-tutorials/reliability/retries/),
[Compose services](https://docs.docker.com/reference/compose-file/services/),
[PostgreSQL row locks](https://www.postgresql.org/docs/16/explicit-locking.html),
[psycopg transactions](https://www.psycopg.org/psycopg3/docs/basic/transactions.html).
+18
View File
@@ -0,0 +1,18 @@
# Лабораторная 3 — БПИ2303 — Щербаков — на 3
Перенесён API из собственной lab2. Добавлены две API-реплики, HAProxy,
X-Instance-Id, общие ключи идемпотентности и отдельный migration job.
Запуск: `python scripts/bootstrap.py`, затем
`docker compose --env-file .env up -d --build --wait`.
На проверенном хосте в `.env` установлен `APP_PORT=18083`.
Smoke, 14 собственных тестов, persistence и failover обеих реплик прошли.
Инструкция, результаты, ограничения и источники: [REPORT.md](REPORT.md).
Полный протокол: [evidence/grade3-checks.txt](evidence/grade3-checks.txt).
Обязательные tests/ и contracts/ сохранены, секреты исключены из Git.
Использован OpenAI Codex. Уровни 4/5 не заявляются.
Ограничения: один host/LB/PostgreSQL, без HA БД и защиты от потери volume.
Проверен отказ одной API-реплики. Ветка решения: `solution/BPI2303-Scherbakov`.
Название коммита/PR: «ЛР 3 — БПИ2303 — Щербаков — на 3».
+97
View File
@@ -0,0 +1,97 @@
name: mtusi2026lab3
x-api: &api
build: .
image: mtusi2026lab3-api:local
environment: &api-env
APP_HOST: 0.0.0.0
APP_PORT: 8080
APP_ENV: ${APP_ENV:-lab}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
depends_on:
migrate:
condition: service_completed_successfully
restart: unless-stopped
read_only: true
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
stop_grace_period: 7s
cpus: 1.0
mem_limit: 256m
services:
postgres:
image: postgres:16.10-bookworm
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
secrets: [postgres_password]
volumes:
- postgres_data:/var/lib/postgresql/data
healthcheck:
test: [CMD-SHELL, "pg_isready -U messenger -d messenger"]
interval: 2s
timeout: 3s
retries: 30
restart: unless-stopped
cpus: 1.0
mem_limit: 256m
migrate:
build: .
image: mtusi2026lab3-api:local
command: [python, -m, src.database]
environment:
DATABASE_URL_FILE: /run/secrets/database_url
secrets: [database_url]
depends_on:
postgres:
condition: service_healthy
restart: "no"
healthcheck:
disable: true
read_only: true
cap_drop: [ALL]
security_opt: [no-new-privileges:true]
cpus: 0.5
mem_limit: 128m
api1:
<<: *api
environment:
<<: *api-env
INSTANCE_ID: api1
api2:
<<: *api
environment:
<<: *api-env
INSTANCE_ID: api2
lb:
image: haproxy:3.0.11-alpine
volumes:
- ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
ports:
- "127.0.0.1:${APP_PORT:-8080}:8080"
depends_on:
api1:
condition: service_healthy
api2:
condition: service_healthy
restart: unless-stopped
stop_grace_period: 7s
cpus: 0.5
mem_limit: 128m
volumes:
postgres_data:
secrets:
postgres_password:
file: ./secrets/postgres_password
database_url:
file: ./secrets/database_url
+1
View File
@@ -0,0 +1 @@
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
+53
View File
@@ -0,0 +1,53 @@
UTC 2026-11-13T10:14:48.740224+00:00
COMMAND python scripts/verify.py --base-url http://127.0.0.1:18083
Client=29.5.3 Server=29.5.3
Docker CPUs=8 memory_bytes=2967707648 OS=Docker Desktop
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
test_access_before_payload_validation (test_api.API.test_access_before_payload_validation) ... ok
test_bad_credentials_and_schemes (test_api.API.test_bad_credentials_and_schemes) ... ok
test_chat_atomic_invalid_members (test_api.API.test_chat_atomic_invalid_members) ... ok
test_concurrent_messages_and_keyset (test_api.API.test_concurrent_messages_and_keyset) ... ok
test_cursor_scope_and_tampering (test_api.API.test_cursor_scope_and_tampering) ... ok
test_json_and_sender_validation (test_api.API.test_json_and_sender_validation) ... ok
test_logout_only_revokes_current_session (test_api.API.test_logout_only_revokes_current_session) ... ok
test_registration_validation (test_api.API.test_registration_validation) ... ok
test_unicode_password_with_colon_and_max_length (test_api.API.test_unicode_password_with_colon_and_max_length) ... ok
test_username_race (test_api.API.test_username_race) ... ok
test_conflicting_bodies_race (test_idempotency.Idempotency.test_conflicting_bodies_race) ... ok
test_invalid_keys_and_no_cached_error (test_idempotency.Idempotency.test_invalid_keys_and_no_cached_error) ... ok
test_key_scope_and_access (test_idempotency.Idempotency.test_key_scope_and_access) ... ok
test_same_key_concurrent_across_replicas (test_idempotency.Idempotency.test_same_key_concurrent_across_replicas) ... PASS: concurrent_retries=12 observed_replicas=2 committed_messages=1
ok
----------------------------------------------------------------------
Ran 14 tests in 20.505s
OK
OBSERVED_INSTANCES ["api1-8bf4ca1b6782", "api2-84a86743f141"]
Container mtusi2026lab3-migrate-run-ce2dbd67e3aa Creating
Container mtusi2026lab3-migrate-run-ce2dbd67e3aa Created
PASS: migrations applied
Container mtusi2026lab3-migrate-run-29635236b377 Creating
Container mtusi2026lab3-migrate-run-29635236b377 Created
PASS: migrations applied
PASS: repeated migrations preserve all table counts 50|18|34|53|47|53|2
BEFORE_RESTART {"api1": {"id": "02bbaf71155d", "status": "running", "started_at": "2026-11-13T10:13:03.914179031Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "api2": {"id": "29260af8132d", "status": "running", "started_at": "2026-11-13T10:13:03.905124693Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "postgres": {"id": "7ddc2e9d0ff8", "status": "running", "started_at": "2026-11-13T10:12:52.495526953Z", "volumes": ["mtusi2026lab3_postgres_data"], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "lb": {"id": "36838b658528", "status": "running", "started_at": "2026-11-13T10:14:24.206525036Z", "volumes": [], "ports": {"8080/tcp": [{"HostIp": "127.0.0.1", "HostPort": "18083"}]}, "memory_limit": 134217728, "nano_cpus": 500000000}}
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
AFTER_RESTART {"api1": {"id": "02bbaf71155d", "status": "running", "started_at": "2026-11-13T10:15:39.648840987Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "api2": {"id": "29260af8132d", "status": "running", "started_at": "2026-11-13T10:15:41.135861407Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "postgres": {"id": "7ddc2e9d0ff8", "status": "running", "started_at": "2026-11-13T10:15:40.976703745Z", "volumes": ["mtusi2026lab3_postgres_data"], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "lb": {"id": "36838b658528", "status": "running", "started_at": "2026-11-13T10:15:39.495114394Z", "volumes": [], "ports": {"8080/tcp": [{"HostIp": "127.0.0.1", "HostPort": "18083"}]}, "memory_limit": 134217728, "nano_cpus": 500000000}}
PASS: four containers restarted; volume, sessions, cursor and idempotency result preserved
FAILOVER_RUN 1
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 97, "failed_attempts": 0, "first_recovery_seconds": 3.359}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
AFTER_FAILOVER {"api1": {"id": "02bbaf71155d", "status": "exited", "started_at": "2026-11-13T10:15:39.648840987Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "api2": {"id": "29260af8132d", "status": "running", "started_at": "2026-11-13T10:15:41.135861407Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "postgres": {"id": "7ddc2e9d0ff8", "status": "running", "started_at": "2026-11-13T10:15:40.976703745Z", "volumes": ["mtusi2026lab3_postgres_data"], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "lb": {"id": "36838b658528", "status": "running", "started_at": "2026-11-13T10:15:39.495114394Z", "volumes": [], "ports": {"8080/tcp": [{"HostIp": "127.0.0.1", "HostPort": "18083"}]}, "memory_limit": 134217728, "nano_cpus": 500000000}}
CONCURRENT_READS {"ok": 139, "errors": 1}
FAILOVER_RUN 2
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 95, "failed_attempts": 1, "first_recovery_seconds": 3.016}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
AFTER_FAILOVER {"api1": {"id": "02bbaf71155d", "status": "running", "started_at": "2026-11-13T10:16:20.233122551Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "api2": {"id": "29260af8132d", "status": "exited", "started_at": "2026-11-13T10:15:41.135861407Z", "volumes": [], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "postgres": {"id": "7ddc2e9d0ff8", "status": "running", "started_at": "2026-11-13T10:15:40.976703745Z", "volumes": ["mtusi2026lab3_postgres_data"], "ports": {}, "memory_limit": 268435456, "nano_cpus": 1000000000}, "lb": {"id": "36838b658528", "status": "running", "started_at": "2026-11-13T10:15:39.495114394Z", "volumes": [], "ports": {"8080/tcp": [{"HostIp": "127.0.0.1", "HostPort": "18083"}]}, "memory_limit": 134217728, "nano_cpus": 500000000}}
CONCURRENT_READS {"ok": 130, "errors": 0}
PASS: each API stopped separately; reads/writes and original session survive; both replicas restored
PASS: grade-3 verification complete
+42
View File
@@ -0,0 +1,42 @@
global
log stdout format raw local0
maxconn 512
hard-stop-after 5s
defaults
log global
mode http
option httplog
option dontlognull
timeout connect 500ms
timeout client 10s
timeout server 5s
timeout check 1s
retries 1
retry-on conn-failure
option redispatch
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 1s
hold obsolete 1s
hold nx 1s
hold timeout 1s
hold refused 1s
hold other 1s
frontend public
bind :8080
default_backend replicas
backend replicas
balance roundrobin
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host localhost
http-check expect status 200
default-server check inter 1s fall 2 rise 1 resolvers docker resolve-prefer ipv4 init-addr libc,none
server api1 api1:8080
server api2 api2:8080
+31
View File
@@ -0,0 +1,31 @@
# Общая схема и транзакции
Из lab2: users (UUID, UNIQUE username, scrypt password_hash), chats,
memberships (составной PK и FK), messages (FK на чат и членство), sessions
(SHA-256 токена, user_id, expires_at), settings (общий ключ HMAC cursor),
schema_migrations (номер файла и SHA-256). История индексирована по
`(chat_id, created_at, id)`, членство — по `(user_id, chat_id)`.
Lab3 добавляет message_keys: PK `(user_id, chat_id, key)`, FK user/chat/message,
expires_at = часы БД + 24 часа. Таблица обслуживает только POST messages;
метод и путь чата заданы её назначением и chat_id.
POST сообщения: проверка сессии → блокировка доступного чата FOR UPDATE
→ валидация JSON/ключа → удаление истёкшего ключа данной области → поиск
результата → replay либо INSERT сообщения + INSERT ключа → COMMIT → HTTP 201.
Другой текст с прежним действующим ключом даёт 409. Блокировка PostgreSQL
общая для всех реплик. Сообщения неизменяемы, FK ключа сохраняет точный результат.
Ошибка откатывает всю транзакцию. Text сравнивается после JSON decode.
Все API читают один primary без кэша истории/сессий. Проверка expiry идёт
по clock_timestamp() PostgreSQL, токен после рестарта не продлевается.
Создание чата и участников атомарно. Ответы о записи идут после COMMIT.
Монотонное время внутри чата под блокировкой: max(часы БД, предыдущее + 1 мкс).
Cursor связан с ресурсом, подписан общим ключом. Snapshot между страницами
не гарантируется. Список разных чатов зависит от часов БД и порядка завершения
транзакций, как в lab2.
Миграции запускает отдельный сервис migrate; API не меняют схему.
Advisory lock 2026002 защищает от одновременных migration jobs;
DDL и журнал миграций коммитятся вместе. Checksum применённого файла неизменяем.
001_initial.sql перенесён без изменения; новое DDL находится в 002.
+36
View File
@@ -0,0 +1,36 @@
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'),
display_name text NOT NULL CHECK (char_length(display_name) BETWEEN 1 AND 100),
password_hash text NOT NULL,
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT clock_timestamp()
);
CREATE TABLE memberships (
chat_id uuid NOT NULL REFERENCES chats(id),
user_id uuid NOT NULL REFERENCES users(id),
ordinal integer NOT NULL CHECK (ordinal >= 0),
PRIMARY KEY (chat_id, user_id),
UNIQUE (chat_id, ordinal)
);
CREATE INDEX memberships_user ON memberships (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats(id),
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL,
FOREIGN KEY (chat_id, sender_id) REFERENCES memberships(chat_id, user_id)
);
CREATE INDEX messages_history ON messages (chat_id, created_at, id);
CREATE TABLE sessions (
token_hash text PRIMARY KEY,
user_id uuid NOT NULL REFERENCES users(id),
expires_at timestamptz NOT NULL
);
CREATE INDEX sessions_expiry ON sessions (expires_at);
CREATE TABLE settings (key text PRIMARY KEY, value text NOT NULL);
+11
View File
@@ -0,0 +1,11 @@
-- This table serves only POST /api/v1/chats/{chat_id}/messages.
-- Therefore method and canonical path are implicit in (user_id, chat_id, key).
CREATE TABLE message_keys (
user_id uuid NOT NULL REFERENCES users(id),
chat_id uuid NOT NULL REFERENCES chats(id),
key text NOT NULL CHECK (key ~ '^[A-Za-z0-9._:-]{1,128}$'),
message_id uuid NOT NULL REFERENCES messages(id),
expires_at timestamptz NOT NULL DEFAULT (clock_timestamp() + interval '24 hours'),
PRIMARY KEY (user_id, chat_id, key)
);
CREATE INDEX message_keys_expiry ON message_keys(expires_at);
+3
View File
@@ -0,0 +1,3 @@
psycopg[binary]==3.2.6
psycopg-pool==3.2.6
typing_extensions==4.16.0
+18
View File
@@ -0,0 +1,18 @@
"""Generate local synthetic credentials without printing or overwriting them."""
from pathlib import Path
import secrets
root = Path(__file__).resolve().parents[1]
directory = root / "secrets"
directory.mkdir(exist_ok=True)
password_file = directory / "postgres_password"
if not password_file.exists():
password_file.write_text(secrets.token_hex(32), encoding="ascii")
url = directory / "database_url"
if not url.exists():
password = password_file.read_text(encoding="ascii").strip()
url.write_text(f"postgresql://messenger:{password}@postgres:5432/messenger", encoding="ascii")
env = root / ".env"
if not env.exists():
env.write_bytes((root / ".env.example").read_bytes())
print("Local .env and secrets ready; existing files preserved.")
+4
View File
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0.."
docker compose --env-file .env restart postgres api1 api2 lb
exit /b %errorlevel%
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart postgres api1 api2 lb
+4
View File
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0.."
python scripts/stop_one.py
exit /b %errorlevel%
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
exec "${PYTHON:-python3}" scripts/stop_one.py
+19
View File
@@ -0,0 +1,19 @@
"""Stop exactly the process identified by TARGET_INSTANCE_ID; never remove volumes."""
import os
from pathlib import Path
import re
import subprocess
ROOT = Path(__file__).resolve().parents[1]
target = os.environ.get("TARGET_INSTANCE_ID", "")
if not re.fullmatch(r"api[12]-[0-9a-f]{12}", target):
raise SystemExit("TARGET_INSTANCE_ID must be the exact X-Instance-Id from a running API")
service = target.split("-", 1)[0]
compose = ["docker", "compose", "--env-file", ".env"]
# Compare to the real API process, rather than trusting a supplied service name.
code = "from urllib.request import urlopen; print(urlopen('http://127.0.0.1:8080/health/live',timeout=2).headers['X-Instance-Id'])"
actual = subprocess.check_output(compose + ["exec", "-T", service, "python", "-c", code], cwd=ROOT, text=True).strip()
if actual != target:
raise SystemExit("Target process changed; refusing to stop another instance")
subprocess.run(compose + ["stop", "--timeout", "6", service], cwd=ROOT, check=True)
print("Stopped " + service + " instance=" + target)
+150
View File
@@ -0,0 +1,150 @@
"""Reproduce grade-3 evidence against the lab3 Compose stack; no credentials in output."""
import argparse
from datetime import datetime, timezone
import json
import os
from pathlib import Path
import subprocess
import sys
import threading
import time
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "tests"))
from client import Client, Failure
COMPOSE = ["docker", "compose", "--env-file", ".env"]
def command(args, capture=False):
result = subprocess.run(args, cwd=ROOT, text=True, encoding="utf-8", errors="replace",
stdout=subprocess.PIPE if capture else sys.stdout,
stderr=subprocess.STDOUT, timeout=180)
if result.returncode:
raise RuntimeError("Command failed: " + args[0])
return result.stdout
def sql(query):
return command(COMPOSE + ["exec", "-T", "postgres", "psql", "-U", "messenger", "-d", "messenger", "-Atc", query], True).strip()
def state():
result = {}
for service in ("api1", "api2", "postgres", "lb"):
cid = command(COMPOSE + ["ps", "-a", "-q", service], True).strip()
data = json.loads(command(["docker", "inspect", cid], True))[0]
result[service] = {"id": cid[:12], "status": data["State"]["Status"],
"started_at": data["State"]["StartedAt"],
"volumes": [m["Name"] for m in data["Mounts"] if m["Type"] == "volume"],
"ports": data["HostConfig"]["PortBindings"],
"memory_limit": data["HostConfig"]["Memory"],
"nano_cpus": data["HostConfig"]["NanoCpus"]}
return result
def wait_replicas(c, actor):
deadline, seen = time.monotonic() + 60, set()
while time.monotonic() < deadline:
try:
seen.add(c.call("GET", "/api/v1/users/me", actor=actor, schema="User")["headers"]["X-Instance-Id"])
if len(seen) >= 2:
return seen
except Failure:
pass
time.sleep(0.1)
raise AssertionError("Two replicas did not become ready")
def main():
p = argparse.ArgumentParser(description=__doc__)
p.add_argument("--base-url", default="http://127.0.0.1:8080")
p.add_argument("--output")
args = p.parse_args()
if args.output:
sys.stdout = open(ROOT / args.output, "w", encoding="utf-8", buffering=1)
sys.stderr = sys.stdout
os.environ.update(BASE_URL=args.base_url, NO_PROXY="localhost,127.0.0.1", no_proxy="localhost,127.0.0.1")
print("UTC " + datetime.now(timezone.utc).isoformat(), flush=True)
print("COMMAND python scripts/verify.py --base-url " + args.base_url, flush=True)
command(["docker", "version", "--format", "Client={{.Client.Version}} Server={{.Server.Version}}"])
command(["docker", "info", "--format", "Docker CPUs={{.NCPU}} memory_bytes={{.MemTotal}} OS={{.OperatingSystem}}"])
command(COMPOSE + ["config", "--quiet"])
command([sys.executable, "scripts/check_contract.py"])
command([sys.executable, "tests/smoke.py", "--base-url", args.base_url])
command([sys.executable, "-m", "unittest", "discover", "-s", "student-tests", "-v"])
c = Client(args.base_url, timeout=2)
a, b, _, chat = c.bootstrap()
seen = wait_replicas(c, a)
print("OBSERVED_INSTANCES " + json.dumps(sorted(seen)), flush=True)
first = c.message(a, chat, "survives restart", key="restart-key")["json"]
second = c.message(b, chat, "cursor after restart")["json"]
path = "/api/v1/chats/" + chat["id"] + "/messages"
page = c.call("GET", path + "?limit=1", actor=a, schema="MessagePage")["json"]
counts = "SELECT (SELECT count(*) FROM users),(SELECT count(*) FROM chats),(SELECT count(*) FROM memberships),(SELECT count(*) FROM messages),(SELECT count(*) FROM sessions),(SELECT count(*) FROM message_keys),(SELECT count(*) FROM schema_migrations)"
before_counts = sql(counts)
for _ in range(2):
command(COMPOSE + ["run", "--rm", "--no-deps", "migrate"])
assert sql(counts) == before_counts
print("PASS: repeated migrations preserve all table counts " + before_counts, flush=True)
before = state()
print("BEFORE_RESTART " + json.dumps(before), flush=True)
hook = "scripts/restart.cmd" if os.name == "nt" else "scripts/restart.sh"
command([sys.executable, "tests/resilience.py", "--mode", "persistence", "--action-script", hook, "--base-url", args.base_url])
after = state()
print("AFTER_RESTART " + json.dumps(after), flush=True)
for service in before:
assert before[service]["started_at"] != after[service]["started_at"]
assert before[service]["volumes"] == after[service]["volumes"]
assert c.message(a, chat, "survives restart", key="restart-key")["json"] == first
rest = c.call("GET", path + "?limit=1&cursor=" + quote(page["next_cursor"]), actor=a, schema="MessagePage")["json"]
assert page["items"] == [first] and rest["items"] == [second]
print("PASS: four containers restarted; volume, sessions, cursor and idempotency result preserved", flush=True)
stopped = set()
hook = "scripts/stop-one.cmd" if os.name == "nt" else "scripts/stop-one.sh"
# Run the unchanged public test until it has selected each real replica.
# Read concurrently with its POST stream to also measure read availability.
for attempt in range(6):
if stopped == {"api1", "api2"}:
break
command(COMPOSE + ["up", "-d", "--wait", "api1", "api2"], True)
wait_replicas(c, a)
done, reads = threading.Event(), {"ok": 0, "errors": 0}
def read_during_failure():
reader = Client(args.base_url, timeout=2)
while not done.is_set():
try:
result = reader.call("GET", path, actor=b, schema="MessagePage")["json"]
assert first in result["items"]
reads["ok"] += 1
except Failure:
reads["errors"] += 1
done.wait(0.1)
worker = threading.Thread(target=read_during_failure)
worker.start()
try:
print("FAILOVER_RUN " + str(attempt + 1), flush=True)
command([sys.executable, "tests/resilience.py", "--mode", "failover", "--action-script", hook, "--base-url", args.base_url])
current = state()
down = {s for s in ("api1", "api2") if current[s]["status"] == "exited"}
assert len(down) == 1
stopped.update(down)
print("AFTER_FAILOVER " + json.dumps(current), flush=True)
assert reads["ok"] >= 5
print("CONCURRENT_READS " + json.dumps(reads), flush=True)
assert c.message(a, chat, "survives restart", key="restart-key")["json"] == first
finally:
done.set()
worker.join(timeout=5)
command(COMPOSE + ["up", "-d", "--wait", "api1", "api2"], True)
assert stopped == {"api1", "api2"}, "Both replicas must be tested"
wait_replicas(c, a)
assert sql("SELECT count(*) FROM chats c WHERE NOT EXISTS (SELECT 1 FROM memberships m WHERE m.chat_id=c.id)") == "0"
print("PASS: each API stopped separately; reads/writes and original session survive; both replicas restored", flush=True)
print("PASS: grade-3 verification complete", flush=True)
if __name__ == "__main__":
main()
+1
View File
@@ -0,0 +1 @@
"""Lab 1: a single-process, in-memory messenger."""
+43
View File
@@ -0,0 +1,43 @@
import re
from uuid import UUID
class APIError(Exception):
def __init__(self, status, code, message):
self.status, self.code, self.message = status, code, message
def invalid():
return APIError(400, "invalid_request", "Invalid request")
def uuid_value(value):
if not isinstance(value, str) or not re.fullmatch(
r"[0-9a-fA-F]{8}(?:-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}", value
):
raise invalid()
return str(UUID(value))
def string_value(value, maximum):
if (not isinstance(value, str) or not 1 <= len(value) <= maximum
or not value.strip() or "\x00" in value or any(0xD800 <= ord(c) <= 0xDFFF for c in value)):
raise invalid()
return value
def fields(body, expected):
if not isinstance(body, dict) or set(body) != set(expected):
raise invalid()
def unique_object(pairs):
result = {}
for key, value in pairs:
if key in result:
raise invalid()
result[key] = value
return result
def reject_constant(value):
raise invalid()
+44
View File
@@ -0,0 +1,44 @@
"""PostgreSQL configuration and transactional, versioned migrations."""
import hashlib
import os
from pathlib import Path
import secrets
import psycopg
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
def database_url():
filename = os.environ.get("DATABASE_URL_FILE")
return Path(filename).read_text().strip() if filename else os.environ["DATABASE_URL"]
def migrate():
with psycopg.connect(database_url(), connect_timeout=3) as conn:
conn.execute("SELECT pg_advisory_xact_lock(2026002)")
conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations "
"(version text PRIMARY KEY, checksum text NOT NULL)")
for path in sorted((Path(__file__).resolve().parents[1] / "migrations").glob("*.sql")):
sql = path.read_text(encoding="utf-8")
checksum = hashlib.sha256(sql.encode()).hexdigest()
old = conn.execute("SELECT checksum FROM schema_migrations WHERE version=%s", (path.name,)).fetchone()
if old:
if old[0] != checksum:
raise RuntimeError("Applied migration checksum changed")
continue
conn.execute(sql)
conn.execute("INSERT INTO schema_migrations VALUES (%s,%s)", (path.name, checksum))
conn.execute("INSERT INTO settings VALUES ('cursor_key',%s) ON CONFLICT DO NOTHING", (secrets.token_hex(32),))
def pool():
return ConnectionPool(database_url(), min_size=1, max_size=8, timeout=2,
max_waiting=32, open=True, check=ConnectionPool.check_connection,
kwargs={"connect_timeout": 3, "row_factory": dict_row,
"options": "-c timezone=UTC -c statement_timeout=3000 -c lock_timeout=2000"})
if __name__ == "__main__":
migrate()
print("PASS: migrations applied")
+18
View File
@@ -0,0 +1,18 @@
"""Container readiness probe; exits nonzero on failure."""
import json
import os
from urllib.request import ProxyHandler, build_opener
def main():
host = os.environ.get("APP_HOST", "0.0.0.0")
if host == "0.0.0.0":
host = "127.0.0.1"
port = int(os.environ.get("APP_PORT", "8080"))
with build_opener(ProxyHandler({})).open(f"http://{host}:{port}/health/ready", timeout=2) as response:
if response.status != 200 or json.load(response) != {"status": "ok"}:
raise SystemExit(1)
if __name__ == "__main__":
main()
+38
View File
@@ -0,0 +1,38 @@
"""Signed, resource-bound keyset cursors, inherited from lab1."""
import base64
import binascii
import hmac
import json
import re
from .common import invalid
class Pagination:
def cursor(self, scope, record):
payload = json.dumps([scope, record["created_at"], record["id"]], separators=(",", ":")).encode()
signature = hmac.digest(self.cursor_key, payload, "sha256")
return base64.urlsafe_b64encode(signature + payload).decode().rstrip("=")
def decode_page(self, query, scope):
if set(query) - {"limit", "cursor"} or any(len(v) != 1 for v in query.values()):
raise invalid()
limit = query.get("limit", ["50"])[0]
if not re.fullmatch(r"[0-9]{1,3}", limit) or not 1 <= int(limit) <= 100:
raise invalid()
limit = int(limit)
after = None
if "cursor" in query:
token = query["cursor"][0]
if not re.fullmatch(r"[A-Za-z0-9_-]{1,1024}", token):
raise invalid()
try:
raw = base64.b64decode(token + "=" * (-len(token) % 4), altchars=b"-_", validate=True)
signature, payload = raw[:32], raw[32:]
if not hmac.compare_digest(signature, hmac.digest(self.cursor_key, payload, "sha256")):
raise invalid()
resource, created, record_id = json.loads(payload)
if resource != scope:
raise invalid()
after = (created, record_id)
except (ValueError, UnicodeError, binascii.Error):
raise invalid() from None
return limit, after
+183
View File
@@ -0,0 +1,183 @@
"""Stateless lab3 HTTP replica. Migrations run as a separate Compose job."""
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
import json
import logging
import os
import re
import signal
import threading
import time
from urllib.parse import parse_qs, urlsplit
from uuid import uuid4
import psycopg
from .common import APIError, invalid, unique_object, reject_constant
from .store import Store
LOG = logging.getLogger("messenger")
MAX_BODY = 64 * 1024
SHUTDOWN_SECONDS = 5
class Server(ThreadingHTTPServer):
daemon_threads = True
request_queue_size = 128
def __init__(self, address):
self.instance_id = os.environ.get("INSTANCE_ID", "api") + "-" + uuid4().hex[:12]
self.store = Store()
self.stopping = threading.Event()
self.workers = set()
self.workers_lock = threading.Lock()
super().__init__(address, Handler)
self.timeout = 0.2
def process_request_thread(self, request, client_address):
worker = threading.current_thread()
with self.workers_lock:
self.workers.add(worker)
try:
super().process_request_thread(request, client_address)
finally:
with self.workers_lock:
self.workers.discard(worker)
def handle_error(self, request, client_address):
LOG.error("connection_handler_failed")
class Handler(BaseHTTPRequestHandler):
server_version = "Messenger"
sys_version = ""
def setup(self):
super().setup()
self.connection.settimeout(2)
def log_message(self, format, *args):
# Base handler includes raw paths and possibly user-supplied text.
pass
def send_error(self, code, message=None, explain=None):
self.request_id = getattr(self, "request_id", str(uuid4()))
self.reply(400, {"error": {"code": "invalid_request", "message": "Invalid HTTP request", "request_id": self.request_id}})
def read_body(self):
if self.headers.get_content_type() != "application/json":
raise APIError(415, "unsupported_media_type", "Expected application/json")
lengths = self.headers.get_all("Content-Length", [])
if self.headers.get("Transfer-Encoding") or len(lengths) != 1 or not re.fullmatch(r"[0-9]{1,10}", lengths[0]):
raise invalid()
size = int(lengths[0])
if size > MAX_BODY:
raise APIError(413, "payload_too_large", "Request exceeds 65536 bytes")
try:
raw = self.rfile.read(size)
if len(raw) != size:
raise invalid()
return json.loads(raw.decode("utf-8"), object_pairs_hook=unique_object, parse_constant=reject_constant)
except (ValueError, UnicodeError, RecursionError, TimeoutError):
raise invalid() from None
def reply(self, status, body):
encoded = b"" if status == 204 else json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
self.send_response(status)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.send_header("Content-Length", str(len(encoded)))
self.send_header("X-Request-Id", self.request_id)
self.send_header("X-Instance-Id", self.server.instance_id)
if status == 401:
challenge = 'Basic realm="messenger", charset="UTF-8"' if urlsplit(self.path).path == "/api/v1/auth/sessions" else 'Bearer realm="messenger"'
self.send_header("WWW-Authenticate", challenge)
self.send_header("Connection", "close")
self.end_headers()
self.close_connection = True
self.wfile.write(encoded)
def handle_api(self):
started = time.monotonic()
self.request_id = str(uuid4())
status = 500
try:
server = self.server
assert isinstance(server, Server)
if server.stopping.is_set():
raise APIError(503, "unavailable", "Server is stopping")
parsed = urlsplit(self.path)
path = parsed.path
if path in ("/health/live", "/health/ready") and self.command == "GET":
if path == "/health/ready":
server.store.ready()
status, body = 200, {"status": "ok"}
else:
store = server.store
public = (path, self.command) in (("/api/v1/users", "POST"), ("/api/v1/auth/sessions", "POST"))
actor = None if public else store.authenticate(self.headers.get("Authorization"))
cached_body = None
if path == "/api/v1/auth/sessions" and self.command == "POST":
if self.headers.get("Transfer-Encoding") or self.headers.get("Content-Length", "0") != "0":
raise invalid()
status, body = store.login(self.headers.get("Authorization"))
else:
if self.command == "POST":
match = re.fullmatch(r"/api/v1/chats/([^/]+)/messages", path)
if match:
store.check_chat(match[1], actor)
cached_body = self.read_body()
query = parse_qs(parsed.query, keep_blank_values=True, max_num_fields=10)
keys = self.headers.get_all("Idempotency-Key", [])
key = keys[0] if len(keys) == 1 else None
status, body = store.dispatch(self.command, path, query, actor, lambda: cached_body, key)
except APIError as exc:
status = exc.status
body = {"error": {"code": exc.code, "message": exc.message, "request_id": self.request_id}}
except (psycopg.OperationalError, psycopg.InterfaceError):
status = 503
body = {"error": {"code": "unavailable", "message": "Storage unavailable", "request_id": self.request_id}}
except ValueError:
status = 400
body = {"error": {"code": "invalid_request", "message": "Invalid request", "request_id": self.request_id}}
except Exception as exc:
LOG.error("request_failed request_id=%s exception=%s", self.request_id, type(exc).__name__)
body = {"error": {"code": "internal_error", "message": "Internal error", "request_id": self.request_id}}
try:
self.reply(status, body)
except OSError:
LOG.info("client_disconnected request_id=%s", self.request_id)
finally:
LOG.info("request request_id=%s method=%s status=%d duration_ms=%.3f", self.request_id, self.command, status, (time.monotonic() - started) * 1000)
do_GET = do_POST = do_PUT = do_PATCH = do_DELETE = do_OPTIONS = handle_api
def main():
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
server = Server((os.environ.get("APP_HOST", "0.0.0.0"), int(os.environ.get("APP_PORT", "8080"))))
def stop(signum, frame):
server.stopping.set()
signal.signal(signal.SIGTERM, stop)
signal.signal(signal.SIGINT, stop)
LOG.info("started host=%s port=%d env=%s", *server.server_address, os.environ.get("APP_ENV", "lab"))
try:
while not server.stopping.is_set():
server.handle_request()
finally:
server.stopping.set()
server.server_close()
LOG.info("shutdown_started listener_closed=true budget_seconds=%d", SHUTDOWN_SECONDS)
deadline = time.monotonic() + SHUTDOWN_SECONDS
with server.workers_lock:
workers = list(server.workers)
for worker in workers:
worker.join(max(0, deadline - time.monotonic()))
server.store.pool.close()
LOG.info("shutdown_complete unfinished_requests=%d", sum(w.is_alive() for w in workers))
if __name__ == "__main__":
main()
+198
View File
@@ -0,0 +1,198 @@
"""Shared PostgreSQL state and atomic idempotent message creation."""
import base64
from datetime import datetime
import hashlib
import hmac
import os
import re
import secrets
from uuid import UUID, uuid4
import psycopg
from .common import APIError, fields, invalid, string_value, uuid_value
from .database import pool
from .pagination import Pagination
def record(row):
return {k: (str(v) if isinstance(v, UUID) else
v.isoformat(timespec="microseconds").replace("+00:00", "Z")
if isinstance(v, datetime) else v) for k, v in row.items()}
def password_hash(password, salt=None):
salt = salt or secrets.token_hex(16)
derived = hashlib.scrypt(password.encode("utf-8"), salt=bytes.fromhex(salt),
n=16384, r=8, p=1, dklen=32)
return "scrypt$16384$8$1$" + salt + "$" + derived.hex()
def unauthorized():
return APIError(401, "unauthorized", "Valid credentials required")
class Store(Pagination):
def __init__(self):
self.pool = pool()
self.ttl = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
if self.ttl <= 0:
raise ValueError("SESSION_TTL_SECONDS must be positive")
with self.pool.connection() as conn:
self.cursor_key = bytes.fromhex(conn.execute("SELECT value FROM settings WHERE key='cursor_key'").fetchone()["value"])
self.dummy_hash = password_hash("dummy-password-not-a-user")
def ready(self):
with self.pool.connection() as conn:
if not conn.execute("SELECT 1 FROM schema_migrations WHERE version='002_idempotency.sql'").fetchone():
raise APIError(503, "unavailable", "Schema not ready")
conn.execute("SELECT 1 FROM sessions LIMIT 1")
conn.execute("SELECT 1 FROM message_keys LIMIT 1")
def authenticate(self, header):
if not isinstance(header, str) or not re.fullmatch(r"(?i:Bearer) [A-Za-z0-9_-]{43}", header):
raise unauthorized()
digest = hashlib.sha256(header.split(" ", 1)[1].encode()).hexdigest()
with self.pool.connection() as conn:
row = conn.execute("SELECT user_id FROM sessions WHERE token_hash=%s AND expires_at>clock_timestamp()", (digest,)).fetchone()
if not row:
raise unauthorized()
return (str(row["user_id"]), digest)
def login(self, header):
try:
scheme, encoded = header.split(" ", 1)
if scheme.lower() != "basic":
raise ValueError()
username, password = base64.b64decode(encoded, validate=True).decode("utf-8").split(":", 1)
if not re.fullmatch(r"[a-z0-9_]{3,32}", username) or not 12 <= len(password) <= 128:
raise ValueError()
except (AttributeError, ValueError, UnicodeError):
raise unauthorized() from None
with self.pool.connection() as conn:
row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone()
expected = row["password_hash"] if row else self.dummy_hash
actual = password_hash(password, expected.split("$")[4])
if not hmac.compare_digest(actual, expected) or row is None:
raise unauthorized()
del row["password_hash"]
token = secrets.token_urlsafe(32)
digest = hashlib.sha256(token.encode()).hexdigest()
with self.pool.connection() as conn:
expiry = conn.execute("INSERT INTO sessions VALUES (%s,%s,clock_timestamp()+%s*interval '1 second') RETURNING expires_at", (digest, row["id"], self.ttl)).fetchone()
return 201, {"token": token, "token_type": "Bearer", "expires_at": record(expiry)["expires_at"], "user": record(row)}
def chat(self, conn, value, actor, lock=False):
chat_id = uuid_value(value)
row = conn.execute("SELECT c.* FROM chats c WHERE c.id=%s AND EXISTS "
"(SELECT 1 FROM memberships m WHERE m.chat_id=c.id AND m.user_id=%s)" +
(" FOR UPDATE OF c" if lock else ""), (chat_id, actor[0])).fetchone()
if not row:
raise APIError(404, "not_found", "Object not found")
row = record(row)
row["member_ids"] = [str(m["user_id"]) for m in conn.execute("SELECT user_id FROM memberships WHERE chat_id=%s ORDER BY ordinal", (chat_id,))]
return row
def check_chat(self, value, actor):
with self.pool.connection() as conn:
self.chat(conn, value, actor)
def page(self, conn, query, scope, table, actor=None, chat_id=None):
limit, after = self.decode_page(query, scope)
# Table and predicate are selected internally, never supplied by a client.
if table == "messages":
sql = "SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s"
params = [chat_id]
else:
sql = "SELECT c.* FROM chats c WHERE EXISTS (SELECT 1 FROM memberships m WHERE m.chat_id=c.id AND m.user_id=%s)"
params = [actor[0]]
if after:
sql += " AND (created_at,id)>(%s::timestamptz,%s::uuid)"
params.extend(after)
sql += " ORDER BY created_at,id LIMIT %s"
params.append(limit + 1)
rows = [record(r) for r in conn.execute(sql, params)]
items = rows[:limit]
if table == "chats":
items = [self.chat(conn, r["id"], actor) for r in items]
return {"items": items, "next_cursor": self.cursor(scope, items[-1]) if len(rows) > limit else None}
def dispatch(self, method, path, query, actor, read_body, idempotency_key=None):
if path == "/api/v1/users" and method == "POST":
body = read_body()
fields(body, ("username", "display_name", "password"))
username = body["username"]
if not isinstance(username, str) or not re.fullmatch(r"[a-z0-9_]{3,32}", username):
raise invalid()
display = string_value(body["display_name"], 100)
password = string_value(body["password"], 128)
if len(password) < 12:
raise invalid()
hashed = password_hash(password)
try:
with self.pool.connection() as conn:
row = conn.execute("INSERT INTO users (id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at", (uuid4(), username, display, hashed)).fetchone()
return 201, record(row)
except psycopg.errors.UniqueViolation:
raise APIError(409, "conflict", "Username already exists") from None
with self.pool.connection() as conn:
if path == "/api/v1/auth/sessions/current" and method == "DELETE":
deleted = conn.execute("DELETE FROM sessions WHERE token_hash=%s RETURNING user_id", (actor[1],)).fetchone()
if not deleted:
raise unauthorized()
return 204, None
if path == "/api/v1/users/me" and method == "GET":
return 200, record(conn.execute("SELECT id,username,display_name,created_at FROM users WHERE id=%s", (actor[0],)).fetchone())
if path == "/api/v1/chats":
if method == "GET":
return 200, self.page(conn, query, "chats:" + actor[0], "chats", actor=actor)
if method == "POST":
body = read_body()
fields(body, ("title", "member_ids"))
title = string_value(body["title"], 100)
members = body["member_ids"]
if not isinstance(members, list) or not 1 <= len(members) <= 100:
raise invalid()
members = [uuid_value(m) for m in members]
if len(set(members)) != len(members) or actor[0] not in members:
raise invalid()
row = conn.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *", (uuid4(), title)).fetchone()
existing = conn.execute("SELECT id FROM users WHERE id=ANY(%s::uuid[])", (members,)).fetchall()
if len(existing) != len(members):
raise invalid() # Rolls back the chat INSERT as well.
with conn.cursor() as cur:
cur.executemany("INSERT INTO memberships VALUES (%s,%s,%s)", [(row["id"], m, i) for i, m in enumerate(members)])
return 201, dict(record(row), member_ids=members)
match = re.fullmatch(r"/api/v1/chats/([^/]+)(/messages)?", path)
if match:
chat = self.chat(conn, match[1], actor, lock=method == "POST")
if match[2] is None and method == "GET":
return 200, chat
if match[2] == "/messages":
if method == "GET":
return 200, self.page(conn, query, "messages:" + chat["id"], "messages", chat_id=chat["id"])
if method == "POST":
if not isinstance(idempotency_key, str) or not re.fullmatch(r"[A-Za-z0-9._:-]{1,128}", idempotency_key):
raise invalid()
body = read_body()
fields(body, ("text",))
text = string_value(body["text"], 4000)
# The chat row is already locked across ALL API replicas.
# READ COMMITTED sees the preceding writer's committed key.
conn.execute("DELETE FROM message_keys WHERE user_id=%s AND chat_id=%s AND key=%s AND expires_at<=clock_timestamp()",
(actor[0], chat["id"], idempotency_key))
previous = conn.execute("SELECT m.* FROM message_keys k JOIN messages m ON m.id=k.message_id "
"WHERE k.user_id=%s AND k.chat_id=%s AND k.key=%s",
(actor[0], chat["id"], idempotency_key)).fetchone()
if previous:
if previous["text"] != text:
raise APIError(409, "conflict", "Key already used for another message")
return 201, record(previous)
row = conn.execute("INSERT INTO messages VALUES (%s,%s,%s,%s,GREATEST(clock_timestamp(), "
"COALESCE((SELECT created_at+interval '1 microsecond' FROM messages "
"WHERE chat_id=%s ORDER BY created_at DESC,id DESC LIMIT 1),clock_timestamp()))) RETURNING *",
(uuid4(), chat["id"], actor[0], text, chat["id"])).fetchone()
conn.execute("INSERT INTO message_keys(user_id,chat_id,key,message_id) VALUES (%s,%s,%s,%s)",
(actor[0], chat["id"], idempotency_key, row["id"]))
return 201, record(row)
raise APIError(404, "not_found", "Object not found")
+107
View File
@@ -0,0 +1,107 @@
"""Own HTTP checks, separate from the unchanged public tests."""
import base64
from concurrent.futures import ThreadPoolExecutor
import os
from pathlib import Path
import sys
import unittest
from urllib.parse import quote
from uuid import uuid4
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client
class API(unittest.TestCase):
def setUp(self):
self.c = Client(os.environ.get("BASE_URL", "http://127.0.0.1:8080"))
self.a, self.b, self.e, self.chat = self.c.bootstrap()
self.path = "/api/v1/chats/" + self.chat["id"]
def test_registration_validation(self):
body = dict(self.a["registration"], username="u_" + uuid4().hex[:16])
for password in ("short", "x" * 129, 123, None):
self.c.call("POST", "/api/v1/users", 400, body=dict(body, password=password))
self.c.call("POST", "/api/v1/users", 400, body=dict(body, extra=True))
def test_unicode_password_with_colon_and_max_length(self):
username = "u_" + uuid4().hex[:16]
password = "Я:🔐" + "б" * 125
body = {"username": username, "display_name": "Имя 👋", "password": password}
user = self.c.call("POST", "/api/v1/users", 201, body=body, schema="User")["json"]
credential = base64.b64encode((username + ":" + password).encode()).decode()
result = self.c.call("POST", "/api/v1/auth/sessions", 201, headers={"Authorization": "Basic " + credential}, schema="Session")["json"]
self.assertEqual(user, result["user"])
self.assertGreaterEqual(len(base64.urlsafe_b64decode(result["token"] + "=")), 32)
def test_bad_credentials_and_schemes(self):
for credential in ("Basic ***", "Bearer token", "", "Basic " + base64.b64encode(b"missing:wrong-password").decode()):
self.c.call("POST", "/api/v1/auth/sessions", 401, headers={"Authorization": credential})
self.c.call("GET", "/api/v1/users/me", 401, headers={"X-User-Id": self.a["id"]})
def test_logout_only_revokes_current_session(self):
body = self.a["registration"]
credential = base64.b64encode((body["username"] + ":" + body["password"]).encode()).decode()
other = self.c.call("POST", "/api/v1/auth/sessions", 201, headers={"Authorization": "Basic " + credential}, schema="Session")["json"]
self.c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=self.a)
self.c.call("GET", "/api/v1/users/me", 401, actor=self.a)
self.c.call("GET", "/api/v1/users/me", actor={"token": other["token"]}, schema="User")
def test_chat_atomic_invalid_members(self):
before = self.c.call("GET", "/api/v1/chats?limit=100", actor=self.a, schema="ChatPage")["json"]
for members in ([self.a["id"], str(uuid4())], [self.a["id"], self.a["id"]], [self.b["id"]]):
self.c.call("POST", "/api/v1/chats", 400, actor=self.a, body={"title": "rollback", "member_ids": members})
after = self.c.call("GET", "/api/v1/chats?limit=100", actor=self.a, schema="ChatPage")["json"]
self.assertEqual(before, after)
def test_username_race(self):
body = dict(self.a["registration"], username="race_" + uuid4().hex[:16])
def register(_):
return Client(self.c.base).call("POST", "/api/v1/users", [201, 409], body=body)["status"]
with ThreadPoolExecutor(max_workers=6) as pool:
statuses = list(pool.map(register, range(6)))
self.assertEqual(statuses.count(201), 1)
self.assertEqual(statuses.count(409), 5)
def test_concurrent_messages_and_keyset(self):
def send(i):
return Client(self.c.base).message(self.a, self.chat, "Поток " + str(i))["json"]
with ThreadPoolExecutor(max_workers=8) as pool:
sent = list(pool.map(send, range(40)))
items, cursor = [], None
while True:
page = self.c.call("GET", self.path + "/messages?limit=7" + ("&cursor=" + quote(cursor) if cursor else ""), actor=self.b, schema="MessagePage")["json"]
items.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
break
self.assertEqual(len(items), 40)
self.assertEqual({x["id"] for x in items}, {x["id"] for x in sent})
self.assertEqual(items, sorted(sent, key=lambda x: (x["created_at"], x["id"])))
def test_cursor_scope_and_tampering(self):
for i in range(3):
self.c.message(self.a, self.chat, str(i))
page = self.c.call("GET", self.path + "/messages?limit=1", actor=self.a, schema="MessagePage")["json"]
cursor = page["next_cursor"]
self.c.call("GET", "/api/v1/chats?cursor=" + quote(cursor), 400, actor=self.a)
other = self.c.call("POST", "/api/v1/chats", 201, actor=self.a, body={"title": "Другой", "member_ids": [self.a["id"]]}, schema="Chat")["json"]
self.c.call("GET", "/api/v1/chats/" + other["id"] + "/messages?cursor=" + quote(cursor), 400, actor=self.a)
self.c.call("GET", self.path + "/messages?cursor=" + quote("X" + cursor[1:]), 400, actor=self.a)
def test_json_and_sender_validation(self):
for raw in (b'{"text":"a","text":"b"}', b'{"text":NaN}', b'{', b'{"text":"\\u0000"}'):
self.c.call("POST", self.path + "/messages", 400, actor=self.a, raw=raw, headers={"Content-Type": "application/json", "Idempotency-Key": uuid4().hex})
self.c.call("POST", self.path + "/messages", 400, actor=self.a, body={"text": "hello", "sender_id": self.b["id"]})
self.c.call("POST", self.path + "/messages", 400, actor=self.a, body={"text": " "})
page = self.c.call("GET", self.path + "/messages", actor=self.a, schema="MessagePage")["json"]
self.assertEqual(page["items"], [])
def test_access_before_payload_validation(self):
self.c.call("POST", self.path + "/messages", 404, actor=self.e, body={})
self.c.call("POST", self.path + "/messages", 401, body={})
self.c.call("GET", self.path, 404, actor=self.e)
if __name__ == "__main__":
unittest.main()
+68
View File
@@ -0,0 +1,68 @@
"""Real HTTP races through the LB, with one shared session and key."""
from concurrent.futures import ThreadPoolExecutor
import os
from pathlib import Path
import sys
import threading
import unittest
from uuid import uuid4
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "tests"))
from client import Client
class Idempotency(unittest.TestCase):
def setUp(self):
self.c = Client(os.environ.get("BASE_URL", "http://127.0.0.1:8080"))
self.a, self.b, self.e, self.chat = self.c.bootstrap()
self.path = "/api/v1/chats/" + self.chat["id"] + "/messages"
def test_same_key_concurrent_across_replicas(self):
key, barrier = uuid4().hex, threading.Barrier(12)
def send(_):
c = Client(self.c.base)
barrier.wait(timeout=10)
return c.message(self.a, self.chat, "Один результат 👋", key=key)
with ThreadPoolExecutor(max_workers=12) as pool:
results = list(pool.map(send, range(12)))
self.assertGreaterEqual(len({r["headers"]["X-Instance-Id"] for r in results}), 2)
self.assertTrue(all(r["json"] == results[0]["json"] for r in results))
history = self.c.call("GET", self.path, actor=self.b, schema="MessagePage")["json"]
self.assertEqual(history["items"], [results[0]["json"]])
print("PASS: concurrent_retries=12 observed_replicas=2 committed_messages=1", flush=True)
def test_conflicting_bodies_race(self):
key, barrier = uuid4().hex, threading.Barrier(2)
def send(text):
c = Client(self.c.base)
barrier.wait(timeout=10)
return c.call("POST", self.path, [201, 409], actor=self.a,
body={"text": text}, headers={"Idempotency-Key": key})
with ThreadPoolExecutor(max_workers=2) as pool:
results = list(pool.map(send, ["first", "second"]))
self.assertEqual(sorted(r["status"] for r in results), [201, 409])
history = self.c.call("GET", self.path, actor=self.a, schema="MessagePage")["json"]
self.assertEqual(len(history["items"]), 1)
def test_key_scope_and_access(self):
key = uuid4().hex
one = self.c.message(self.a, self.chat, "first", key=key)["json"]
two = self.c.message(self.b, self.chat, "second", key=key)["json"]
other = self.c.call("POST", "/api/v1/chats", 201, actor=self.a,
body={"title": "other", "member_ids": [self.a["id"]]}, schema="Chat")["json"]
three = self.c.message(self.a, other, "third", key=key)["json"]
self.assertEqual(len({m["id"] for m in (one, two, three)}), 3)
self.c.call("POST", self.path, 404, actor=self.e, body={"text": "first"}, headers={"Idempotency-Key": key})
self.c.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=self.a)
self.c.call("POST", self.path, 401, actor=self.a, body={"text": "first"}, headers={"Idempotency-Key": key})
def test_invalid_keys_and_no_cached_error(self):
for key in ("", "a" * 129, "has space", "bad/key", "bad,key"):
self.c.call("POST", self.path, 400, actor=self.a, body={"text": "hello"}, headers={"Idempotency-Key": key})
key = uuid4().hex
self.c.call("POST", self.path, 400, actor=self.a, body={"text": " "}, headers={"Idempotency-Key": key})
self.c.message(self.a, self.chat, "valid after rejected body", key=key)
if __name__ == "__main__":
unittest.main()