ЛР 3 — БПИ2303 — Щербаков — на 3 #148
+4
-10
@@ -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.
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
*.sh text eol=lf
|
||||
*.cmd text eol=crlf
|
||||
*.py text eol=lf
|
||||
*.sql text eol=lf
|
||||
*.yaml text eol=lf
|
||||
@@ -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 содержит инструкцию именно моего решения.
|
||||
|
||||
@@ -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
@@ -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"]
|
||||
@@ -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).
|
||||
|
||||
@@ -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».
|
||||
@@ -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
|
||||
@@ -0,0 +1 @@
|
||||
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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.
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -0,0 +1,3 @@
|
||||
psycopg[binary]==3.2.6
|
||||
psycopg-pool==3.2.6
|
||||
typing_extensions==4.16.0
|
||||
@@ -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.")
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
docker compose --env-file .env restart postgres api1 api2 lb
|
||||
exit /b %errorlevel%
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres api1 api2 lb
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
cd /d "%~dp0.."
|
||||
python scripts/stop_one.py
|
||||
exit /b %errorlevel%
|
||||
Executable
+4
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
exec "${PYTHON:-python3}" scripts/stop_one.py
|
||||
@@ -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)
|
||||
@@ -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()
|
||||
@@ -0,0 +1 @@
|
||||
"""Lab 1: a single-process, in-memory messenger."""
|
||||
@@ -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()
|
||||
@@ -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")
|
||||
@@ -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()
|
||||
@@ -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
@@ -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
@@ -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")
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user