diff --git a/REPORT.md b/REPORT.md index c2679005..92c5dd4d 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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-операции не обещают прозрачную идемпотентность. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..bbcbc210 --- /dev/null +++ b/compose.yaml @@ -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: diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..87262a1e --- /dev/null +++ b/requirements.txt @@ -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 diff --git a/server.py b/server.py new file mode 100644 index 00000000..3c8247f3 --- /dev/null +++ b/server.py @@ -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()