Добавить приложение, Compose и отчёт

This commit is contained in:
2026-11-06 19:11:20 +03:00
parent 56e1e89416
commit c1e59428e9
4 changed files with 491 additions and 22 deletions
+86 -22
View File
@@ -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-операции не обещают прозрачную идемпотентность.
+79
View File
@@ -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:
+9
View File
@@ -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
+317
View File
@@ -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()