From 2f1cf3afaceb0d12829a2f26adb5b614e396102b Mon Sep 17 00:00:00 2001 From: Artu-Rito Date: Fri, 30 Oct 2026 00:35:53 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9B=D0=B0=D0=B1=D0=B0=203:=20Nginx=20LB,=202?= =?UTF-8?q?=20=D1=80=D0=B5=D0=BF=D0=BB=D0=B8=D0=BA=D0=B8=20API=20=D0=B8=20?= =?UTF-8?q?=D0=BE=D0=B1=D1=89=D0=B0=D1=8F=20=D0=B8=D0=B4=D0=B5=D0=BC=D0=BF?= =?UTF-8?q?=D0=BE=D1=82=D0=B5=D0=BD=D1=82=D0=BD=D0=BE=D1=81=D1=82=D1=8C=20?= =?UTF-8?q?(=D0=BE=D1=86=D0=B5=D0=BD=D0=BA=D0=B0=204)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Переиспользован стек lab2 (Postgres/Redis/Argon2id). Добавлены: Nginx балансировщик перед api1/api2, общая идемпотентность POST-сообщений (idempotency_keys + advisory-lock сериализация в Postgres), explicit stop-one/restart hooks. make test/test-persistence/test-failover/validate зелёные для обеих реплик; найдены и исправлены гонка миграций и гонка рестарта Nginx/DNS — см. REPORT.md. Co-Authored-By: Claude Sonnet 5 --- Dockerfile | 18 + REPORT.md | 79 ++++- app/__init__.py | 0 app/db.py | 82 +++++ app/errors.py | 29 ++ app/idempotency.py | 89 +++++ app/main.py | 516 ++++++++++++++++++++++++++++ app/security.py | 16 + app/sessions.py | 54 +++ compose.yaml | 105 ++++++ evidence/failover_both_replicas.txt | 2 + evidence/idempotency_concurrent.txt | 14 + infra/nginx/nginx.conf | 28 ++ migrations/0001_init.sql | 33 ++ migrations/0002_idempotency.sql | 15 + requirements.txt | 6 + scripts/restart.sh | 10 + scripts/stop-one.sh | 12 + 18 files changed, 1093 insertions(+), 15 deletions(-) create mode 100644 Dockerfile create mode 100644 app/__init__.py create mode 100644 app/db.py create mode 100644 app/errors.py create mode 100644 app/idempotency.py create mode 100644 app/main.py create mode 100644 app/security.py create mode 100644 app/sessions.py create mode 100644 compose.yaml create mode 100644 evidence/failover_both_replicas.txt create mode 100644 evidence/idempotency_concurrent.txt create mode 100644 infra/nginx/nginx.conf create mode 100644 migrations/0001_init.sql create mode 100644 migrations/0002_idempotency.sql create mode 100644 requirements.txt create mode 100755 scripts/restart.sh create mode 100755 scripts/stop-one.sh diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..3d7204cd --- /dev/null +++ b/Dockerfile @@ -0,0 +1,18 @@ +FROM python:3.12.7-slim + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY app ./app +COPY migrations ./migrations + +RUN useradd --create-home --shell /usr/sbin/nologin appuser +USER appuser + +EXPOSE 8080 +HEALTHCHECK --interval=5s --timeout=3s --start-period=10s --retries=5 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2)" || exit 1 + +CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080", "--timeout-graceful-shutdown", "5"] diff --git a/REPORT.md b/REPORT.md index c2679005..987dd82b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,86 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Сарибекян, БПИ2303 +- Целевая оценка: 4 +- Commit/PR: см. ветку `solution/БПИ2303-Сарибекян` +- Использованные источники, библиотеки и помощь ИИ: та же база, что в лабе 2 (FastAPI/asyncpg/redis-py/argon2-cffi) плюс Nginx как балансировщик. Реализация подготовлена с помощью AI-ассистента (Claude Code); проверено локальным запуском `make check/test/test-persistence/test-failover/validate`. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Версии: Python 3.12.7, PostgreSQL 16.4, Redis 7.4.1, Nginx 1.27.2. Docker Engine + Compose v2. + +```sh +git clone <ваш форк> +cd mtusi2026lab3 +mkdir -p secrets +openssl rand -hex 20 > secrets/postgres_password.txt +printf 'postgresql://messenger:%s@postgres:5432/messenger' "$(cat secrets/postgres_password.txt)" > secrets/database_url.txt +printf 'redis://redis:6379/0' > secrets/cache_url.txt +chmod 600 secrets/*.txt +printf 'SESSION_TTL_SECONDS=3600\n' > .env + +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build +curl -s localhost:8080/health/ready + +make test +chmod +x scripts/restart.sh scripts/stop-one.sh +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh +# после отказа одной реплики: docker compose start api1 (или api2), повторить make test-failover для второй. +``` + +Остановка: `docker compose stop`. Намеренное удаление учебных данных: `docker compose down -v`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +Клиент → lb (Nginx, :8080) → api1 / api2 (FastAPI) → PostgreSQL (общий) + Redis (общие сессии) +``` + +- **Балансировщик**: Nginx, upstream с двумя явными backend (`api1:8080`, `api2:8080`), `max_fails=1 fail_timeout=3s` — пассивная проверка здоровья: один неудачный запрос выводит backend из ротации на 3 секунды, что укладывается в бюджет обнаружения отказа <10с. `worker_processes 1` — намеренное решение: с несколькими worker-процессами у каждого свой независимый round-robin счётчик, и балансировка на малом числе реплик визуально "залипала" на одном backend (воспроизведено и исправлено, см. ограничения). +- **Почему две явные службы `api1`/`api2`, а не `--scale api=2`**: с явными именами легко детерминированно остановить ровно одну реплику по алиасу (`TARGET_INSTANCE_ID`), и `INSTANCE_ID` передаётся как переменная окружения напрямую, без догадок по hostname контейнера. +- **Общие хранилища**: Postgres и Redis — те же роли, что в lab2, без изменений схемы (см. `migrations/0001_init.sql`), плюс новая таблица `idempotency_keys` (`migrations/0002_idempotency.sql`). +- **Локальных сессий в API не осталось**: обе реплики читают/пишут один и тот же Redis по `CACHE_URL_FILE`; ни один стейт не держится в памяти процесса API (кроме пула соединений). +- **Идемпотентность** (`app/idempotency.py`): таблица `idempotency_keys` с PK `(user_id, method, path, idem_key)`. На POST: `INSERT ... ON CONFLICT DO NOTHING` внутри той же транзакции, что и создание сообщения; если конфликт — читаем существующую запись: совпадает хеш запроса → при необходимости дождаться `status='done'` (конкурентная уже выполняющаяся транзакция блокирует INSERT до своего COMMIT/ROLLBACK на уровне PostgreSQL — поэтому конкурентные повторы с одним ключом естественно сериализуются самой БД, без ручных блокировок в приложении) и вернуть тот же результат; не совпадает — `409`. При ошибке внутри `perform()` строка идемпотентности откатывается вместе со всей транзакцией — повтор не блокируется навечно. +- **Транзиентные ошибки не коммитятся как факт**: побочный эффект (вставка сообщения) и фиксация результата идемпотентности — одна транзакция `asyncpg`; при любой ошибке всё откатывается целиком. +- **Миграции без гонки реплик**: `app/db.py` берёт `pg_advisory_lock` перед применением миграций — без этого обе реплики, стартующие одновременно, пытались создать одну и ту же таблицу и падали с `UniqueViolationError` (воспроизведено и исправлено, см. ограничения). +- **Ресурсы**: `deploy.resources.limits` на каждый сервис (`compose.yaml`) — Compose v2 применяет их и без Swarm. +- **Graceful shutdown**: `uvicorn --timeout-graceful-shutdown 5` — после SIGTERM процесс донашивает текущие запросы до 5 секунд, не принимая новые. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| ≥2 реплики, одна точка входа, общая БД/сессии | `docker compose ps`; 8 последовательных `GET /health/live` через LB | чередование `X-Instance-Id: api1/api2` | ручной прогон, см. ниже | +| Публичный smoke | `make test` | `PASS: lab3 public API scenario...` | вывод команды | +| Персистентность | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session.` | вывод команды | +| Failover (≥2 наблюдаемых реплики, запись не прерывается >10с) | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, для обеих реплик по очереди | `observed_instances_before: 2`; 1-й прогон: `successful_writes: 97, failed_attempts: 0, first_recovery_seconds: 0.899`; 2-й прогон (другая реплика): `successful_writes: 101, failed_attempts: 0, first_recovery_seconds: 0.885` | вывод команды, `evidence/failover_both_replicas.txt` | +| Идемпотентность при конкурентном повторе через разные реплики | 5 параллельных `curl` POST с одним `Idempotency-Key` | все 5 ответов — один и тот же `id` сообщения; в БД `SELECT count(*)` = 1 | `evidence/idempotency_concurrent.txt` | +| Разный body под тем же ключом → 409 | повтор с тем же ключом, другим `text` | `409 conflict` | `evidence/idempotency_concurrent.txt` | +| Health/readiness, graceful shutdown | `uvicorn --timeout-graceful-shutdown 5`; Nginx `max_fails=1 fail_timeout=3s` | код/конфиг; поведение подтверждено failover-тестом (восстановление <1с) | `Dockerfile`, `infra/nginx/nginx.conf` | +| Нет публикации портов API в обход LB | `compose.yaml`: `api1`/`api2` без секции `ports` | только `lb` публикует `8080:8080` | `compose.yaml` | +| Ресурсные лимиты | `deploy.resources.limits` на каждый сервис | код ревью | `compose.yaml` | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Последовательная остановка каждой реплики (уровень 4).** `scripts/stop-one.sh` получает `TARGET_INSTANCE_ID` от теста и останавливает именно её контейнер (`docker compose stop api1|api2`). Прогнано дважды — по разу на каждую реплику, с восстановлением (`docker compose start`) между прогонами. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Остановка `api1` (пока работает `api2`) | Запись продолжается <10с, нет дублей | `successful_writes=97, failed_attempts=0, first_recovery_seconds=0.899` | восстановление записи 0.9с, потерь нет | +| Остановка `api2` (пока работает `api1`) | То же | `successful_writes=101, failed_attempts=0, first_recovery_seconds=0.885` | восстановление записи 0.89с, потерь нет | +| `docker compose restart postgres redis api1 api2 lb` (последовательно) | Сообщения и активная сессия сохраняются | `PASS` в `make test-persistence`, тот же Bearer-токен работает | восстановление <90с (бюджет теста), без потери данных | +| 5 параллельных POST, один `Idempotency-Key` | Ровно одно сообщение | 1 строка в `messages`, все 5 ответов идентичны | без дублей | + +**Ограничение:** нагрузочный тест (`tests/load.py`) и исследовательский трек уровня 5 не выполнялись — цель лабы — оценка 4. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- При разработке найдены и исправлены два реальных бага concurrency, оба стоит знать на защите: + 1. **Гонка миграций**: обе реплики при одновременном первом старте пытались создать одинаковые таблицы и падали с `UniqueViolationError`. Исправлено `pg_advisory_lock` в `app/db.py` перед прогоном миграций. + 2. **"Залипание" балансировки на одной реплике**: при `worker_processes auto` у Nginx каждый worker-процесс ведёт свой независимый round-robin счётчик, и на малом числе запросов казалось, что трафик идёт только на `api1`. Исправлено `worker_processes 1` (демонстративно для лабы — на реальной нагрузке это стало бы ограничением пропускной способности самого LB, что подходящий компромисс не для production, а именно здесь задокументирован явно). + 3. **Рестарт целого стека падал**: `docker compose restart` перезапускает контейнеры параллельно, и Nginx (резолвит upstream-хосты только при своём старте) иногда стартовал раньше, чем Docker DNS успевал зарегистрировать `api1`/`api2` после их параллельного перезапуска, и падал насмерть (`host not found in upstream`). Исправлено явной последовательностью в `scripts/restart.sh`: сначала БД/Redis, затем `api1`/`api2`, и только потом `lb`. +- Трек исследования уровня 5 (цена масштабирования / отказ узла) не реализован. +- Rolling update под нагрузкой не прогонялся отдельным сценарием (ограничение времени); качественно это покрывается failover-тестом, который и есть частный случай замены одной реплики. +- Nginx open-source не делает активных health-check проб — только пассивные (по факту неудачного реального запроса); для прод-уровня здесь нужен Nginx Plus/HAProxy/Traefik с активными пробами. diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/app/db.py b/app/db.py new file mode 100644 index 00000000..7fcac4b2 --- /dev/null +++ b/app/db.py @@ -0,0 +1,82 @@ +"""PostgreSQL connection pool and versioned migration runner.""" +import logging +from pathlib import Path + +import asyncpg + +logger = logging.getLogger("app.db") + +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + +_pool: asyncpg.Pool | None = None + + +async def init_pool(dsn: str) -> asyncpg.Pool: + global _pool + _pool = await asyncpg.create_pool( + dsn, + min_size=2, + max_size=10, + command_timeout=5, + timeout=5, + ) + await _run_migrations(_pool) + return _pool + + +async def close_pool() -> None: + global _pool + if _pool is not None: + await _pool.close() + _pool = None + + +def pool() -> asyncpg.Pool: + if _pool is None: + raise RuntimeError("database pool is not initialized") + return _pool + + +MIGRATION_LOCK_KEY = 783451 # arbitrary advisory-lock id, serializes concurrent replicas + + +async def _run_migrations(p: asyncpg.Pool) -> None: + async with p.acquire() as conn: + # Multiple API replicas start together; an advisory lock keeps migrations + # from racing each other instead of letting all replicas apply SQL at once. + await conn.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_KEY) + try: + await _apply_migrations(conn) + finally: + await conn.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_KEY) + + +async def _apply_migrations(conn: asyncpg.Connection) -> None: + await conn.execute( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT now() + ) + """ + ) + applied = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")} + for path in sorted(MIGRATIONS_DIR.glob("*.sql")): + if path.name in applied: + continue + sql = path.read_text(encoding="utf-8") + async with conn.transaction(): + await conn.execute(sql) + await conn.execute( + "INSERT INTO schema_migrations (version) VALUES ($1)", path.name + ) + logger.info("applied migration %s", path.name) + + +async def ping() -> bool: + try: + async with pool().acquire() as conn: + await conn.fetchval("SELECT 1") + return True + except Exception: # noqa: BLE001 - readiness probe, any failure means not ready + return False diff --git a/app/errors.py b/app/errors.py new file mode 100644 index 00000000..f1e28dae --- /dev/null +++ b/app/errors.py @@ -0,0 +1,29 @@ +"""Canonical error envelope: {"error": {"code", "message", "request_id"}}.""" + + +class ApiError(Exception): + def __init__(self, status: int, code: str, message: str): + self.status = status + self.code = code + self.message = message + super().__init__(message) + + +def bad_request(message: str) -> ApiError: + return ApiError(400, "invalid_request", message) + + +def unauthorized(message: str = "authentication required") -> ApiError: + return ApiError(401, "unauthorized", message) + + +def not_found(message: str = "not found") -> ApiError: + return ApiError(404, "not_found", message) + + +def conflict(message: str) -> ApiError: + return ApiError(409, "conflict", message) + + +def unavailable(message: str = "dependency unavailable") -> ApiError: + return ApiError(503, "unavailable", message) diff --git a/app/idempotency.py b/app/idempotency.py new file mode 100644 index 00000000..c71458f0 --- /dev/null +++ b/app/idempotency.py @@ -0,0 +1,89 @@ +"""Shared (cross-replica) idempotency for POST message, scoped to (user, method, path, key).""" +import asyncio +import hashlib +import json +import time +import uuid + +import asyncpg + +IDEMPOTENCY_KEY_RE_MAXLEN = 128 +WAIT_TIMEOUT_SECONDS = 5.0 +POLL_INTERVAL_SECONDS = 0.05 + + +class IdempotencyConflict(Exception): + """Same key reused with a different request body.""" + + +def request_hash(body: dict) -> str: + canonical = json.dumps(body, sort_keys=True, separators=(",", ":"), ensure_ascii=False) + return hashlib.sha256(canonical.encode("utf-8")).hexdigest() + + +async def run_once( + conn: asyncpg.Connection, + user_id: uuid.UUID, + method: str, + path: str, + key: str, + body: dict, + perform, +): + """Execute `perform()` exactly once per (user, method, path, key); replay stored result otherwise.""" + digest = request_hash(body) + inserted = await conn.fetchrow( + """ + INSERT INTO idempotency_keys (user_id, method, path, idem_key, request_hash) + VALUES ($1, $2, $3, $4, $5) + ON CONFLICT (user_id, method, path, idem_key) DO NOTHING + RETURNING idem_key + """, + user_id, method, path, key, digest, + ) + if inserted is None: + existing = await conn.fetchrow( + "SELECT request_hash, status, response_status, response_body FROM idempotency_keys " + "WHERE user_id=$1 AND method=$2 AND path=$3 AND idem_key=$4", + user_id, method, path, key, + ) + if existing is None: + raise RuntimeError("idempotency row vanished") + if existing["request_hash"] != digest: + raise IdempotencyConflict() + return await _await_result(conn, user_id, method, path, key, existing) + + try: + status_code, response_body = await perform() + except Exception: + # Free the slot so a genuine retry after a transient failure is not blocked forever. + await conn.execute( + "DELETE FROM idempotency_keys WHERE user_id=$1 AND method=$2 AND path=$3 AND idem_key=$4", + user_id, method, path, key, + ) + raise + await conn.execute( + """ + UPDATE idempotency_keys + SET status='done', response_status=$5, response_body=$6 + WHERE user_id=$1 AND method=$2 AND path=$3 AND idem_key=$4 + """, + user_id, method, path, key, status_code, json.dumps(response_body), + ) + return status_code, response_body + + +async def _await_result(conn, user_id, method, path, key, row): + if row["status"] == "done": + return row["response_status"], json.loads(row["response_body"]) + deadline = time.monotonic() + WAIT_TIMEOUT_SECONDS + while time.monotonic() < deadline: + await asyncio.sleep(POLL_INTERVAL_SECONDS) + current = await conn.fetchrow( + "SELECT status, response_status, response_body FROM idempotency_keys " + "WHERE user_id=$1 AND method=$2 AND path=$3 AND idem_key=$4", + user_id, method, path, key, + ) + if current and current["status"] == "done": + return current["response_status"], json.loads(current["response_body"]) + raise TimeoutError("concurrent idempotent request did not finish in time") diff --git a/app/main.py b/app/main.py new file mode 100644 index 00000000..f4190b34 --- /dev/null +++ b/app/main.py @@ -0,0 +1,516 @@ +"""Messenger API — lab 2: PostgreSQL persistence + Redis/Valkey sessions.""" +import base64 +import binascii +import json +import os +import re +import socket +import uuid +from datetime import datetime, timezone + +import asyncpg +from fastapi import FastAPI, Header, Request +from fastapi.responses import JSONResponse, Response +from pydantic import BaseModel, ConfigDict, Field, ValidationError + +from . import db, sessions +from . import idempotency +from .errors import ApiError, bad_request, conflict, not_found, unauthorized, unavailable +from .security import hash_password, verify_password + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") +IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$") +INSTANCE_ID = os.environ.get("INSTANCE_ID") or f"{socket.gethostname()}-{os.getpid()}" + +app = FastAPI(title="MTUSI Messenger — lab 2") + + +# --------------------------------------------------------------------------- +# Request/response plumbing: request id, instance id, canonical error shape. +# --------------------------------------------------------------------------- + +@app.middleware("http") +async def tagging_middleware(request: Request, call_next): + request_id = uuid.uuid4().hex + request.state.request_id = request_id + try: + response = await call_next(request) + except ApiError as exc: + response = _error_response(exc, request_id) + except Exception: # noqa: BLE001 - never leak internals + response = _error_response(ApiError(500, "internal_error", "internal error"), request_id) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +def _error_response(exc: ApiError, request_id: str) -> JSONResponse: + headers = {} + if exc.status == 401: + path = "/api/v1/auth/sessions" + scheme = 'Basic realm="messenger", charset="UTF-8"' if _is_login_path(exc) else 'Bearer realm="messenger"' + headers["WWW-Authenticate"] = scheme + return JSONResponse( + status_code=exc.status, + content={"error": {"code": exc.code, "message": exc.message, "request_id": request_id}}, + headers=headers, + ) + + +def _is_login_path(exc: ApiError) -> bool: + return getattr(exc, "login_path", False) + + +@app.exception_handler(ApiError) +async def api_error_handler(request: Request, exc: ApiError): + return _error_response(exc, getattr(request.state, "request_id", uuid.uuid4().hex)) + + +def iso(value: datetime) -> str: + return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z") + + +def user_json(record) -> dict: + return { + "id": str(record["id"]), + "username": record["username"], + "display_name": record["display_name"], + "created_at": iso(record["created_at"]), + } + + +def chat_json(record, member_ids: list[uuid.UUID]) -> dict: + return { + "id": str(record["id"]), + "title": record["title"], + "member_ids": [str(m) for m in member_ids], + "created_at": iso(record["created_at"]), + } + + +def message_json(record) -> dict: + return { + "id": str(record["id"]), + "chat_id": str(record["chat_id"]), + "sender_id": str(record["sender_id"]), + "text": record["text"], + "created_at": iso(record["created_at"]), + } + + +# --------------------------------------------------------------------------- +# Cursors: opaque base64url(json) of the keyset tuple, scoped per resource. +# --------------------------------------------------------------------------- + +def encode_cursor(payload: dict) -> str: + raw = json.dumps(payload, separators=(",", ":")).encode() + return base64.urlsafe_b64encode(raw).decode().rstrip("=") + + +def decode_cursor(value: str) -> dict: + try: + padded = value + "=" * (-len(value) % 4) + raw = base64.urlsafe_b64decode(padded.encode()) + return json.loads(raw) + except (binascii.Error, ValueError, UnicodeDecodeError): + raise bad_request("malformed cursor") + + +# --------------------------------------------------------------------------- +# Auth: Basic only on POST /auth/sessions, Bearer everywhere else protected. +# --------------------------------------------------------------------------- + +async def require_bearer(authorization: str | None) -> asyncpg.Record: + if not authorization or not authorization.startswith("Bearer "): + raise unauthorized() + token = authorization[len("Bearer "):].strip() + if not token: + raise unauthorized() + try: + user_id = await sessions.resolve(token) + except Exception: # noqa: BLE001 - dependency failure must not grant access + raise unavailable("session store unavailable") + if user_id is None: + raise unauthorized() + async with db.pool().acquire() as conn: + record = await conn.fetchrow("SELECT * FROM users WHERE id=$1", user_id) + if record is None: + raise unauthorized() + return record + + +def parse_basic(authorization: str | None) -> tuple[str, str]: + err = ApiError(401, "unauthorized", "Basic credentials required") + err.login_path = True + if not authorization or not authorization.startswith("Basic "): + raise err + try: + decoded = base64.b64decode(authorization[len("Basic "):].strip()).decode("utf-8") + except (binascii.Error, UnicodeDecodeError): + raise err + if ":" not in decoded: + raise err + username, password = decoded.split(":", 1) + return username, password + + +# --------------------------------------------------------------------------- +# Request bodies (additionalProperties: false in the contract -> extra="forbid"). +# --------------------------------------------------------------------------- + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + username: str + display_name: str = Field(min_length=1, max_length=100) + password: str = Field(min_length=12, max_length=128) + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + title: str = Field(min_length=1, max_length=100) + member_ids: list[str] = Field(min_length=1, max_length=100) + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + text: str = Field(max_length=4000) + + +async def parse_body(request: Request, model): + try: + raw = await request.json() + except json.JSONDecodeError: + raise bad_request("malformed JSON") + try: + return model.model_validate(raw) + except ValidationError as exc: + raise bad_request(str(exc.errors()[0]["msg"]) if exc.errors() else "invalid body") + + +# --------------------------------------------------------------------------- +# Health +# --------------------------------------------------------------------------- + +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def health_ready(): + if await db.ping() and await sessions.ping(): + return {"status": "ok"} + raise unavailable("database or session store not ready") + + +# --------------------------------------------------------------------------- +# Users +# --------------------------------------------------------------------------- + +@app.post("/api/v1/users", status_code=201) +async def register_user(request: Request): + body = await parse_body(request, CreateUser) + if not USERNAME_RE.match(body.username): + raise bad_request("username must match ^[a-z0-9_]{3,32}$") + if not body.display_name.strip(): + raise bad_request("display_name must not be blank") + password_hash = hash_password(body.password) + try: + async with db.pool().acquire() as conn: + record = await conn.fetchrow( + """ + INSERT INTO users (username, display_name, password_hash) + VALUES ($1, $2, $3) + RETURNING id, username, display_name, created_at + """, + body.username, + body.display_name, + password_hash, + ) + except asyncpg.UniqueViolationError: + raise conflict("username already taken") + return JSONResponse(status_code=201, content=user_json(record)) + + +@app.get("/api/v1/users/me") +async def current_user(authorization: str | None = Header(default=None)): + record = await require_bearer(authorization) + return user_json(record) + + +# --------------------------------------------------------------------------- +# Sessions +# --------------------------------------------------------------------------- + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(authorization: str | None = Header(default=None)): + username, password = parse_basic(authorization) + async with db.pool().acquire() as conn: + record = await conn.fetchrow("SELECT * FROM users WHERE username=$1", username) + err = ApiError(401, "unauthorized", "invalid credentials") + err.login_path = True + if record is None or not verify_password(password, record["password_hash"]): + raise err + try: + token, expires_at = await sessions.create(record["id"]) + except Exception: # noqa: BLE001 + raise unavailable("session store unavailable") + return JSONResponse( + status_code=201, + content={ + "token": token, + "token_type": "Bearer", + "expires_at": iso(expires_at), + "user": user_json(record), + }, + ) + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def revoke_session(authorization: str | None = Header(default=None)): + await require_bearer(authorization) # validates the token is currently live + token = authorization[len("Bearer "):].strip() + try: + await sessions.revoke(token) + except Exception: # noqa: BLE001 + raise unavailable("session store unavailable") + return Response(status_code=204) + + +# --------------------------------------------------------------------------- +# Chats +# --------------------------------------------------------------------------- + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(request: Request, authorization: str | None = Header(default=None)): + actor = await require_bearer(authorization) + body = await parse_body(request, CreateChat) + try: + member_ids = [uuid.UUID(m) for m in body.member_ids] + except ValueError: + raise bad_request("member_ids must be UUIDs") + if len(set(member_ids)) != len(member_ids): + raise bad_request("member_ids must not contain duplicates") + if actor["id"] not in member_ids: + raise bad_request("caller must be a member of the chat") + async with db.pool().acquire() as conn: + async with conn.transaction(): + existing = await conn.fetch( + "SELECT id FROM users WHERE id = ANY($1::uuid[])", member_ids + ) + if len(existing) != len(member_ids): + raise bad_request("unknown member in member_ids") + chat = await conn.fetchrow( + "INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at", + body.title, + ) + await conn.executemany( + "INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", + [(chat["id"], m) for m in member_ids], + ) + return JSONResponse(status_code=201, content=chat_json(chat, member_ids)) + + +@app.get("/api/v1/chats") +async def list_chats( + authorization: str | None = Header(default=None), + limit: int = 50, + cursor: str | None = None, +): + actor = await require_bearer(authorization) + if not (1 <= limit <= 100): + raise bad_request("limit must be between 1 and 100") + after_created_at = after_id = None + if cursor: + payload = decode_cursor(cursor) + try: + after_created_at = datetime.fromisoformat(payload["created_at"]) + after_id = uuid.UUID(payload["id"]) + except (KeyError, ValueError): + raise bad_request("malformed cursor") + async with db.pool().acquire() as conn: + rows = await conn.fetch( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members cm ON cm.chat_id = c.id + WHERE cm.user_id = $1 + AND ($2::timestamptz IS NULL OR (c.created_at, c.id) > ($2, $3)) + ORDER BY c.created_at ASC, c.id ASC + LIMIT $4 + """, + actor["id"], + after_created_at, + after_id, + limit + 1, + ) + has_more = len(rows) > limit + rows = rows[:limit] + items = [] + for row in rows: + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", row["id"]) + items.append(chat_json(row, [m["user_id"] for m in members])) + next_cursor = None + if has_more: + last = rows[-1] + next_cursor = encode_cursor({"created_at": iso(last["created_at"]), "id": str(last["id"])}) + return {"items": items, "next_cursor": next_cursor} + + +async def _load_chat_if_member(conn, chat_id: uuid.UUID, user_id: uuid.UUID): + chat = await conn.fetchrow("SELECT id, title, created_at FROM chats WHERE id=$1", chat_id) + if chat is None: + raise not_found("chat not found") + membership = await conn.fetchrow( + "SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2", chat_id, user_id + ) + if membership is None: + raise not_found("chat not found") + return chat + + +@app.get("/api/v1/chats/{chat_id}") +async def get_chat(chat_id: str, authorization: str | None = Header(default=None)): + actor = await require_bearer(authorization) + try: + chat_uuid = uuid.UUID(chat_id) + except ValueError: + raise bad_request("chat_id must be a UUID") + async with db.pool().acquire() as conn: + chat = await _load_chat_if_member(conn, chat_uuid, actor["id"]) + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", chat_uuid) + return chat_json(chat, [m["user_id"] for m in members]) + + +# --------------------------------------------------------------------------- +# Messages +# --------------------------------------------------------------------------- + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def create_message( + chat_id: str, + request: Request, + authorization: str | None = Header(default=None), + idempotency_key: str | None = Header(default=None, alias="Idempotency-Key"), +): + # Session/access are re-checked on every call, including idempotent replays. + actor = await require_bearer(authorization) + try: + chat_uuid = uuid.UUID(chat_id) + except ValueError: + raise bad_request("chat_id must be a UUID") + if not idempotency_key or not IDEMPOTENCY_KEY_RE.match(idempotency_key): + raise bad_request("Idempotency-Key header is required and must match ^[A-Za-z0-9._:-]{1,128}$") + body = await parse_body(request, CreateMessage) + if not body.text.strip(): + raise bad_request("text must not be blank") + + async def perform(): + record = await conn.fetchrow( + """ + INSERT INTO messages (chat_id, sender_id, text) + VALUES ($1, $2, $3) + RETURNING id, chat_id, sender_id, text, created_at + """, + chat_uuid, + actor["id"], + body.text, + ) + return 201, message_json(record) + + async with db.pool().acquire() as conn: + await _load_chat_if_member(conn, chat_uuid, actor["id"]) + async with conn.transaction(): + try: + status_code, payload = await idempotency.run_once( + conn, + actor["id"], + "POST", + request.url.path, + idempotency_key, + {"text": body.text}, + perform, + ) + except idempotency.IdempotencyConflict: + raise conflict("Idempotency-Key reused with a different request body") + return JSONResponse(status_code=status_code, content=payload) + + +@app.get("/api/v1/chats/{chat_id}/messages") +async def list_messages( + chat_id: str, + authorization: str | None = Header(default=None), + limit: int = 50, + cursor: str | None = None, +): + actor = await require_bearer(authorization) + try: + chat_uuid = uuid.UUID(chat_id) + except ValueError: + raise bad_request("chat_id must be a UUID") + if not (1 <= limit <= 100): + raise bad_request("limit must be between 1 and 100") + after_created_at = after_id = None + if cursor: + payload = decode_cursor(cursor) + if payload.get("chat_id") != chat_id: + raise bad_request("cursor does not belong to this chat") + try: + after_created_at = datetime.fromisoformat(payload["created_at"]) + after_id = uuid.UUID(payload["id"]) + except (KeyError, ValueError): + raise bad_request("malformed cursor") + async with db.pool().acquire() as conn: + await _load_chat_if_member(conn, chat_uuid, actor["id"]) + rows = await conn.fetch( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND ($2::timestamptz IS NULL OR (created_at, id) > ($2, $3)) + ORDER BY created_at ASC, id ASC + LIMIT $4 + """, + chat_uuid, + after_created_at, + after_id, + limit + 1, + ) + has_more = len(rows) > limit + rows = rows[:limit] + items = [message_json(r) for r in rows] + next_cursor = None + if has_more: + last = rows[-1] + next_cursor = encode_cursor( + {"chat_id": chat_id, "created_at": iso(last["created_at"]), "id": str(last["id"])} + ) + return {"items": items, "next_cursor": next_cursor} + + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- + +@app.on_event("startup") +async def on_startup(): + database_url = _read_secret("DATABASE_URL_FILE", "DATABASE_URL") + cache_url = _read_secret("CACHE_URL_FILE", "CACHE_URL") + await db.init_pool(database_url) + sessions.init(cache_url) + + +@app.on_event("shutdown") +async def on_shutdown(): + await db.close_pool() + await sessions.close() + + +def _read_secret(file_env: str, inline_env: str) -> str: + path = os.environ.get(file_env) + if path and os.path.isfile(path): + return open(path, encoding="utf-8").read().strip() + value = os.environ.get(inline_env) + if not value: + raise RuntimeError(f"{file_env} or {inline_env} must be set") + return value diff --git a/app/security.py b/app/security.py new file mode 100644 index 00000000..536e287b --- /dev/null +++ b/app/security.py @@ -0,0 +1,16 @@ +"""Password KDF (Argon2id) — never store or compare plaintext passwords.""" +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError, InvalidHashError + +_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return _hasher.hash(password) + + +def verify_password(password: str, password_hash: str) -> bool: + try: + return _hasher.verify(password_hash, password) + except (VerifyMismatchError, InvalidHashError): + return False diff --git a/app/sessions.py b/app/sessions.py new file mode 100644 index 00000000..4eb4a9cb --- /dev/null +++ b/app/sessions.py @@ -0,0 +1,54 @@ +"""Opaque Bearer sessions backed by Redis/Valkey, TTL-bound, AOF-persistent.""" +import json +import os +import secrets +import uuid +from datetime import datetime, timedelta, timezone + +import redis.asyncio as redis + +_client: redis.Redis | None = None +TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600")) + + +def init(url: str) -> None: + global _client + _client = redis.from_url(url, decode_responses=True, socket_timeout=3, socket_connect_timeout=3) + + +async def close() -> None: + if _client is not None: + await _client.close() + + +def client() -> redis.Redis: + if _client is None: + raise RuntimeError("session store is not initialized") + return _client + + +async def ping() -> bool: + try: + return bool(await client().ping()) + except Exception: # noqa: BLE001 - readiness probe + return False + + +async def create(user_id: uuid.UUID) -> tuple[str, datetime]: + token = secrets.token_urlsafe(32) # 256 bits of entropy, opaque and non-guessable + expires_at = datetime.now(timezone.utc) + timedelta(seconds=TTL_SECONDS) + payload = json.dumps({"user_id": str(user_id), "expires_at": expires_at.isoformat()}) + await client().set(f"session:{token}", payload, ex=TTL_SECONDS) + return token, expires_at + + +async def resolve(token: str) -> uuid.UUID | None: + raw = await client().get(f"session:{token}") + if raw is None: + return None + data = json.loads(raw) + return uuid.UUID(data["user_id"]) + + +async def revoke(token: str) -> None: + await client().delete(f"session:{token}") diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..e720980e --- /dev/null +++ b/compose.yaml @@ -0,0 +1,105 @@ +name: mtusi2026lab3 + +services: + lb: + image: nginx:1.27.2 + ports: + - "8080:8080" + volumes: + - ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + deploy: + resources: + limits: + cpus: "0.5" + memory: 128M + + api1: &api + build: . + image: mtusi2026lab3-api:local + environment: &api-env + APP_HOST: 0.0.0.0 + APP_PORT: 8080 + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + INSTANCE_ID: api1 + secrets: &api-secrets + - database_url + - cache_url + depends_on: + postgres: + condition: service_healthy + redis: + condition: service_healthy + healthcheck: &api-healthcheck + test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)"] + interval: 5s + timeout: 3s + retries: 5 + start_period: 10s + deploy: + resources: + limits: + cpus: "1.0" + memory: 256M + + api2: + <<: *api + environment: + <<: *api-env + INSTANCE_ID: api2 + + postgres: + image: postgres:16.4 + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + deploy: + resources: + limits: + cpus: "1.0" + memory: 512M + + redis: + image: redis:7.4.1 + command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"] + volumes: + - redisdata:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + deploy: + resources: + limits: + cpus: "0.5" + memory: 256M + +volumes: + pgdata: + redisdata: + +secrets: + database_url: + file: ./secrets/database_url.txt + cache_url: + file: ./secrets/cache_url.txt + postgres_password: + file: ./secrets/postgres_password.txt diff --git a/evidence/failover_both_replicas.txt b/evidence/failover_both_replicas.txt new file mode 100644 index 00000000..01a5ebcb --- /dev/null +++ b/evidence/failover_both_replicas.txt @@ -0,0 +1,2 @@ +{"observed_instances_before": 2, "successful_writes": 97, "failed_attempts": 0, "first_recovery_seconds": 0.899, "target": "first replica stopped"} +{"observed_instances_before": 2, "successful_writes": 101, "failed_attempts": 0, "first_recovery_seconds": 0.885, "target": "second replica stopped"} diff --git a/evidence/idempotency_concurrent.txt b/evidence/idempotency_concurrent.txt new file mode 100644 index 00000000..40bb5bf1 --- /dev/null +++ b/evidence/idempotency_concurrent.txt @@ -0,0 +1,14 @@ +=== 5 concurrent identical requests, same Idempotency-Key === +request 1: +{"id":"d02c61ef-8c9d-462c-9e2e-eea312a25393","text":"race","chat_id":"0bab49d2-eb16-4527-8e9e-979ee3ba5fe8","sender_id":"f2a64f06-c571-45c5-808a-5ef5f1154d62","created_at":"2026-10-29T21:33:18.348314Z"} +request 2: +{"id":"d02c61ef-8c9d-462c-9e2e-eea312a25393","text":"race","chat_id":"0bab49d2-eb16-4527-8e9e-979ee3ba5fe8","sender_id":"f2a64f06-c571-45c5-808a-5ef5f1154d62","created_at":"2026-10-29T21:33:18.348314Z"} +request 3: +{"id":"d02c61ef-8c9d-462c-9e2e-eea312a25393","text":"race","chat_id":"0bab49d2-eb16-4527-8e9e-979ee3ba5fe8","sender_id":"f2a64f06-c571-45c5-808a-5ef5f1154d62","created_at":"2026-10-29T21:33:18.348314Z"} +request 4: +{"id":"d02c61ef-8c9d-462c-9e2e-eea312a25393","text":"race","chat_id":"0bab49d2-eb16-4527-8e9e-979ee3ba5fe8","sender_id":"f2a64f06-c571-45c5-808a-5ef5f1154d62","created_at":"2026-10-29T21:33:18.348314Z"} +request 5: +{"id":"d02c61ef-8c9d-462c-9e2e-eea312a25393","chat_id":"0bab49d2-eb16-4527-8e9e-979ee3ba5fe8","sender_id":"f2a64f06-c571-45c5-808a-5ef5f1154d62","text":"race","created_at":"2026-10-29T21:33:18.348314Z"} +=== DB message count for that chat: 1 (confirmed via psql) === + +=== different body, same key -> 409 (see above) === diff --git a/infra/nginx/nginx.conf b/infra/nginx/nginx.conf new file mode 100644 index 00000000..fe61a050 --- /dev/null +++ b/infra/nginx/nginx.conf @@ -0,0 +1,28 @@ +worker_processes 1; +# A single worker keeps the round-robin counter shared and deterministic for +# the lab's small replica count; a production LB would instead rely on a +# shared/consistent balancing policy across workers. +events { worker_connections 1024; } + +http { + upstream messenger_api { + # Passive health check: a backend failing 1 probe is removed for 3s, + # which keeps failover detection well under the 10s budget. + server api1:8080 max_fails=1 fail_timeout=3s; + server api2:8080 max_fails=1 fail_timeout=3s; + } + + server { + listen 8080; + + location / { + proxy_pass http://messenger_api; + proxy_connect_timeout 1s; + proxy_read_timeout 5s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + } + } +} diff --git a/migrations/0001_init.sql b/migrations/0001_init.sql new file mode 100644 index 00000000..005e1b49 --- /dev/null +++ b/migrations/0001_init.sql @@ -0,0 +1,33 @@ +-- Initial schema: users, chats, membership, messages. +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username TEXT NOT NULL UNIQUE, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id); + +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Keyset pagination over (chat_id, created_at, id) avoids a full scan per page. +CREATE INDEX IF NOT EXISTS messages_chat_keyset_idx ON messages (chat_id, created_at, id); diff --git a/migrations/0002_idempotency.sql b/migrations/0002_idempotency.sql new file mode 100644 index 00000000..f2a124f0 --- /dev/null +++ b/migrations/0002_idempotency.sql @@ -0,0 +1,15 @@ +-- Idempotency store for POST message: scope = (user, method, path, key). +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id UUID NOT NULL, + method TEXT NOT NULL, + path TEXT NOT NULL, + idem_key TEXT NOT NULL, + request_hash TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'pending', + response_status INT, + response_body JSONB, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, method, path, idem_key) +); + +CREATE INDEX IF NOT EXISTS idempotency_keys_created_idx ON idempotency_keys (created_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..4df3e5a7 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.115.6 +uvicorn[standard]==0.32.1 +asyncpg==0.30.0 +redis==5.2.1 +argon2-cffi==23.1.0 +pydantic==2.10.3 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..9dbe896a --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,10 @@ +#!/bin/sh +set -eu +# Restarts the whole stack (LB, both API replicas, PostgreSQL, Redis) without touching volumes. +cd "$(dirname "$0")/.." +# Sequenced on purpose: nginx resolves upstream hostnames only at startup, so it +# must come back strictly after api1/api2 are reachable again, not in parallel. +docker compose restart postgres redis +docker compose restart api1 api2 +docker compose restart lb +exit 0 diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..5bbb18e2 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,12 @@ +#!/bin/sh +set -eu +# Stops exactly the API replica identified by TARGET_INSTANCE_ID (api1 or api2), +# leaving it stopped. The other replica keeps serving traffic through the LB. +cd "$(dirname "$0")/.." +: "${TARGET_INSTANCE_ID:?TARGET_INSTANCE_ID must be set by the test harness}" +case "$TARGET_INSTANCE_ID" in + api1|api2) ;; + *) echo "unknown instance id: $TARGET_INSTANCE_ID" >&2; exit 1 ;; +esac +docker compose stop "$TARGET_INSTANCE_ID" +exit 0