From 303c60e2e1f446ab333636116d7bef18a0cbb929 Mon Sep 17 00:00:00 2001 From: ferraronp Date: Fri, 6 Nov 2026 18:57:11 +0300 Subject: [PATCH] Implement lab3 load balancing and idempotent messaging --- .env.example | 16 +-- .gitattributes | 7 ++ DEMO.md | 53 +++++++++ Dockerfile | 10 ++ REPORT.md | 119 +++++++++++++++---- app/__init__.py | 1 + app/__main__.py | 4 + app/api.py | 182 ++++++++++++++++++++++++++++++ app/auth.py | 104 +++++++++++++++++ app/core.py | 79 +++++++++++++ app/main.py | 82 ++++++++++++++ app/migrate.py | 23 ++++ app/models.py | 62 ++++++++++ app/storage.py | 61 ++++++++++ compose.yaml | 118 +++++++++++++++++++ db/migrations/001_initial.sql | 33 ++++++ db/migrations/002_idempotency.sql | 12 ++ infra/haproxy.cfg | 32 ++++++ requirements.txt | 7 ++ scripts/restart.cmd | 11 ++ scripts/restart.sh | 21 ++++ scripts/rolling-update.sh | 17 +++ scripts/stop-one.cmd | 10 ++ scripts/stop-one.sh | 8 ++ scripts/wait_ready.py | 14 +++ tests/idempotency_parallel.py | 38 +++++++ tests/own_unit.py | 42 +++++++ 27 files changed, 1133 insertions(+), 33 deletions(-) create mode 100644 .gitattributes create mode 100644 DEMO.md create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/__main__.py create mode 100644 app/api.py create mode 100644 app/auth.py create mode 100644 app/core.py create mode 100644 app/main.py create mode 100644 app/migrate.py create mode 100644 app/models.py create mode 100644 app/storage.py create mode 100644 compose.yaml create mode 100644 db/migrations/001_initial.sql create mode 100644 db/migrations/002_idempotency.sql create mode 100644 infra/haproxy.cfg create mode 100644 requirements.txt create mode 100644 scripts/restart.cmd create mode 100755 scripts/restart.sh create mode 100755 scripts/rolling-update.sh create mode 100644 scripts/stop-one.cmd create mode 100755 scripts/stop-one.sh create mode 100644 scripts/wait_ready.py create mode 100644 tests/idempotency_parallel.py create mode 100644 tests/own_unit.py diff --git a/.env.example b/.env.example index d32b9be0..5115d7ba 100644 --- a/.env.example +++ b/.env.example @@ -1,13 +1,7 @@ -# Copy to .env for your LOCAL synthetic test environment; never commit .env. -# These are logical interface suggestions; map actual framework names in REPORT.md. -APP_HOST=0.0.0.0 -APP_PORT=8080 -APP_ENV=lab +# Local only: synthetic credentials, never commit .env +POSTGRES_DB=messenger +POSTGRES_USER=lab +POSTGRES_PASSWORD=ChangeMeToYourLocalRandomPassword123 SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url -API_REPLICAS=2 IDEMPOTENCY_TTL_SECONDS=86400 +DB_POOL_MAX=8 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..3d63257b --- /dev/null +++ b/.gitattributes @@ -0,0 +1,7 @@ +*.sh text eol=lf +*.py text eol=lf +*.sql text eol=lf +*.yaml text eol=lf +*.cfg text eol=lf +*.md text eol=crlf +*.cmd text eol=crlf diff --git a/DEMO.md b/DEMO.md new file mode 100644 index 00000000..af8d3477 --- /dev/null +++ b/DEMO.md @@ -0,0 +1,53 @@ +# Lab3 — короткий сценарий демонстрации + +PowerShell, из корня репозитория. Только тестовые учётные данные. + +**1. Поднять стенд** + +```powershell +docker compose --env-file .env up -d --build +docker compose --env-file .env ps +``` + +**2. Две реплики за одной точкой входа** + +```powershell +1..10 | % { (curl.exe -s -D - http://localhost:8080/health/live -o NUL) | Select-String 'X-Instance-Id' } +``` + +**3. Публичный контракт и дополнительные проверки** + +```powershell +make check +make test +python tests/idempotency_parallel.py +``` + +**4. Сохранность после перезапуска всего стенда** + +```powershell +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +``` + +**5. Отключение одной реплики (после теста восстановить)** + +```powershell +python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd +docker compose --env-file .env up -d --no-deps api1 api2 +``` + +**6. Нагрузка (отдельный терминал во время rolling update)** + +```powershell +python tests/load.py --duration 30 --concurrency 4 --output evidence/load.json +``` + +**7. Плановый перезапуск реплик** + +```powershell +docker compose --env-file .env up -d --no-deps --force-recreate api1 +# после готовности api1: +docker compose --env-file .env up -d --no-deps --force-recreate api2 +``` + +Не выполняйте `docker compose down -v`, если хотите сохранить данные. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..31979f18 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.12.10-slim-bookworm +ENV PYTHONDONTWRITEBYTECODE=1 PYTHONUNBUFFERED=1 +WORKDIR /srv +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt && groupadd --gid 999 app && useradd -m --uid 999 --gid app app +COPY app ./app +COPY db ./db +USER app +EXPOSE 8080 +CMD ["python", "-m", "app"] diff --git a/REPORT.md b/REPORT.md index c2679005..301340e2 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,112 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- **Автор / группа:** Авзалов Артур Марсович, БПИ2301 +- **Целевая оценка:** 4; трек 5 не заявлен +- **Статус:** локальная реализация проверена на двух Windows-компьютерах с Docker Desktop 06.11.2026; публичный API, persistence, идемпотентность, остановка обеих реплик и поочерёдное пересоздание под нагрузкой проверены. +- **Инструменты:** Python 3.12, FastAPI/Pydantic, PostgreSQL 16, psycopg3 pool, Redis 7.4 с AOF, HAProxy 3.1, Docker Compose. +- **Помощь ИИ:** ChatGPT использовался для генерации кода, SQL-миграций, конфигурации инфраструктуры, тестов и пояснений. Результаты ниже получены на локальном стенде и зафиксированы по фактическому выводу команд. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Docker Desktop (Compose v2), Python 3.9+ и make (или запуск тестов напрямую). PowerShell: -## Архитектура и решения +```powershell +Copy-Item .env.example .env +# В .env заменить POSTGRES_PASSWORD на свой локальный случайный ASCII-пароль без URI-спецсимволов. +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +docker compose --env-file .env ps +make check PYTHON=python +make test PYTHON=python +python tests/idempotency_parallel.py +``` -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Все API-запросы идут только через `http://localhost:8080` (HAProxy). PostgreSQL, Redis и API-реплики не публикуют портов на хост. Не коммитить `.env` и результаты с секретами. Безопасная остановка: `docker compose --env-file .env down`; **без `-v`**. Удаление учебных данных только намеренно: `down -v`. -## Доказательства критериев +Запуск миграций: одноразовый сервис `migrate` выполняется до старта API; версионные скрипты `db/migrations/001_initial.sql` и `002_idempotency.sql`. Отдельная повторная проверка: `docker compose --env-file .env run --rm migrate`. -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +Проба сохранности на Windows: -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +```powershell +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd +``` -## Эксперименты и отказы +На Linux: `chmod +x scripts/*.sh`, затем `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +## Архитектура -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +```text +Client localhost:8080 -> HAProxy roundrobin + readiness check (1 s interval, fall=2) + | | + api1 api2 + \ / + PostgreSQL (users, chats, messages, idempotency receipts) + Redis AOF (session: => user UUID, EX TTL) +``` -## Ограничения и следующие шаги +Между API-репликами нет общих файлов и локального авторизационного состояния. `API_INSTANCE_ID` назначается для каждой реплики, отражается в `X-Instance-Id`, а `X-Request-Id` генерируется для каждого запроса. Basic используется только на login; пользователь и членство проверяются через Bearer + Redis + PostgreSQL. Argon2id применяется для паролей. -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Тексты сообщений, названия чатов и display names — UTF-8 в PostgreSQL `bytea`, чтобы API поддерживал U+0000, запрещённый в PostgreSQL `text/varchar`. Транзакция защищает создание чата и участников. Пагинация истории — keyset по `(created_at, id)`, индекс `(chat_id, created_at, id)`. + +### Идемпотентность POST сообщений + +Ключ `(actor_id, chat_id, method, Idempotency-Key)` уникален в PostgreSQL. Body fingerprint — SHA-256 канонического JSON с полем `text`; lab3 ещё не содержит вложений. В транзакции после проверки доступа вызывается `pg_advisory_xact_lock(hashtextextended(scope, 0))`, затем либо читается результат предыдущего сообщения, либо атомарно вставляются сообщение и receipt. Повтор возвращает тот же `201 Message`, другое тело с тем же ключом — `409`. Блокировка работает между процессами и освобождается с завершением транзакции. + +Результаты сохраняются бессрочно: требование **не менее 24 часов** выполняется, но БД будет расти; политику очистки следует добавить при длительной эксплуатации. Внешний отказ после COMMIT безопасен: повтор возвращает исходное сообщение. Нет автоматических повторов POST на уровне HAProxy. + +### Отказы и ограничения + +Остановка одной API-реплики переносится на другую. HAProxy проверяет `GET /health/ready` с интервалом 1 с и `fall=2`; в двух прогонах с остановкой api1 восстановление записи заняло 6.281 и 8.282 с. При повторной автоматической проверке на втором компьютере восстановление заняло 8.328 с; имя остановленной реплики в сохранённом выводе не указано. Все три значения меньше 10 с. При ручной остановке api2 на первом компьютере LB вернул 200 от api1; на втором компьютере первый запрос к LB получил переходный 503, после чего публичный smoke успешно прошёл через оставшуюся реплику. Мгновенное переключение или точное время восстановления для api2 не заявляются. Graceful shutdown Uvicorn ограничен 8 с, Docker stop grace period 12 с. HAProxy использует Docker DNS резолвер для смены адреса пересозданной реплики. На каждом API контейнере CPU limit 0.75 и RAM limit 384 MiB, LB 0.5/128 MiB, PG 1.0/512 MiB, Redis 0.5/256 MiB. + +Остановка PostgreSQL или Redis делает обязательные операции недоступными (503); `/health/live` не зависит от внешних сервисов, `/health/ready` проверяет оба. Хранилища **не реплицированы**. Потеря узла Docker, LB, диска или volumes не покрыта. HTTP Basic/Bearer в локальном стенде допускается только на loopback; для удалённого доступа требуется TLS. + +Миграции вынесены в отдельный one-shot сервис и координируются PG advisory lock. Текущие миграции предназначены для **чистого стенда Lab3**; автоматический импорт уже существующей чужой схемы/volume Lab2 не заявлен. Rolling update рассчитан на совместимость неизменной текущей схемы с обеими API-репликами; миграции с несовместимыми ALTER TABLE потребуют расширения стратегии. + +## Фактические проверки (Windows PowerShell + Docker Desktop, 06.11.2026) + +| Критерий | Команда / способ | Наблюдение | +| --- | --- | --- | +| Подъём стенда | `docker compose --env-file .env up -d --build`, `docker compose --env-file .env ps` | **PASS**: `api1`, `api2`, `lb`, `postgres`, `redis` — `healthy`; наружу опубликован только LB на `127.0.0.1:8080` | +| Проверка структуры | `make check PYTHON=python` | **PASS**: `offline skeleton structure, local refs and Python syntax; application NOT tested.` | +| Публичный API | `make test PYTHON=python` | **PASS**: `lab3 public API scenario`; также **PASS** после rolling update и при остановленной api2 на обоих компьютерах | +| Конкурентная идемпотентность | `python tests/idempotency_parallel.py` | **PASS**: две реплики, одно сообщение, повтор `201`, изменённое тело `409` | +| Persistence | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | **PASS**: подтверждённые данные и прежняя сессия сохранились после restart; тест требует дополнительно показать scope hook | +| Автоматический failover | `python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd` | **PASS** трижды (6.281, 8.282 и 8.328 с); на первом компьютере после тестов в `docker compose ps` отсутствовала api1, api2 оставалась `healthy`. На втором выбор остановленной реплики в логе не зафиксирован | +| Отказ api2 | `docker compose --env-file .env stop --timeout 1 api2` + `curl.exe -i http://localhost:8080/health/ready` + `make test PYTHON=python` | **PASS** для функциональной доступности: на первом ПК `200 OK`, `X-Instance-Id: api1` и smoke PASS. На втором ПК первый `curl` вернул от HAProxy `503 No server is available`, но следующий smoke PASS при остановленной api2. Срок восстановления именно для api2 не замерен | +| Повторное применение миграций на втором ПК | `docker compose --env-file .env run --rm migrate` | **PASS**: `Migrations up to date` | +| Возврат обеих реплик | `docker compose --env-file .env up -d --no-deps --wait api1 api2` | **PASS**: обе реплики `healthy` | +| Rolling update под нагрузкой | Фоновый 90-секундный `tests/load.py` + поочерёдное `--force-recreate --wait api1`, затем `api2` | **PASS**: нагрузка была `Running` до замены; обе реплики вернулись в `healthy`; первый ПК — 171 успешная запись, 0 ошибок; второй ПК — 168 успешных записей, 0 ошибок; оба раза job `Completed` | + +Linux persistence отдельно не прогонялся. Локальный дополнительный unit-тест `tests/own_unit.py` не заявляется как выполненный; публичный smoke, check и конкурентная идемпотентность проверены. + +### Измерения нагрузки + +| Сценарий | Успешные запросы | Ошибки | RPS | p50 | p95 | p99 | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | +| Базовая нагрузка, concurrency=4, 30 с | 60 | 0 | 1.863 | 2063 мс | 2344 мс | 2703 мс | +| 90 с без подтверждённого перекрытия с update | 176 | 0 | 1.914 | 2063 мс | 2203 мс | 2469 мс | +| Rolling update под нагрузкой, первый ПК, concurrency=4, 90 с | 171 | 0 | 1.838 | 2063 мс | 2828 мс | 4047 мс | +| Базовая нагрузка, второй ПК, concurrency=4, 30 с | 60 | 0 | 1.882 | 2093 мс | 2125 мс | 2329 мс | +| Rolling update, второй ПК, concurrency=4, 90 с | 168 | 0 | 1.861 | 2094 мс | 2156 мс | 6172 мс | + +Rolling update запускался в PowerShell `Start-Job`; после 15 секунд тест был `Running`, затем по очереди выполнялось пересоздание реплик. На первом ПК `api1` восстановилась за 7.6 с, `api2` за 6.9 с; на втором — за 7.1 с и 7.5 с соответственно. `Wait-Job` оба раза вернул JSON с нулём ошибок и состоянием `Completed`. Эти результаты подтверждают замену контейнеров под нагрузкой, но не являются тестом обновления на новую версию кода или несовместимой схемы БД. + +Фактические значения failover в автоматических прогонах: + +| Остановленная реплика | Успешные записи | Неуспешные попытки | Первое восстановление записи | +| --- | ---: | ---: | ---: | +| api1, прогон 1 | 8 | 0 | 6.281 с | +| api1, прогон 2 | 6 | 1 | 8.282 с | +| выбранная тестом реплика, второй ПК | 6 | 1 | 8.328 с | +| api2, ручной сценарий (первый ПК) | Smoke: PASS | Не измерено | Проверка readiness дала HTTP 200, время failover не измерялось | +| api2, ручной сценарий (второй ПК) | Smoke: PASS | Первый curl: 503 | После 503 smoke прошёл; время восстановления не измерялось | + +На первом ПК остановку именно api2 подтвердил `docker compose ps`, а обработчик ответа имел `X-Instance-Id: api1`. На втором ПК остановка api2 подтверждена выводом `docker compose stop`, первый readiness-запрос вернул 503 от HAProxy, последующий smoke прошёл. Ручной сценарий не даёт количественной оценки RPS или задержки восстановления для api2. + +`tests/load.py` использует closed-loop нагрузку без автоматических повторов: измерение включает клиентские задержки и может страдать coordinated omission. p50/p95/p99 относятся только к успешным HTTP-ответам. На обоих компьютерах медиана осталась около 2.1 с; это делает нехватку RAM первого ПК менее убедительной единственной причиной. Задержку не профилировали, узкое место не установлено. + +### Ограничения результатов + +- PostgreSQL, Redis и балансировщик представлены одним экземпляром; отказ всего хоста и потеря volumes не покрываются. +- При остановке api2 проверены работоспособность и публичный smoke, но отдельное инструментальное время восстановления и RPS этой реплики не фиксировались. На втором ПК первый readiness после остановки вернул 503, поэтому непрерывную безошибочную доступность в этом сценарии не заявляем. +- Приведены результаты двух Windows-хостов при конкретном closed-loop профиле нагрузки; Linux-испытание не проводилось. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e12a1933 --- /dev/null +++ b/app/__init__.py @@ -0,0 +1 @@ +"""Lab 3 messenger API.""" diff --git a/app/__main__.py b/app/__main__.py new file mode 100644 index 00000000..87740f8f --- /dev/null +++ b/app/__main__.py @@ -0,0 +1,4 @@ +import os +import uvicorn +if __name__ == "__main__": + uvicorn.run("app.main:app", host="0.0.0.0", port=int(os.getenv("APP_PORT", "8080")), workers=1, timeout_graceful_shutdown=8) diff --git a/app/api.py b/app/api.py new file mode 100644 index 00000000..3dd7d6f5 --- /dev/null +++ b/app/api.py @@ -0,0 +1,182 @@ +"""Messenger HTTP handlers; state lives only in PostgreSQL/Redis.""" +import hashlib +import json +import re +import uuid + +import psycopg +from argon2 import PasswordHasher +from fastapi import APIRouter, Request + +from .auth import current_user, hasher, login, logout, public_user +from .core import APIError, invalid, iso, make_cursor, parse_limit, parse_uuid, read_cursor +from .models import CreateChat, CreateMessage, CreateUser +from .storage import db + +router = APIRouter() +KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$", re.ASCII) + + +def actor(req: Request) -> dict: + return getattr(req.state, "actor", None) or current_user(req) + + +def chat_detail(conn, chat: dict) -> dict: + members = conn.execute("SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY position", (chat["id"],)).fetchall() + return {"id": str(chat["id"]), "title": bytes(chat["title"]).decode("utf-8"), "created_at": iso(chat["created_at"]), "member_ids": [str(x["user_id"]) for x in members]} + + +def message_detail(row: dict) -> dict: + return {"id": str(row["id"]), "chat_id": str(row["chat_id"]), "sender_id": str(row["sender_id"]), "text": bytes(row["text"]).decode("utf-8"), "created_at": iso(row["created_at"])} + + +def require_chat(conn, chat_id: str, actor_id: str) -> dict: + row = conn.execute("SELECT c.* FROM chats c JOIN chat_members cm ON cm.chat_id=c.id WHERE c.id=%s AND cm.user_id=%s", (chat_id, actor_id)).fetchone() + if row is None: + raise APIError(404, "not_found", "Object not found") + return row + + +@router.get("/health/live") +def live(): + return {"status": "ok"} + + +@router.get("/health/ready") +def ready(): + from .storage import ready as storage_ready + if not storage_ready(): + raise APIError(503, "unavailable", "Service not ready") + return {"status": "ok"} + + +@router.post("/api/v1/users", status_code=201) +def register(body: CreateUser): + hashed = hasher.hash(body.password) + ident = str(uuid.uuid4()) + try: + with db() as conn: + row = conn.execute("INSERT INTO users(id,username,display_name,password_hash) VALUES (%s,%s,%s,%s) RETURNING *", (ident, body.username, body.display_name.encode("utf-8"), hashed)).fetchone() + return public_user(row) + except psycopg.errors.UniqueViolation: + raise APIError(409, "conflict", "Username already exists") from None + + +@router.post("/api/v1/auth/sessions", status_code=201) +def sessions(req: Request): + return login(req) + + +@router.delete("/api/v1/auth/sessions/current", status_code=204) +def sessions_delete(req: Request): + logout(req) + return None + + +@router.get("/api/v1/users/me") +def users_me(req: Request): + return actor(req) + + +@router.post("/api/v1/chats", status_code=201) +def chats_create(req: Request, body: CreateChat): + ident = actor(req)["id"] + if ident not in body.member_ids: + raise invalid("Current user must belong to the chat") + chat_id = str(uuid.uuid4()) + try: + with db() as conn: + with conn.transaction(): + # Validate all members; FK constraints are the final authority for races. + found = conn.execute("SELECT id FROM users WHERE id = ANY(%s::uuid[])", (body.member_ids,)).fetchall() + if len(found) != len(body.member_ids): + raise invalid("Unknown member") + row = conn.execute("INSERT INTO chats(id,title) VALUES (%s,%s) RETURNING *", (chat_id, body.title.encode("utf-8"))).fetchone() + for pos, member in enumerate(body.member_ids): + conn.execute("INSERT INTO chat_members(chat_id,user_id,position) VALUES (%s,%s,%s)", (chat_id, member, pos)) + result = chat_detail(conn, row) + return result + except psycopg.errors.ForeignKeyViolation: + raise invalid("Unknown member") from None + + +@router.get("/api/v1/chats") +def chats_list(req: Request, limit: str | None = None, cursor: str | None = None): + who = actor(req)["id"] + n = parse_limit(limit) + mark = read_cursor(cursor, "chats", who) + with db() as conn: + if mark: + existing = conn.execute("SELECT 1 FROM chats c JOIN chat_members cm ON c.id=cm.chat_id WHERE c.id=%s AND c.created_at=%s AND cm.user_id=%s", (mark[1], mark[0], who)).fetchone() + if not existing: + raise invalid("Invalid cursor") + rows = conn.execute(""" + SELECT c.* FROM chats c JOIN chat_members cm ON cm.chat_id=c.id + WHERE cm.user_id=%s AND (%s::timestamptz IS NULL OR (c.created_at,c.id)>(%s::timestamptz,%s::uuid)) + ORDER BY c.created_at,c.id LIMIT %s + """, (who, mark[0] if mark else None, mark[0] if mark else None, mark[1] if mark else None, n+1)).fetchall() + items = [chat_detail(conn, row) for row in rows[:n]] + more = len(rows) > n + last = rows[n-1] if more else None + return {"items": items, "next_cursor": make_cursor("chats", who, last["created_at"], str(last["id"])) if last else None} + + +@router.get("/api/v1/chats/{chat_id}") +def chats_get(req: Request, chat_id: str): + who = actor(req)["id"] + ident = parse_uuid(chat_id) + with db() as conn: + row = require_chat(conn, ident, who) + return chat_detail(conn, row) + + +@router.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def messages_create(req: Request, chat_id: str, body: CreateMessage): + who = actor(req)["id"] + ident = parse_uuid(chat_id) + key = req.headers.get("Idempotency-Key") + if not key or not KEY_RE.fullmatch(key): + raise invalid("Invalid Idempotency-Key") + # Lab3 has only text; canonical JSON avoids unstable formatting/field ordering. + fingerprint = hashlib.sha256(json.dumps({"text": body.text}, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest() + lock_scope = f"{who}:POST:/api/v1/chats/{ident}/messages:{key}" + with db() as conn: + with conn.transaction(): + require_chat(conn, ident, who) + # Transaction-scoped advisory lock is GLOBAL across API replicas. + conn.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s, 0))", (lock_scope,)) + previous = conn.execute(""" + SELECT idem.body_sha256, m.* FROM message_idempotency idem + JOIN messages m ON m.id=idem.message_id + WHERE idem.actor_id=%s AND idem.chat_id=%s AND idem.method='POST' AND idem.idem_key=%s + """, (who, ident, key)).fetchone() + if previous: + if previous["body_sha256"] != fingerprint: + raise APIError(409, "conflict", "Idempotency key used with another body") + return message_detail(previous) + message_id = str(uuid.uuid4()) + row = conn.execute("INSERT INTO messages(id,chat_id,sender_id,text) VALUES (%s,%s,%s,%s) RETURNING *", (message_id, ident, who, body.text.encode("utf-8"))).fetchone() + conn.execute("INSERT INTO message_idempotency(actor_id,chat_id,method,idem_key,body_sha256,message_id) VALUES (%s,%s,'POST',%s,%s,%s)", (who, ident, key, fingerprint, message_id)) + return message_detail(row) + + +@router.get("/api/v1/chats/{chat_id}/messages") +def messages_list(req: Request, chat_id: str, limit: str | None = None, cursor: str | None = None): + who = actor(req)["id"] + ident = parse_uuid(chat_id) + n = parse_limit(limit) + mark = read_cursor(cursor, "messages", ident) + with db() as conn: + require_chat(conn, ident, who) + if mark: + existing = conn.execute("SELECT 1 FROM messages WHERE id=%s AND chat_id=%s AND created_at=%s", (mark[1], ident, mark[0])).fetchone() + if not existing: + raise invalid("Invalid cursor") + rows = conn.execute(""" + SELECT * FROM messages WHERE chat_id=%s + AND (%s::timestamptz IS NULL OR (created_at,id)>(%s::timestamptz,%s::uuid)) + ORDER BY created_at,id LIMIT %s + """, (ident, mark[0] if mark else None, mark[0] if mark else None, mark[1] if mark else None, n+1)).fetchall() + items = [message_detail(row) for row in rows[:n]] + last = rows[n-1] if len(rows)>n else None + return {"items": items, "next_cursor": make_cursor("messages", ident, last["created_at"], str(last["id"])) if last else None} diff --git a/app/auth.py b/app/auth.py new file mode 100644 index 00000000..8286fb31 --- /dev/null +++ b/app/auth.py @@ -0,0 +1,104 @@ +"""HTTP Basic only on login; bearer sessions shared by all API replicas.""" +import base64 +import binascii +import hashlib +import re +import secrets +import uuid +from datetime import datetime, timedelta, timezone + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, VerificationError +from fastapi import Request +from redis.exceptions import RedisError + +from .core import APIError, SESSION_TTL, iso +from .storage import cache, db + +hasher = PasswordHasher(time_cost=2, memory_cost=19456, parallelism=1) +PASSWORD_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +def public_user(row: dict): + return {"id": str(row["id"]), "username": row["username"], "display_name": bytes(row["display_name"]).decode("utf-8"), "created_at": iso(row["created_at"])} + + +def unauthorized() -> APIError: + return APIError(401, "unauthorized", "Unauthorized") + + +def challenge(req: Request) -> str: + return 'Basic realm="messenger", charset="UTF-8"' if req.url.path == "/api/v1/auth/sessions" else 'Bearer realm="messenger"' + + +def bearer_token(req: Request) -> str: + value = req.headers.get("Authorization", "") + if not value.startswith("Bearer ") or len(value) <= 7 or " " in value[7:] or len(value) > 512: + raise unauthorized() + try: + value[7:].encode("ascii") + except UnicodeEncodeError: + raise unauthorized() from None + return value[7:] + + +def session_key(token: str) -> str: + return "session:" + hashlib.sha256(token.encode("ascii")).hexdigest() + + +def current_user(req: Request) -> dict: + token = bearer_token(req) + try: + raw = cache().get(session_key(token)) + except (RedisError, UnicodeError) as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc + if not raw: + raise unauthorized() + try: + ident = str(uuid.UUID(raw)) + except (ValueError, TypeError): + try: + cache().delete(session_key(token)) + except RedisError as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc + raise unauthorized() from None + with db() as conn: + row = conn.execute("SELECT * FROM users WHERE id = %s", (ident,)).fetchone() + if row is None: + raise unauthorized() + return public_user(row) + + +def login(req: Request): + auth = req.headers.get("Authorization", "") + if not auth.startswith("Basic "): + raise unauthorized() + try: + decoded = base64.b64decode(auth[6:].encode("ascii"), validate=True).decode("utf-8") + username, password = decoded.split(":", 1) + if not PASSWORD_RE.fullmatch(username): + raise ValueError() + except (ValueError, UnicodeError, binascii.Error): + raise unauthorized() from None + with db() as conn: + row = conn.execute("SELECT * FROM users WHERE username=%s", (username,)).fetchone() + if not row: + raise unauthorized() + try: + hasher.verify(row["password_hash"], password) + except (VerifyMismatchError, VerificationError): + raise unauthorized() from None + token = secrets.token_urlsafe(32) + try: + cache().set(session_key(token), str(row["id"]), ex=SESSION_TTL) + except RedisError as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc + return {"token": token, "token_type": "Bearer", "expires_at": iso(datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)), "user": public_user(row)} + + +def logout(req: Request): + current_user(req) + try: + cache().delete(session_key(bearer_token(req))) + except RedisError as exc: + raise APIError(503, "unavailable", "Session store unavailable") from exc diff --git a/app/core.py b/app/core.py new file mode 100644 index 00000000..7a85e52a --- /dev/null +++ b/app/core.py @@ -0,0 +1,79 @@ +"""Configuration, HTTP errors and shared representation helpers.""" +import base64 +import json +import os +import uuid +from datetime import datetime, timezone + +from fastapi import Request + +INSTANCE_ID = os.getenv("API_INSTANCE_ID", uuid.uuid4().hex[:12]) +SESSION_TTL = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +IDEMPOTENCY_TTL = max(86400, int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))) + +class APIError(Exception): + def __init__(self, status: int, code: str, message: str): + super().__init__(message) + self.status = status + self.code = code + self.message = message + + +def iso(value: datetime) -> str: + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def invalid(message: str = "Invalid request") -> APIError: + return APIError(400, "invalid_request", message) + + +def parse_uuid(value: str) -> str: + try: + return str(uuid.UUID(value)) + except (ValueError, TypeError, AttributeError): + raise invalid("Invalid UUID") from None + + +def parse_limit(raw: str | None) -> int: + if raw is None: + return 50 + try: + if not raw.isascii() or not raw.isdecimal(): + raise ValueError() + value = int(raw) + except (ValueError, AttributeError): + raise invalid("Invalid limit") from None + if not 1 <= value <= 100: + raise invalid("Invalid limit") + return value + + +def make_cursor(kind: str, scope: str, created: datetime, ident: str) -> str: + b = json.dumps({"kind": kind, "scope": scope, "created_at": iso(created), "id": ident}, separators=(",", ":")).encode() + return base64.urlsafe_b64encode(b).decode().rstrip("=") + + +def read_cursor(raw: str | None, kind: str, scope: str): + if raw is None: + return None + try: + if not raw or len(raw) > 2048 or any(ch not in "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_" for ch in raw): + raise ValueError() + data = json.loads(base64.b64decode(raw + "=" * (-len(raw) % 4), altchars=b"-_", validate=True)) + if not isinstance(data, dict) or data.get("kind") != kind or data.get("scope") != scope: + raise ValueError() + created = datetime.fromisoformat(data["created_at"].replace("Z", "+00:00")) + if created.tzinfo is None: + raise ValueError() + ident = str(uuid.UUID(data["id"])) + return created, ident + except (ValueError, TypeError, KeyError, UnicodeError, json.JSONDecodeError): + raise invalid("Invalid cursor") from None + + +def request_id(req: Request) -> str: + return getattr(req.state, "request_id", uuid.uuid4().hex) + + +def error_body(req: Request, code: str, message: str): + return {"error": {"code": code, "message": message, "request_id": request_id(req)}} diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..cd51b3e2 --- /dev/null +++ b/app/main.py @@ -0,0 +1,82 @@ +"""FastAPI process: one stateless replica. No auto-migration on startup.""" +import logging +import uuid +from contextlib import asynccontextmanager + +import psycopg +from fastapi import FastAPI, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from starlette.concurrency import run_in_threadpool +from redis.exceptions import RedisError + +from .api import router +from .auth import challenge, current_user +from .core import APIError, INSTANCE_ID, error_body, invalid, request_id +from .storage import start, stop + +logging.basicConfig(level="INFO") +logger = logging.getLogger("lab3") + +@asynccontextmanager +async def lifespan(app: FastAPI): + start() + try: + yield + finally: + stop() + +app = FastAPI(title="MTUCI Messenger Lab 3", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan) +app.include_router(router) + +PROTECTED = ("/api/v1/chats", "/api/v1/users/me", "/api/v1/auth/sessions/current") +JSON_POST = ("/api/v1/users", "/api/v1/chats") + + +@app.middleware("http") +async def request_context(req: Request, call_next): + req.state.request_id = uuid.uuid4().hex + try: + path = req.url.path + # Authenticate before parsing the request body or resource-specific fields. + if any(path == p or path.startswith(p + "/") for p in PROTECTED): + req.state.actor = await run_in_threadpool(current_user, req) + if req.method == "POST" and (path in JSON_POST or (path.startswith("/api/v1/chats/") and path.endswith("/messages"))): + if req.headers.get("content-type", "").split(";", 1)[0].strip().lower() != "application/json": + raise APIError(415, "unsupported_media_type", "Content-Type must be application/json") + if req.method == "POST" and path == "/api/v1/auth/sessions" and await req.body(): + raise invalid("Login body is not allowed") + response = await call_next(req) + except APIError as exc: + response = api_error(req, exc) + except (RedisError, psycopg.OperationalError, psycopg.InterfaceError): + response = api_error(req, APIError(503, "unavailable", "Dependency unavailable")) + except Exception: + logger.exception("unexpected request failure id=%s", request_id(req)) + response = api_error(req, APIError(500, "internal_error", "Internal server error")) + response.headers["X-Request-Id"] = request_id(req) + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +def api_error(req: Request, exc: APIError) -> JSONResponse: + headers = {"WWW-Authenticate": challenge(req)} if exc.status == 401 else {} + return JSONResponse(status_code=exc.status, content=error_body(req, exc.code, exc.message), headers=headers) + + +@app.exception_handler(APIError) +async def api_error_handler(req: Request, exc: APIError): + return api_error(req, exc) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(req: Request, exc: RequestValidationError): + return api_error(req, invalid()) + + +@app.exception_handler(Exception) +async def unexpected_error_handler(req: Request, exc: Exception): + logger.exception("handler failure id=%s", request_id(req)) + if isinstance(exc, (psycopg.OperationalError, psycopg.InterfaceError, RedisError)): + return api_error(req, APIError(503, "unavailable", "Dependency unavailable")) + return api_error(req, APIError(500, "internal_error", "Internal server error")) diff --git a/app/migrate.py b/app/migrate.py new file mode 100644 index 00000000..5f624e33 --- /dev/null +++ b/app/migrate.py @@ -0,0 +1,23 @@ +"""Run once before API instances; transactional and advisory-lock coordinated migrations.""" +import os +from pathlib import Path +import psycopg + +MIGRATIONS = Path(__file__).resolve().parents[1] / "db" / "migrations" + +def main(): + with psycopg.connect(os.environ["DATABASE_URL"], autocommit=False) as conn: + with conn.transaction(): + conn.execute("SELECT pg_advisory_xact_lock(62132103)") + conn.execute("CREATE TABLE IF NOT EXISTS schema_migrations(version TEXT PRIMARY KEY, applied_at TIMESTAMPTZ NOT NULL DEFAULT now())") + for path in sorted(MIGRATIONS.glob("[0-9]*.sql")): + applied = conn.execute("SELECT 1 FROM schema_migrations WHERE version=%s", (path.name,)).fetchone() + if applied: + continue + conn.execute(path.read_text(encoding="utf-8")) + conn.execute("INSERT INTO schema_migrations(version) VALUES (%s)", (path.name,)) + print("Applied", path.name, flush=True) + print("Migrations up to date", flush=True) + +if __name__ == "__main__": + main() diff --git a/app/models.py b/app/models.py new file mode 100644 index 00000000..c593ba1a --- /dev/null +++ b/app/models.py @@ -0,0 +1,62 @@ +"""HTTP request models; all strings use Unicode code point limits.""" +import re +import uuid +from pydantic import BaseModel, ConfigDict, Field, field_validator + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + +class StrictModel(BaseModel): + model_config = ConfigDict(extra="forbid", strict=True) + +class CreateUser(StrictModel): + username: str + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + @field_validator("username") + @classmethod + def username_valid(cls, value: str) -> str: + if not USERNAME_RE.fullmatch(value): + raise ValueError("Invalid username") + return value + + @field_validator("display_name", "password") + @classmethod + def non_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Blank value") + value.encode("utf-8", errors="strict") + return value + +class CreateChat(StrictModel): + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def non_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Blank title") + value.encode("utf-8", errors="strict") + return value + + @field_validator("member_ids") + @classmethod + def uuid_members(cls, value: list[str]) -> list[str]: + for member in value: + if not isinstance(member, str) or str(uuid.UUID(member)) != member: + raise ValueError("Invalid member UUID") + if len(value) != len(set(value)): + raise ValueError("Duplicate member") + return value + +class CreateMessage(StrictModel): + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def non_blank(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Blank text") + value.encode("utf-8", errors="strict") + return value diff --git a/app/storage.py b/app/storage.py new file mode 100644 index 00000000..26c78d45 --- /dev/null +++ b/app/storage.py @@ -0,0 +1,61 @@ +"""Shared external state: psycopg connection pool and Redis session store.""" +import os +from contextlib import contextmanager + +import psycopg +from psycopg.rows import dict_row +from psycopg_pool import ConnectionPool, PoolTimeout +from redis import Redis +from redis.exceptions import RedisError + +from .core import APIError + +pool: ConnectionPool | None = None +redis_client: Redis | None = None + + +def start() -> None: + global pool, redis_client + url = os.environ["DATABASE_URL"] + size = int(os.getenv("DB_POOL_MAX", "8")) + pool = ConnectionPool(conninfo=url, min_size=1, max_size=size, timeout=3, kwargs={"row_factory": dict_row, "connect_timeout": 5, "options": "-c statement_timeout=5000"}, open=False) + pool.open(wait=True, timeout=30) + redis_client = Redis.from_url(os.environ.get("REDIS_URL", "redis://redis:6379/0"), socket_connect_timeout=2, socket_timeout=2, decode_responses=True) + redis_client.ping() + + +def stop() -> None: + global pool, redis_client + if pool is not None: + pool.close() + pool = None + if redis_client is not None: + redis_client.close() + redis_client = None + + +@contextmanager +def db(): + if pool is None: + raise APIError(503, "unavailable", "Database unavailable") + try: + with pool.connection() as conn: + yield conn + except (psycopg.OperationalError, psycopg.InterfaceError, PoolTimeout) as exc: + raise APIError(503, "unavailable", "Database unavailable") from exc + + +def cache() -> Redis: + if redis_client is None: + raise APIError(503, "unavailable", "Session store unavailable") + return redis_client + + +def ready() -> bool: + try: + with db() as conn: + conn.execute("SELECT 1").fetchone() + cache().ping() + return True + except (APIError, RedisError, psycopg.Error): + return False diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..d550c60a --- /dev/null +++ b/compose.yaml @@ -0,0 +1,118 @@ +services: + postgres: + image: postgres:16.10-bookworm + environment: + POSTGRES_DB: ${POSTGRES_DB:-messenger} + POSTGRES_USER: ${POSTGRES_USER:-lab} + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U $$POSTGRES_USER -d $$POSTGRES_DB"] + interval: 2s + timeout: 2s + retries: 30 + mem_limit: 512m + cpus: 1.0 + restart: unless-stopped + networks: [storage] + + redis: + image: redis:7.4.5-alpine + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "always", "--save", "60", "1"] + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 2s + timeout: 2s + retries: 30 + mem_limit: 256m + cpus: 0.5 + restart: unless-stopped + networks: [storage] + + migrate: + build: . + command: ["python", "-m", "app.migrate"] + environment: + DATABASE_URL: postgresql://${POSTGRES_USER:-lab}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger} + depends_on: + postgres: + condition: service_healthy + networks: [storage] + restart: "no" + + api1: + build: . + environment: &api_env + APP_PORT: "8080" + API_INSTANCE_ID: api1 + DATABASE_URL: postgresql://${POSTGRES_USER:-lab}:${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}@postgres:5432/${POSTGRES_DB:-messenger} + REDIS_URL: redis://redis:6379/0 + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400} + DB_POOL_MAX: ${DB_POOL_MAX:-8} + depends_on: &api_depends + postgres: + condition: service_healthy + redis: + condition: service_healthy + migrate: + condition: service_completed_successfully + expose: ["8080"] + healthcheck: &api_health + 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: 15 + start_period: 10s + mem_limit: 384m + cpus: 0.75 + stop_grace_period: 12s + restart: unless-stopped + networks: [frontend, storage] + + api2: + build: . + environment: + <<: *api_env + API_INSTANCE_ID: api2 + depends_on: *api_depends + expose: ["8080"] + healthcheck: *api_health + mem_limit: 384m + cpus: 0.75 + stop_grace_period: 12s + restart: unless-stopped + networks: [frontend, storage] + + lb: + image: haproxy:3.1.7-alpine + volumes: + - ./infra/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro + ports: + - "127.0.0.1:8080:8080" + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + healthcheck: + test: ["CMD", "haproxy", "-c", "-f", "/usr/local/etc/haproxy/haproxy.cfg"] + interval: 10s + timeout: 3s + retries: 3 + mem_limit: 128m + cpus: 0.5 + restart: unless-stopped + networks: [frontend] + +networks: + frontend: + storage: + internal: true + +volumes: + postgres_data: + redis_data: diff --git a/db/migrations/001_initial.sql b/db/migrations/001_initial.sql new file mode 100644 index 00000000..203b012f --- /dev/null +++ b/db/migrations/001_initial.sql @@ -0,0 +1,33 @@ +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name BYTEA NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT users_display_bytes CHECK (octet_length(display_name) BETWEEN 1 AND 400) +); +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title BYTEA NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + CONSTRAINT chats_title_bytes CHECK (octet_length(title) BETWEEN 1 AND 400) +); +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id), + user_id UUID NOT NULL REFERENCES users(id), + position INTEGER NOT NULL, + PRIMARY KEY (chat_id, user_id), + UNIQUE (chat_id, position) +); +CREATE INDEX IF NOT EXISTS idx_members_user ON chat_members (user_id, chat_id); +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats(id), + sender_id UUID NOT NULL, + text BYTEA NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + FOREIGN KEY (chat_id, sender_id) REFERENCES chat_members(chat_id, user_id), + CONSTRAINT messages_text_bytes CHECK (octet_length(text) BETWEEN 1 AND 16000) +); +CREATE INDEX IF NOT EXISTS idx_messages_chat_history ON messages (chat_id, created_at, id); +CREATE INDEX IF NOT EXISTS idx_chats_history ON chats (created_at, id); diff --git a/db/migrations/002_idempotency.sql b/db/migrations/002_idempotency.sql new file mode 100644 index 00000000..04a000ad --- /dev/null +++ b/db/migrations/002_idempotency.sql @@ -0,0 +1,12 @@ +-- Same transaction creates message and idempotency receipt. Unique key arbitrates concurrent replicas. +CREATE TABLE IF NOT EXISTS message_idempotency ( + actor_id UUID NOT NULL REFERENCES users(id), + chat_id UUID NOT NULL REFERENCES chats(id), + method VARCHAR(8) NOT NULL DEFAULT 'POST', + idem_key VARCHAR(128) NOT NULL, + body_sha256 CHAR(64) NOT NULL, + message_id UUID NOT NULL REFERENCES messages(id), + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + PRIMARY KEY (actor_id, chat_id, method, idem_key) +); +CREATE INDEX IF NOT EXISTS idx_idempotency_age ON message_idempotency (created_at); diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg new file mode 100644 index 00000000..449163bb --- /dev/null +++ b/infra/haproxy.cfg @@ -0,0 +1,32 @@ +global + log stdout format raw local0 + maxconn 1000 + +defaults + log global + mode http + option httplog + option dontlognull + timeout connect 2s + timeout client 15s + timeout server 15s + timeout http-request 5s + +resolvers docker + nameserver localdns 127.0.0.11:53 + resolve_retries 3 + timeout resolve 1s + timeout retry 1s + hold valid 1s + +frontend messenger + bind *:8080 + default_backend api_nodes + +backend api_nodes + balance roundrobin + option httpchk GET /health/ready + http-check expect status 200 + default-server inter 1s fall 2 rise 1 slowstart 2s + server api1 api1:8080 check resolvers docker init-addr none + server api2 api2:8080 check resolvers docker init-addr none diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..2338a4a1 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,7 @@ +fastapi==0.115.12 +uvicorn==0.34.2 +pydantic==2.11.4 +psycopg[binary]==3.2.6 +psycopg-pool==3.2.6 +redis==5.2.1 +argon2-cffi==23.1.0 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..03172886 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,11 @@ +@echo off +setlocal +cd /d "%~dp0.." +docker compose --env-file .env stop --timeout 5 lb api1 api2 redis postgres +if errorlevel 1 exit /b 1 +docker compose --env-file .env up -d --wait postgres redis +if errorlevel 1 exit /b 1 +docker compose --env-file .env up -d --no-deps api1 api2 lb +if errorlevel 1 exit /b 1 +python scripts\wait_ready.py +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..44eb523a --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,21 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Preserve named volumes. Restart all state stores and both API processes. +docker compose --env-file .env stop --timeout 5 lb api1 api2 redis postgres +docker compose --env-file .env up -d --wait postgres redis +docker compose --env-file .env up -d --no-deps api1 api2 lb +python - <<'PY' +import time, urllib.request +for i in range(120): + try: + with urllib.request.urlopen('http://localhost:8080/health/ready', timeout=2) as response: + if response.status == 200: + print('[restart] all services ready') + break + except Exception: + pass + time.sleep(.5) +else: + raise SystemExit('[restart] health timeout') +PY diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100755 index 00000000..77f8d2a2 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +# Run tests/load.py in a second terminal while this script recreates API instances. +for replica in api1 api2; do + docker compose --env-file .env up -d --no-deps --force-recreate "$replica" + docker compose --env-file .env exec -T "$replica" python - <<'PY' +import time,urllib.request +for _ in range(40): + try: + if urllib.request.urlopen('http://127.0.0.1:8080/health/ready',timeout=2).status==200:break + except Exception:pass + time.sleep(.5) +else:raise SystemExit('replica did not recover') +PY + sleep 3 + done diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 00000000..e3f21f0e --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,10 @@ +@echo off +setlocal +cd /d "%~dp0.." +if "%TARGET_INSTANCE_ID%"=="api1" goto stop +if "%TARGET_INSTANCE_ID%"=="api2" goto stop +echo Unexpected TARGET_INSTANCE_ID 1>&2 +exit /b 2 +:stop +docker compose --env-file .env stop --timeout 1 %TARGET_INSTANCE_ID% +exit /b %ERRORLEVEL% diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..344d6905 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,8 @@ +#!/bin/sh +# The public failover test sets TARGET_INSTANCE_ID from the actual response header. +set -eu +cd "$(dirname "$0")/.." +case "${TARGET_INSTANCE_ID:?missing TARGET_INSTANCE_ID}" in + api1|api2) docker compose --env-file .env stop --timeout 1 "$TARGET_INSTANCE_ID" ;; + *) echo 'Unexpected instance alias' >&2; exit 2 ;; +esac diff --git a/scripts/wait_ready.py b/scripts/wait_ready.py new file mode 100644 index 00000000..86d0318b --- /dev/null +++ b/scripts/wait_ready.py @@ -0,0 +1,14 @@ +"""Operator-facing readiness wait after container replacement.""" +import time +import urllib.request +for _ in range(120): + try: + with urllib.request.urlopen("http://localhost:8080/health/ready", timeout=2) as response: + if response.status == 200: + print("[restart] all services ready") + break + except Exception: + pass + time.sleep(.5) +else: + raise SystemExit("[restart] health timeout") diff --git a/tests/idempotency_parallel.py b/tests/idempotency_parallel.py new file mode 100644 index 00000000..3edffd75 --- /dev/null +++ b/tests/idempotency_parallel.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +"""Lab3 own test: 30 requests using identical actor/chat/key/body across both replicas.""" +import concurrent.futures +import sys +import uuid +from client import Client, Failure, arguments, check, run + + +def main(): + args = arguments("Check atomic idempotency across API replicas") + c = Client(args.base_url, args.ca_file) + alice, bob, _, chat = c.bootstrap() + key = uuid.uuid4().hex + body = {"text": "Concurrent replay " + key} + path = f"/api/v1/chats/{chat['id']}/messages" + + def worker(_): + # Independent request client; one shared bearer token and idempotency key. + client = Client(args.base_url, args.ca_file) + return client.call("POST", path, expected=201, actor=alice, body=body, + headers={"Idempotency-Key": key}, schema="Message") + + with concurrent.futures.ThreadPoolExecutor(max_workers=12) as executor: + results = list(executor.map(worker, range(30))) + ids = {result["json"]["id"] for result in results} + instances = {result["headers"]["X-Instance-Id"] for result in results} + check(len(ids) == 1, "parallel replay created different messages") + check(len(instances) >= 2, "LB did not serve requests via both API replicas") + check(all(r["json"] == results[0]["json"] for r in results), "replay returned altered result") + c.call("POST", path, 409, actor=alice, body={"text": "different body"}, headers={"Idempotency-Key": key}) + c.call("POST", path, 201, actor=bob, body=body, headers={"Idempotency-Key": key}, schema="Message") + history = c.call("GET", path + "?limit=100", actor=bob, schema="MessagePage")["json"]["items"] + check(sum(x["id"] in ids for x in history) == 1, "message duplicated in history") + print("PASS: parallel idempotency across", len(instances), "replicas; one message, replay 201, conflicting body 409") + + +if __name__ == "__main__": + run(main) diff --git a/tests/own_unit.py b/tests/own_unit.py new file mode 100644 index 00000000..bad78c17 --- /dev/null +++ b/tests/own_unit.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 +"""Fast non-Docker checks for input contracts and cursor scoping.""" +import sys +from pathlib import Path +from datetime import datetime, timezone +import uuid + +sys.path.insert(0, str(Path(__file__).resolve().parents[1])) +from app.core import make_cursor, read_cursor, parse_limit, APIError +from app.models import CreateUser, CreateChat, CreateMessage +from pydantic import ValidationError + + +def reject(fn): + try: + fn() + except (APIError, ValidationError, ValueError): + return + raise AssertionError("Expected invalid input") + + +def main(): + token = str(uuid.uuid4()) + dt = datetime.now(timezone.utc) + cursor = make_cursor("messages", token, dt, str(uuid.uuid4())) + assert read_cursor(cursor, "messages", token)[0] == dt + reject(lambda: read_cursor(cursor, "messages", str(uuid.uuid4()))) + reject(lambda: read_cursor(cursor, "chats", token)) + assert parse_limit(None) == 50 + reject(lambda: parse_limit("0")) + reject(lambda: parse_limit("101")) + reject(lambda: CreateUser(username="user_name", display_name=" \t", password="Long-enough-secret")) + reject(lambda: CreateUser(username="user_name", display_name="Test", password=" " * 3)) + assert CreateMessage(text="A\u0000B").text == "A\u0000B" + reject(lambda: CreateMessage(text=" \t")) + reject(lambda: CreateChat(title="title", member_ids=[token] * 2)) + reject(lambda: CreateChat(title="title", member_ids=[token] * 101)) + print("PASS: models, cursor scoping, limits, Unicode U+0000") + + +if __name__ == "__main__": + main()