forked from mtusi2026/mtusi2026lab3
Добавить приложение, Compose и отчёт
This commit is contained in:
@@ -1,37 +1,101 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Койчакаев Багавдин, БВТ2301.
|
||||
- Целевая оценка: 5; законченный трек: 1 — цена масштабирования.
|
||||
- Состав реализации: API ЛР2, HAProxy, минимум две API-реплики, общие PostgreSQL и Valkey, конкурентная идемпотентность в PostgreSQL.
|
||||
- Внешние источники: контракт и материалы курса. Использованы Python 3.12.8, psycopg 3.2.3, argon2-cffi 23.1.0, redis-py 5.2.1; при подготовке использовался Codex.
|
||||
|
||||
## Запуск из чистого clone
|
||||
## Запуск
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
```sh
|
||||
cp .env.example .env
|
||||
# задайте POSTGRES_PASSWORD и CURSOR_SECRET (случайный ключ минимум 32 байта)
|
||||
docker compose --env-file .env config --quiet
|
||||
docker compose --env-file .env up -d --build --scale api=2 --wait --wait-timeout 180
|
||||
make check
|
||||
make validate
|
||||
make test BASE_URL=http://127.0.0.1:8080
|
||||
make test-idempotency BASE_URL=http://127.0.0.1:8080
|
||||
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
|
||||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
Приложение слушает только внутреннюю сеть Compose. Единственный опубликованный порт — loopback порт HAProxy 8080. Миграции запускает одноразовый сервис `migrate` перед API, под advisory lock PostgreSQL. Первая схема сохраняется совместимой с базой ЛР2; миграция `002_idempotency` добавляет таблицу ключей и индекс срока хранения.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```text
|
||||
HTTP client → HAProxy :8080 → API × 2+ → PostgreSQL (messages, sessions, idempotency)
|
||||
↘ общий Valkey (TTL lookup hint; PostgreSQL остаётся источником истины)
|
||||
```
|
||||
|
||||
## Доказательства критериев
|
||||
HAProxy round-robin балансирует запросы между адресами DNS `api`, повторно разрешая адрес каждые 2 секунды. Проверка `GET /health/ready` выполняется раз в секунду; две ошибки исключают backend, два успеха возвращают его. Connect timeout — 1 секунда, timeout ожидания/ответа — 10 секунд. API слушает `0.0.0.0:8080` внутри сети и на SIGTERM прекращает `serve_forever`; Compose ждёт до 10 секунд для штатного завершения.
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
Сессия проверяется PostgreSQL на каждом запросе; значение Valkey лишь ускоряет lookup и не авторизует пользователя без живой строки в PostgreSQL. Общий `CURSOR_SECRET` нужен, чтобы cursor истории, созданный одной репликой, принимался другой. Секрет и пароль БД находятся только в локальном `.env`, игнорируемом Git и Docker build context.
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
Для каждого POST сообщения обязателен ключ `[A-Za-z0-9._:-]{1,128}`. Уникальная область — пользователь, метод, путь чата и ключ; body хешируется после нормализации JSON, а пропущенный `attachment_ids` равен `[]`. `pg_advisory_xact_lock` сериализует одновременные запросы одной области во всех API-процессах; PostgreSQL хранит отпечаток body и точный JSON результата вместе с сообщением в одной транзакции. Совпавший запрос возвращает тот же `201` и Message; отличающийся body — `409`; запись можно использовать заново спустя 24 часа. Ошибка/откат транзакции не оставляет частично зарегистрированный ключ. Каждый API-ответ включая ошибку содержит непустой `X-Request-Id` и идентификатор процесса в `X-Instance-Id`.
|
||||
|
||||
## Эксперименты и отказы
|
||||
### Роли и версии
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
| Роль | Service | Версия | Health/volume/порты |
|
||||
|---|---|---|---|
|
||||
| API | `api` (Compose scale) | Python 3.12.8 slim Bookworm, pinned digest в Dockerfile | `/health/ready`, без host-порта, без локального состояния |
|
||||
| Балансировщик | `haproxy` | 3.0.8 Alpine | HAProxy backend checks, единственный порт `127.0.0.1:8080` |
|
||||
| База | `postgres` | 16.4 Bookworm | `pg_isready`, общий volume `postgres_data`, внутренний порт 5432 |
|
||||
| Кэш сессий | `valkey` | 8.0.1 Alpine | `PING`, volume `valkey_data`, AOF `everysec`, внутренний порт 6379 |
|
||||
| Миграции | `migrate` | тот же образ API | одноразовый контейнер; выполняется до запуска реплик |
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
CPU/RAM limits заданы в compose для API, HAProxy, PostgreSQL и Valkey. `api` не имеет `container_name`, поэтому штатное горизонтальное масштабирование поддерживается.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
## Проверки уровня 3 и 4
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Публичный smoke проверяет обязательный API через HAProxy. Дополнительный параллельный тест запускает 32 запроса с одним ключом и одним body одновременно; все ответы вернули один ID сообщения, наблюдались две реплики. Persistence-сценарий перезапустил API, HAProxy, PostgreSQL и Valkey без удаления volumes; тот же Bearer-токен прочитал те же данные. Три failover-прогона остановили API-реплику по очереди и повторили сценарий после восстановления. Каждый наблюдал две реплики до отказа; новые записи восстановились за 2,902 с, 1,543 с и 1,447 с; ошибок было 0 во всех трёх прогонах (113, 125 и 114 успешных записей); сообщение до отказа и все подтверждённые записи остались доступны, дубли отсутствовали. В конце теста остановленная реплика оставалась остановленной; Compose восстановил её перед следующим прогоном и после финальной проверки.
|
||||
|
||||
Rolling replacement под нагрузкой выполняется скриптом `scripts/rolling-update.sh`: пул сначала увеличивается до трёх, затем контейнеры заменяются по одному с сохранением активного backend. Под нагрузкой 60 секунд, concurrency 16: 50 291 успешная запись (836,949 RPS), 24 ошибки из 50 315 запросов (0,048%), p50/p95/p99 = 6,118/55,938/85,729 мс. После завершения пул восстановлен до двух здоровых реплик. Метрики сохранены в `evidence/rolling-update-load.json`; успешность запросов при замене не абсолютная, что отражено в ограничениях.
|
||||
|
||||
## Трек 1 — цена масштабирования
|
||||
|
||||
**Гипотеза.** При равном суммарном CPU/RAM перенос ресурса с одного API на несколько реплик улучшит RPS только до насыщения общей PostgreSQL или пула соединений. При фиксированной мощности на реплику добавление API в какой-то момент перестанет повышать throughput; увеличение пула сверх полезного уровня добавит конкуренцию за БД, а не пропускную способность.
|
||||
|
||||
**Методика.** `scripts/track1_experiment.py` пересоздаёт API при каждом профиле, ждёт readiness и 5 секунд стабилизации, затем трижды измеряет закрытый цикл POST-сообщений по 30 секунд с concurrency 16. Перед каждым sample очищаются только учебные таблицы `messages` и `idempotency_keys`, затем выполняется `ANALYZE`; порядок вариантов перемешивается детерминированным seed. Сессии/пользователи остаются в PostgreSQL. Фиксированный бюджет: 2 vCPU и 1 GiB RAM суммарно для API, разделённые между 1/2/4 репликами. Серия роста: 0,5 vCPU и 256 MiB на реплику для 1/2/4/8 реплик. Отдельное сравнение при четырёх репликах меняет `DB_POOL_MAX` 5/10/20. PostgreSQL ограничен 2 CPU и 1 GiB; HAProxy — 0,25 CPU и 128 MiB. Записываются успешные RPS, ошибки, p50/p95/p99, CPU/RAM компонентов и число сообщений. Сводки и исходные данные — `evidence/track1-results.json`, график — `evidence/track1-rps.svg`.
|
||||
|
||||
Чтобы определить точку насыщения, `scripts/track1_offered_load.py` подаёт фиксированный поток 250/500/750/1000 POST RPS на восемь API-реплик (0,5 CPU / 256 MiB каждая) по три раза в перемешанном порядке; HTTP-клиент переиспользуется в потоках, число in-flight ограничено, Docker stats во время нагрузочного окна не опрашивается. Throughput рассчитан по фактическому времени вместе с drain. Затем `scripts/track1_offered_scale.py` делает три парных прогона 8/12 реплик при предложенных 1000 RPS. Между повторами масштабирование возвращается к восьми репликам, чтобы освободить DB-соединения до очистки синтетических таблиц. Все исходные измерения лежат в `evidence/offered-load-results.json` и `evidence/offered-scale-results.json`; график rate sweep — `evidence/offered-load.svg`.
|
||||
|
||||
| Профиль | Реплики | Пул/реплика | медиана RPS (min–max) | медиана ошибок | p50/p95/p99, ms | API CPU mean/peak, % | API RAM peak, MiB |
|
||||
|---|---:|---:|---:|---:|---:|---:|---:|
|
||||
| fixed-1 | 1 | 10 | 418,5 (389,7–456,3) | 0,017% | 32,3/53,0/82,4 | 174,3/190,2 | 61,9 |
|
||||
| fixed-2 | 2 | 10 | 698,6 (653,6–749,2) | 0% | 8,0/62,4/92,9 | 74,0/109,5 | 60,9 |
|
||||
| fixed-4 | 4 | 10 | 837,7 (590,7–900,3) | 0,007% | 5,2/57,5/101,9 | 38,2/53,3 | 62,4 |
|
||||
| scaled-1 | 1 | 10 | 103,7 (102,1–108,8) | 0,064% | 111,1/313,3/484,9 | 47,8/53,3 | 83,5 |
|
||||
| scaled-2 | 2 | 10 | 274,6 (244,8–276,3) | 0,048% | 22,9/183,7/290,4 | 37,6/52,9 | 140,0 |
|
||||
| scaled-4 | 4 | 10 | 680,7 (635,3–875,7) | 0% | 6,0/71,0/123,1 | 40,8/53,2 | 79,2 |
|
||||
| scaled-8 | 8 | 10 | 764,2 (655,4–787,6) | 0% | 9,5/70,6/111,2 | 29,0/50,1 | 82,0 |
|
||||
| pool-5 | 4 | 5 | 921,2 (837,9–1061,3) | 0,003% | 5,3/49,2/89,8 | 40,4/53,3 | 62,6 |
|
||||
| pool-10 | 4 | 10 | 808,9 (611,5–969,2) | 0,020% | 5,5/66,7/108,3 | 38,9/51,9 | 99,5 |
|
||||
| pool-20 | 4 | 20 | 951,3 (573,5–1044,2) | 0,003% | 5,4/45,3/89,2 | 41,7/52,5 | 63,1 |
|
||||
|
||||
Среда: macOS 26.5.1 arm64, 8 host CPU; Docker Engine 29.8.2; Docker VM 8 CPU / 4 106 605 444 байта RAM (~3 918 MiB); Python клиента 3.14.6; Python API 3.12.8; PostgreSQL 16.4. Закрытая серия длилась 30 секунд, rate-controlled серия — 15 секунд на sample. Во всех замерах JSON фиксирует размер синтетических таблиц; перед sample `messages` и `idempotency_keys` очищались, остальные пользовательские данные сохранялись. Closed-loop percentiles подвержены coordinated omission; rate-controlled серия имеет короткие окна и оценивает только эту среду. Все результаты ограничены одним Docker-host; потеря узла одновременно затрагивает API, HAProxy, PostgreSQL и локальные volumes.
|
||||
|
||||
| Предложено, RPS | Медиана успешных RPS (min–max) | Медиана ошибок | Медиана p95, ms |
|
||||
|---:|---:|---:|---:|
|
||||
| 250 | 249,6 (249,6–250,0) | 0% | 9,9 |
|
||||
| 500 | 499,6 (419,6–499,9) | 0% | 41,6 |
|
||||
| 750 | 745,9 (693,2–748,7) | 0,018% | 100,9 |
|
||||
| 1000 | 810,1 (553,2–879,3) | 2,753% | 1 611,3 |
|
||||
|
||||
Парное сравнение при 1000 предложенных RPS:
|
||||
|
||||
| API-реплик | Успешные RPS, медиана (min–max) | p95, медиана, ms | Ошибки POST за 3 повтора | Диагностика PostgreSQL |
|
||||
|---:|---:|---:|---:|---|
|
||||
| 8 | 727,0 (584,4–851,5) | 1 504,7 | 874 / 45 000 | `SELECT` прошёл |
|
||||
| 12 | 555,8 (546,0–774,9) | 1 986,4 | 12 / 45 000 | Все 3 запроса отклонены: `too many clients already` |
|
||||
|
||||
**Поиск насыщения и улучшение.** В rate-controlled серии 250 и 500 предложенных RPS полностью принимались без ошибок (медианный p95 9,9 и 41,6 мс). При 750 RPS медиана успешной пропускной способности составила 745,9 RPS, p95 — 100,9 мс. При 1000 RPS throughput вырос лишь до 810,1 RPS, медианная доля ошибок достигла 2,75%, а p95 — 1 611 мс. Это показывает knee общей цепочки между 750 и 1000 RPS; повторяемость ограничена тремя короткими прогонами, поэтому это не универсальная производственная ёмкость.
|
||||
|
||||
Компонентное ограничение установлено отдельной проверкой DB-пула. При `DB_POOL_MAX=10` восемь реплик могут открыть до 80 соединений, а двенадцать — до 120. Фактический `max_connections` PostgreSQL равен 100. В трёх прогонах с 12 репликами и нагрузкой 1000 RPS, помимо роста задержки, PostgreSQL трижды отказал даже в диагностическом `SELECT` с `FATAL: sorry, too many clients already`; после возврата к восьми репликам запросы к БД снова проходили. Наблюдение сохранено в `evidence/db-saturation-observation.txt`, а метрики сравнения — `evidence/offered-scale-results.json`. Таким образом, насыщение пула/БД возникает между восемью и двенадцатью репликами при текущем лимите пула; дальнейшее увеличение API без снижения размера пула или повышения DB connection budget ухудшает доступность общих соединений. 8→12 RPS-диапазоны перекрываются, поэтому причинный вывод основан на подтверждённом исчерпании connection slots, а не только на падении медианного throughput.
|
||||
|
||||
Подтверждённое улучшение при фиксированном суммарном бюджете 2 vCPU / 1 GiB: переход fixed-1→fixed-2 поднял медиану с 418,5 до 698,6 RPS (+66,9%); диапазоны трёх повторов не пересекаются (389,7–456,3 и 653,6–749,2 RPS). p50 снизился с 32,3 до 8,0 мс, p95 изменился с 53,0 до 62,4 мс. Серии DB_POOL_MAX=5/10/20 при низкой конкуренции и HAProxy 0,25/0,5 CPU имеют перекрывающиеся диапазоны; их эффект не заявляется как отдельное улучшение. Все измерения ограничены одной Docker VM и конкретным синтетическим профилем.
|
||||
|
||||
## Результаты и ограничения
|
||||
|
||||
Офлайн структурная проверка, API smoke, гонка идемпотентности, перезапуск и failover пройдены; подробный stdout сохранён в `evidence/lab3-checks.txt`. Полная OpenAPI/JSON Schema проверка требует `openapi-spec-validator==0.7.2` из `requirements-dev.txt`; установить зависимость в этой среде не удалось из-за недоступного DNS PyPI. HTTP используется только на loopback для синтетических данных. Эта схема выдерживает отказ одного API-процесса при работающих HAProxy, host, PostgreSQL и Valkey; она не выдерживает потерю Docker-host, HAProxy или PostgreSQL. При отказе Valkey действующие сессии проверяются по PostgreSQL. Отдельной HA базы данных и второго узла нет. Под нагрузкой при rolling replacement замерены 24 ошибки на 50 315 запросов (0,048%); для повторения именно операции создания сообщения клиент должен повторить запрос с тем же `Idempotency-Key`. Другие POST-операции не обещают прозрачную идемпотентность.
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
services:
|
||||
migrate:
|
||||
build: .
|
||||
command: ["python", "server.py"]
|
||||
environment:
|
||||
RUN_MIGRATIONS_ONLY: "1"
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
CACHE_URL: redis://valkey:6379/0
|
||||
depends_on:
|
||||
postgres: { condition: service_healthy }
|
||||
valkey: { condition: service_healthy }
|
||||
restart: "no"
|
||||
api:
|
||||
build: .
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
APP_HOST: 0.0.0.0
|
||||
APP_PORT: 8080
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
CURSOR_SECRET: ${CURSOR_SECRET:?Set CURSOR_SECRET in .env}
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
CACHE_URL: redis://valkey:6379/0
|
||||
DB_POOL_MAX: ${DB_POOL_MAX:-10}
|
||||
DB_POOL_MIN: ${DB_POOL_MIN:-1}
|
||||
depends_on:
|
||||
migrate: { condition: service_completed_successfully }
|
||||
valkey: { condition: service_healthy }
|
||||
cpus: ${API_CPUS:-1.0}
|
||||
mem_limit: ${API_MEMORY:-512m}
|
||||
stop_grace_period: 10s
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"]
|
||||
interval: 2s
|
||||
timeout: 3s
|
||||
retries: 2
|
||||
start_period: 10s
|
||||
postgres:
|
||||
image: postgres:16.4-bookworm
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
volumes: ["postgres_data:/var/lib/postgresql/data"]
|
||||
cpus: 2.0
|
||||
mem_limit: 1g
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U \"$$POSTGRES_USER\" -d \"$$POSTGRES_DB\""]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
valkey:
|
||||
image: valkey/valkey:8.0.1-alpine
|
||||
restart: unless-stopped
|
||||
command: ["valkey-server", "--appendonly", "yes", "--appendfsync", "everysec"]
|
||||
volumes: ["valkey_data:/data"]
|
||||
cpus: 0.25
|
||||
mem_limit: 128m
|
||||
healthcheck:
|
||||
test: ["CMD", "valkey-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
haproxy:
|
||||
image: haproxy:3.0.8-alpine
|
||||
restart: unless-stopped
|
||||
ports: ["127.0.0.1:${APP_PORT:-8080}:8080"]
|
||||
volumes: ["./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro"]
|
||||
depends_on: [api]
|
||||
cpus: ${LB_CPUS:-0.25}
|
||||
mem_limit: 128m
|
||||
healthcheck:
|
||||
test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"]
|
||||
interval: 10s
|
||||
timeout: 3s
|
||||
retries: 3
|
||||
volumes:
|
||||
postgres_data:
|
||||
valkey_data:
|
||||
@@ -0,0 +1,9 @@
|
||||
argon2-cffi==23.1.0
|
||||
argon2-cffi-bindings==26.1.0
|
||||
cffi==2.1.1
|
||||
pycparser==3.12
|
||||
psycopg[binary,pool]==3.2.3
|
||||
psycopg-binary==3.2.3
|
||||
psycopg-pool==3.3.3
|
||||
redis==5.2.1
|
||||
typing_extensions==4.16.0
|
||||
@@ -0,0 +1,317 @@
|
||||
#!/usr/bin/env python3
|
||||
"""PostgreSQL-backed messenger API for MTUSI lab 2."""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64, binascii, hashlib, json, logging, os, re, secrets, signal, socket, threading, time, uuid
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
|
||||
import psycopg
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool, PoolTimeout
|
||||
import redis
|
||||
from argon2 import PasswordHasher, exceptions as argon_exc
|
||||
|
||||
LOG = logging.getLogger("messenger")
|
||||
USERNAME_RE = re.compile(r"\A[a-z0-9_]{3,32}\Z")
|
||||
POOL: ConnectionPool | None = None
|
||||
CACHE: redis.Redis | None = None
|
||||
PASSWORDS = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1)
|
||||
MAX_BODY_BYTES = 1024 * 1024
|
||||
CURSOR_SECRET = os.getenv("CURSOR_SECRET", "local-only-change-this-cursor-secret").encode("utf-8")
|
||||
INSTANCE_ID = os.getenv("API_INSTANCE_ID") or socket.gethostname() or str(uuid.uuid4())
|
||||
IDEMPOTENCY_KEY_RE = re.compile(r"\A[A-Za-z0-9._:-]{1,128}\Z")
|
||||
|
||||
def utcnow() -> datetime: return datetime.now(timezone.utc)
|
||||
def stamp(value: datetime) -> str: return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
def new_id() -> str: return str(uuid.uuid4())
|
||||
|
||||
class ApiError(Exception):
|
||||
def __init__(self, status, code, message): self.status, self.code, self.message = status, code, message
|
||||
|
||||
def invalid(message="Некорректный запрос"): raise ApiError(400, "invalid_request", message)
|
||||
def unavailable(): raise ApiError(503, "unavailable", "Зависимость временно недоступна")
|
||||
|
||||
def db():
|
||||
assert POOL is not None
|
||||
return POOL.connection()
|
||||
|
||||
def migrate():
|
||||
migrations = Path(__file__).parent / "migrations"
|
||||
with db() as conn:
|
||||
conn.execute("SELECT pg_advisory_xact_lock(2026102802)")
|
||||
conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations (version text PRIMARY KEY, applied_at timestamptz NOT NULL DEFAULT now())")
|
||||
for migration in sorted(migrations.glob("*.sql")):
|
||||
version = migration.stem
|
||||
if conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (version,)).fetchone() is None:
|
||||
conn.execute(migration.read_text(encoding="utf-8"))
|
||||
conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (version,))
|
||||
|
||||
def as_user(row): return {"id": str(row["id"]), "username": row["username"], "display_name": row["display_name"], "created_at": stamp(row["created_at"])}
|
||||
def as_chat(row, members): return {"id": str(row["id"]), "title": row["title"], "member_ids": [str(x) for x in members], "created_at": stamp(row["created_at"])}
|
||||
def as_message(row): return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": row["text"], "created_at": stamp(row["created_at"])}
|
||||
|
||||
def require_text(value, field, maximum):
|
||||
if not isinstance(value, str) or not value.strip() or len(value) > maximum: invalid(f"Поле {field} должно содержать от 1 до {maximum} символов и не быть пустым")
|
||||
try: value.encode("utf-8")
|
||||
except UnicodeEncodeError: invalid(f"Поле {field} должно содержать корректный Unicode")
|
||||
return value
|
||||
|
||||
def strict_object(value, allowed, required):
|
||||
if not isinstance(value, dict) or set(value)-allowed or required-set(value): invalid("Тело запроса содержит неверные поля")
|
||||
return value
|
||||
|
||||
def parse_uuid(value, label="UUID"):
|
||||
try: return str(uuid.UUID(value))
|
||||
except (ValueError, TypeError, AttributeError): invalid(f"Некорректный {label}")
|
||||
|
||||
def cursor_encode(scope, row):
|
||||
obj = {"scope":scope,"created_at":stamp(row["created_at"]),"id":str(row["id"])}
|
||||
raw = json.dumps(obj,separators=(",",":"),ensure_ascii=True).encode()
|
||||
sig = hashlib.sha256(CURSOR_SECRET+raw).digest()[:12]
|
||||
return base64.urlsafe_b64encode(raw+sig).decode().rstrip("=")
|
||||
|
||||
def cursor_decode(value, scope):
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(value+"="*(-len(value)%4)); payload,sig=raw[:-12],raw[-12:]
|
||||
if not secrets.compare_digest(sig,hashlib.sha256(CURSOR_SECRET+payload).digest()[:12]): invalid("Некорректный cursor")
|
||||
obj=json.loads(payload)
|
||||
if set(obj)!={"scope","created_at","id"} or obj["scope"]!=scope: invalid("Cursor относится к другому списку")
|
||||
dt=datetime.fromisoformat(obj["created_at"].replace("Z","+00:00")); return dt,parse_uuid(obj["id"])
|
||||
except (ValueError,TypeError,KeyError,binascii.Error): invalid("Некорректный cursor")
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
protocol_version="HTTP/1.0"
|
||||
def setup(self): super().setup(); self.connection.settimeout(3)
|
||||
def log_message(self, fmt,*args): LOG.info("%s %s %s",self.command,urlsplit(self.path).path,args[1] if len(args)>1 else "")
|
||||
def do_GET(self): self.dispatch()
|
||||
def do_POST(self): self.dispatch()
|
||||
def do_DELETE(self): self.dispatch()
|
||||
|
||||
def send_json(self,status,payload,headers=None):
|
||||
body=json.dumps(payload,ensure_ascii=False,separators=(",",":")).encode()
|
||||
self.send_response(status); self.send_header("Content-Type","application/json; charset=utf-8"); self.send_header("Content-Length",str(len(body)))
|
||||
self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID)
|
||||
for k,v in (headers or {}).items(): self.send_header(k,v)
|
||||
self.end_headers(); self.wfile.write(body)
|
||||
def empty(self,status,headers=None):
|
||||
self.send_response(status); self.send_header("Content-Length","0"); self.send_header("X-Request-Id",self.request_id); self.send_header("X-Instance-Id",INSTANCE_ID)
|
||||
for k,v in (headers or {}).items(): self.send_header(k,v)
|
||||
self.end_headers()
|
||||
def error(self,e): self.send_json(e.status,{"error":{"code":e.code,"message":e.message,"request_id":self.request_id}},getattr(e,"headers",None))
|
||||
def read_json(self):
|
||||
if self.headers.get_content_type()!="application/json": raise ApiError(415,"unsupported_media_type","Ожидается Content-Type: application/json")
|
||||
try: n=int(self.headers.get("Content-Length",""))
|
||||
except ValueError: invalid("Некорректный Content-Length")
|
||||
if n<0: invalid("Некорректный Content-Length")
|
||||
if n>MAX_BODY_BYTES: raise ApiError(413,"payload_too_large","Тело запроса слишком велико")
|
||||
raw=self.rfile.read(n)
|
||||
if len(raw)!=n: invalid("Тело запроса передано не полностью")
|
||||
try: val=json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeError,json.JSONDecodeError): invalid("Тело запроса должно быть корректным JSON UTF-8")
|
||||
if not isinstance(val,dict): invalid("Тело запроса должно быть JSON-объектом")
|
||||
return val
|
||||
def challenge(self,scheme):
|
||||
e=ApiError(401,"unauthorized","Нет действительной сессии"); e.headers={"WWW-Authenticate":scheme}; raise e
|
||||
|
||||
def authenticate(self):
|
||||
header=self.headers.get("Authorization","")
|
||||
if not header.startswith("Bearer "): self.challenge('Bearer realm="messenger"')
|
||||
token=header[7:].strip()
|
||||
if not token or len(token)>256: self.challenge('Bearer realm="messenger"')
|
||||
digest=hashlib.sha256(token.encode()).hexdigest(); cache_key="sess:"+digest
|
||||
uid=None
|
||||
if CACHE:
|
||||
try: uid=CACHE.get(cache_key)
|
||||
except redis.RedisError: pass
|
||||
with db() as conn:
|
||||
# Valkey's expiring user ID is a lookup hint. PostgreSQL validates it
|
||||
# against the live session on every request, so missed cache deletion
|
||||
# during an outage can never keep a logged-out token valid.
|
||||
row=None
|
||||
if uid:
|
||||
row=conn.execute("SELECT u.id,u.username,u.display_name,u.created_at,s.expires_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.user_id=%s AND s.expires_at>now()",(digest,uid)).fetchone()
|
||||
if not row:
|
||||
row=conn.execute("SELECT u.id,u.username,u.display_name,u.created_at,s.expires_at FROM sessions s JOIN users u ON u.id=s.user_id WHERE s.token_hash=%s AND s.expires_at>now()",(digest,)).fetchone()
|
||||
if not row: self.challenge('Bearer realm="messenger"')
|
||||
if CACHE and str(row["id"])!=uid:
|
||||
try: CACHE.setex(cache_key,max(1,int((row["expires_at"]-utcnow()).total_seconds())),str(row["id"]))
|
||||
except redis.RedisError: pass
|
||||
return as_user(row),digest
|
||||
|
||||
def dispatch(self):
|
||||
self.request_id=secrets.token_hex(16)
|
||||
try:
|
||||
split=urlsplit(self.path); path=split.path; q=parse_qs(split.query,keep_blank_values=True)
|
||||
if path in ("/health/live","/health/ready"):
|
||||
if self.command!="GET" or q: invalid("Health endpoint принимает только GET без параметров")
|
||||
if path.endswith("ready"):
|
||||
try:
|
||||
with db() as c: c.execute("SELECT 1")
|
||||
except Exception: unavailable()
|
||||
self.send_json(200,{"status":"ok"}); return
|
||||
if path=="/api/v1/users" and self.command=="POST": self.register(); return
|
||||
if path=="/api/v1/auth/sessions" and self.command=="POST": self.login(); return
|
||||
if path=="/api/v1/auth/sessions/current" and self.command=="DELETE":
|
||||
actor,digest=self.authenticate()
|
||||
with db() as c: c.execute("DELETE FROM sessions WHERE token_hash=%s",(digest,))
|
||||
if CACHE:
|
||||
try: CACHE.delete("sess:"+digest)
|
||||
except redis.RedisError: pass
|
||||
self.empty(204); return
|
||||
actor,_=self.authenticate()
|
||||
if path=="/api/v1/users/me" and self.command=="GET": self.no_query(q); self.send_json(200,actor); return
|
||||
if path=="/api/v1/chats":
|
||||
if self.command=="POST": self.no_query(q); self.create_chat(actor); return
|
||||
if self.command=="GET": self.list_chats(actor,q); return
|
||||
m=re.fullmatch(r"/api/v1/chats/([^/]+)(?:/(messages))?",path)
|
||||
if m:
|
||||
cid=parse_uuid(m.group(1),"chat_id")
|
||||
if m.group(2)=="messages":
|
||||
if self.command=="POST": self.create_message(actor,cid); return
|
||||
if self.command=="GET": self.list_messages(actor,cid,q); return
|
||||
if self.command=="GET":
|
||||
self.no_query(q)
|
||||
with db() as c:
|
||||
row=c.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE c.id=%s AND m.user_id=%s",(cid,actor["id"])).fetchone()
|
||||
if not row: raise ApiError(404,"not_found","Объект не найден")
|
||||
ids=c.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id",(cid,)).fetchall()
|
||||
self.send_json(200,as_chat(row,[x["user_id"] for x in ids])); return
|
||||
raise ApiError(404,"not_found","Объект не найден")
|
||||
except ApiError as e: self.error(e)
|
||||
except (psycopg.Error,PoolTimeout,redis.RedisError) as e: LOG.warning("dependency error request_id=%s type=%s",self.request_id,type(e).__name__); self.error(ApiError(503,"unavailable","Зависимость временно недоступна"))
|
||||
except (BrokenPipeError,ConnectionResetError): pass
|
||||
except Exception: LOG.exception("request failed request_id=%s",self.request_id); self.error(ApiError(500,"internal_error","Внутренняя ошибка сервера"))
|
||||
|
||||
def no_query(self,q):
|
||||
if q: invalid("Этот endpoint не принимает query-параметры")
|
||||
def register(self):
|
||||
b=strict_object(self.read_json(),{"username","display_name","password"},{"username","display_name","password"})
|
||||
if not isinstance(b["username"],str) or not USERNAME_RE.fullmatch(b["username"]): invalid("username должен соответствовать [a-z0-9_]{3,32}")
|
||||
name=require_text(b["display_name"],"display_name",100); password=b["password"]
|
||||
if not isinstance(password,str) or not 12<=len(password)<=128: invalid("password должен содержать от 12 до 128 символов")
|
||||
uid=new_id(); hashed=PASSWORDS.hash(password)
|
||||
try:
|
||||
with db() as c: row=c.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING id,username,display_name,created_at",(uid,b["username"],name,hashed)).fetchone()
|
||||
except psycopg.errors.UniqueViolation: raise ApiError(409,"conflict","username уже занят")
|
||||
self.send_json(201,as_user(row))
|
||||
def login(self):
|
||||
if self.headers.get("Content-Length") not in (None, "0", ""): invalid("POST /auth/sessions не принимает body")
|
||||
h=self.headers.get("Authorization","")
|
||||
try:
|
||||
if not h.startswith("Basic "): raise ValueError()
|
||||
userpass=base64.b64decode(h[6:],validate=True).decode("utf-8"); username,password=userpass.split(":",1)
|
||||
except (ValueError,UnicodeError,binascii.Error): self.challenge('Basic realm="messenger", charset="UTF-8"')
|
||||
with db() as c: row=c.execute("SELECT id,username,display_name,created_at,password_hash FROM users WHERE username=%s",(username,)).fetchone()
|
||||
# Verify a fixed dummy hash for unknown users to reduce timing-based enumeration.
|
||||
try: ok=PASSWORDS.verify(row["password_hash"] if row else DUMMY_HASH,password)
|
||||
except (argon_exc.VerificationError,ValueError): ok=False
|
||||
if not row or not ok: self.challenge('Basic realm="messenger", charset="UTF-8"')
|
||||
token=secrets.token_urlsafe(32); digest=hashlib.sha256(token.encode()).hexdigest(); ttl=int(os.getenv("SESSION_TTL_SECONDS","3600")); expires=utcnow()+timedelta(seconds=ttl)
|
||||
with db() as c: c.execute("INSERT INTO sessions(token_hash,user_id,expires_at) VALUES (%s,%s,%s)",(digest,row["id"],expires))
|
||||
if CACHE:
|
||||
try: CACHE.setex("sess:"+digest,ttl,str(row["id"]))
|
||||
except redis.RedisError: pass
|
||||
self.send_json(201,{"token":token,"token_type":"Bearer","expires_at":stamp(expires),"user":as_user(row)})
|
||||
|
||||
def create_chat(self,actor):
|
||||
b=strict_object(self.read_json(),{"title","member_ids"},{"title","member_ids"}); title=require_text(b["title"],"title",100); ids=b["member_ids"]
|
||||
if not isinstance(ids,list) or not 1<=len(ids)<=100: invalid("member_ids должен содержать от 1 до 100 UUID")
|
||||
ids=[parse_uuid(v,"member_id") for v in ids]
|
||||
if len(set(ids))!=len(ids): invalid("member_ids не должен содержать повторов")
|
||||
if actor["id"] not in ids: invalid("Создатель чата должен входить в member_ids")
|
||||
cid=new_id()
|
||||
try:
|
||||
with db() as c:
|
||||
known=c.execute("SELECT id FROM users WHERE id=ANY(%s)",(ids,)).fetchall()
|
||||
if len(known)!=len(ids): invalid("Все участники чата должны быть зарегистрированы")
|
||||
row=c.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING id,title,created_at",(cid,title)).fetchone()
|
||||
with c.cursor() as cursor:
|
||||
cursor.executemany("INSERT INTO chat_members(chat_id,user_id) VALUES (%s,%s)",[(cid,u) for u in ids])
|
||||
except psycopg.errors.ForeignKeyViolation: invalid("Все участники чата должны быть зарегистрированы")
|
||||
self.send_json(201,as_chat(row,ids))
|
||||
def parse_page(self,q,scope):
|
||||
if set(q)-{"limit","cursor"} or any(len(v)!=1 for v in q.values()): invalid("Неверные параметры пагинации")
|
||||
raw=q.get("limit",["50"])[0]
|
||||
if not re.fullmatch(r"[0-9]{1,3}",raw): invalid("limit должен быть целым числом от 1 до 100")
|
||||
limit=int(raw)
|
||||
if not 1<=limit<=100: invalid("limit должен быть целым числом от 1 до 100")
|
||||
cur=cursor_decode(q["cursor"][0],scope) if "cursor" in q and q["cursor"][0] else None
|
||||
if "cursor" in q and not q["cursor"][0]: invalid("cursor не должен быть пустым")
|
||||
return limit,cur
|
||||
def list_chats(self,actor,q):
|
||||
limit,cur=self.parse_page(q,"chats"); params=[actor["id"]]; clause=""
|
||||
if cur: clause=" AND (c.created_at,c.id)>(%s,%s)"; params.extend(cur)
|
||||
with db() as c:
|
||||
rows=c.execute("SELECT c.id,c.title,c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id WHERE m.user_id=%s"+clause+" ORDER BY c.created_at,c.id LIMIT %s",(*params,limit+1)).fetchall()
|
||||
items=[]
|
||||
for row in rows[:limit]:
|
||||
members=c.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id",(row["id"],)).fetchall(); items.append(as_chat(row,[m["user_id"] for m in members]))
|
||||
self.send_json(200,{"items":items,"next_cursor":cursor_encode("chats",rows[limit-1]) if len(rows)>limit else None})
|
||||
def create_message(self,actor,cid):
|
||||
self.no_query(parse_qs(urlsplit(self.path).query,keep_blank_values=True))
|
||||
key=self.headers.get("Idempotency-Key", "")
|
||||
if not IDEMPOTENCY_KEY_RE.fullmatch(key): invalid("Idempotency-Key обязателен и должен соответствовать [A-Za-z0-9._:-]{1,128}")
|
||||
with db() as c:
|
||||
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
|
||||
b=strict_object(self.read_json(),{"text","attachment_ids"},{"text"}); text=require_text(b["text"],"text",4000)
|
||||
attachment_ids=b.get("attachment_ids", [])
|
||||
if attachment_ids != []: invalid("Вложения не поддерживаются в лабораторной 3")
|
||||
canonical=json.dumps({"text":text,"attachment_ids":[]},ensure_ascii=False,sort_keys=True,separators=(",",":"))
|
||||
request_hash=hashlib.sha256(canonical.encode("utf-8")).hexdigest()
|
||||
resource_path=f"/api/v1/chats/{cid}/messages"
|
||||
scope=f"{actor['id']}\nPOST\n{resource_path}\n{key}"
|
||||
try:
|
||||
with db() as c:
|
||||
# One transaction-scoped lock serializes equal keys across API replicas.
|
||||
c.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s,0))",(scope,))
|
||||
old=c.execute("SELECT request_hash,response_body FROM idempotency_keys WHERE user_id=%s AND method='POST' AND resource_path=%s AND key=%s AND created_at>now()-interval '24 hours'",(actor["id"],resource_path,key)).fetchone()
|
||||
if old:
|
||||
if old["request_hash"]!=request_hash: raise ApiError(409,"conflict","Idempotency-Key уже использован с другим содержимым")
|
||||
payload=old["response_body"]
|
||||
else:
|
||||
c.execute("DELETE FROM idempotency_keys WHERE user_id=%s AND method='POST' AND resource_path=%s AND key=%s",(actor["id"],resource_path,key))
|
||||
row=c.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING id,chat_id,sender_id,text,created_at",(new_id(),cid,actor["id"],text)).fetchone()
|
||||
payload=as_message(row)
|
||||
c.execute("INSERT INTO idempotency_keys(user_id,method,resource_path,key,request_hash,response_body) VALUES (%s,'POST',%s,%s,%s,%s::jsonb)",(actor["id"],resource_path,key,request_hash,json.dumps(payload,ensure_ascii=False,separators=(",",":"))))
|
||||
except psycopg.errors.ForeignKeyViolation: raise ApiError(404,"not_found","Объект не найден")
|
||||
self.send_json(201,payload)
|
||||
def list_messages(self,actor,cid,q):
|
||||
with db() as c:
|
||||
if not c.execute("SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s",(cid,actor["id"])).fetchone(): raise ApiError(404,"not_found","Объект не найден")
|
||||
limit,cur=self.parse_page(q,"messages:"+cid); params=[cid]; clause=""
|
||||
if cur: clause=" AND (created_at,id)>(%s,%s)"; params.extend(cur)
|
||||
with db() as c: rows=c.execute("SELECT id,chat_id,sender_id,text,created_at FROM messages WHERE chat_id=%s"+clause+" ORDER BY created_at,id LIMIT %s",(*params,limit+1)).fetchall()
|
||||
self.send_json(200,{"items":[as_message(r) for r in rows[:limit]],"next_cursor":cursor_encode("messages:"+cid,rows[limit-1]) if len(rows)>limit else None})
|
||||
|
||||
class Server(ThreadingHTTPServer):
|
||||
daemon_threads=True; allow_reuse_address=True
|
||||
|
||||
def main():
|
||||
global POOL,CACHE,DUMMY_HASH
|
||||
logging.basicConfig(level=os.getenv("LOG_LEVEL","INFO").upper(),format="%(asctime)s %(levelname)s %(message)s")
|
||||
pool_max=int(os.getenv("DB_POOL_MAX","10"))
|
||||
if not 1<=pool_max<=50: raise SystemExit("DB_POOL_MAX must be between 1 and 50")
|
||||
POOL=ConnectionPool(os.getenv("DATABASE_URL","postgresql://messenger:messenger@postgres:5432/messenger"),min_size=int(os.getenv("DB_POOL_MIN","1")),max_size=pool_max,timeout=3,kwargs={"row_factory":dict_row},open=True)
|
||||
CACHE=redis.Redis.from_url(os.getenv("CACHE_URL","redis://valkey:6379/0"),socket_connect_timeout=0.5,socket_timeout=0.5,decode_responses=True)
|
||||
DUMMY_HASH=PASSWORDS.hash("dummy-password-do-not-use-123")
|
||||
deadline=time.monotonic()+60
|
||||
while True:
|
||||
try: migrate(); break
|
||||
except (psycopg.Error, PoolTimeout):
|
||||
if time.monotonic()>deadline: raise
|
||||
LOG.info("waiting for PostgreSQL"); time.sleep(1)
|
||||
if os.getenv("RUN_MIGRATIONS_ONLY") == "1":
|
||||
POOL.close()
|
||||
return
|
||||
try: CACHE.ping()
|
||||
except redis.RedisError: LOG.warning("Valkey unavailable; session validation will use PostgreSQL")
|
||||
host=os.getenv("APP_HOST","0.0.0.0"); port=int(os.getenv("APP_PORT","8080")); server=Server((host,port),Handler)
|
||||
def stop(signum,_frame): LOG.info("received signal %s; stopping",signum); threading.Thread(target=server.shutdown,daemon=True).start()
|
||||
signal.signal(signal.SIGTERM,stop); signal.signal(signal.SIGINT,stop)
|
||||
try: LOG.info("server listening on %s:%s",host,port); server.serve_forever(poll_interval=.2)
|
||||
finally: server.server_close(); POOL.close(); LOG.info("server stopped")
|
||||
|
||||
if __name__=="__main__": main()
|
||||
Reference in New Issue
Block a user