ЛР 3 — БПИ2303 — Сарибекян — на 4 #84
+18
@@ -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"]
|
||||
@@ -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 с активными пробами.
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
"""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,
|
||||
)
|
||||
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 run_migrations(dsn: str) -> None:
|
||||
p = await asyncpg.create_pool(dsn, min_size=1, max_size=2, command_timeout=5, timeout=5)
|
||||
try:
|
||||
await _run_migrations(p)
|
||||
finally:
|
||||
await p.close()
|
||||
|
||||
|
||||
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
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
+534
@@ -0,0 +1,534 @@
|
||||
"""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.exceptions import RequestValidationError
|
||||
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:
|
||||
if request.url.path.startswith("/api/") and not await _dependencies_ready():
|
||||
raise unavailable("database or session store not ready")
|
||||
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
|
||||
|
||||
|
||||
async def _dependencies_ready() -> bool:
|
||||
return await db.ping() and await sessions.ping()
|
||||
|
||||
|
||||
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))
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def request_validation_error_handler(request: Request, exc: RequestValidationError):
|
||||
return _error_response(
|
||||
bad_request("invalid request parameters"),
|
||||
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())
|
||||
payload = json.loads(raw)
|
||||
if not isinstance(payload, dict):
|
||||
raise bad_request("malformed cursor")
|
||||
return payload
|
||||
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.fullmatch(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
|
||||
@@ -0,0 +1,24 @@
|
||||
"""Run database migrations as a dedicated deployment step."""
|
||||
import asyncio
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from . import db
|
||||
|
||||
|
||||
def read_secret(name: str, fallback: str) -> str:
|
||||
path = os.environ.get(name)
|
||||
if path:
|
||||
return Path(path).read_text(encoding="utf-8").strip()
|
||||
value = os.environ.get(fallback)
|
||||
if not value:
|
||||
raise RuntimeError(f"{name} or {fallback} is required")
|
||||
return value
|
||||
|
||||
|
||||
async def main() -> None:
|
||||
await db.run_migrations(read_secret("DATABASE_URL_FILE", "DATABASE_URL"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -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
|
||||
@@ -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}")
|
||||
+121
@@ -0,0 +1,121 @@
|
||||
name: mtusi2026lab3
|
||||
|
||||
services:
|
||||
lb:
|
||||
image: nginx:1.27.2
|
||||
ports:
|
||||
- "8080:8080"
|
||||
volumes:
|
||||
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf.template:ro
|
||||
- ./infra/nginx/run.sh:/usr/local/bin/run-nginx.sh:ro
|
||||
command: ["/bin/sh", "/usr/local/bin/run-nginx.sh"]
|
||||
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:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
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
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: mtusi2026lab3-api:local
|
||||
command: ["python", "-m", "app.migrate"]
|
||||
environment:
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
secrets:
|
||||
- database_url
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
|
||||
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
|
||||
@@ -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"}
|
||||
@@ -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) ===
|
||||
@@ -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_ADDRESS max_fails=1 fail_timeout=3s;
|
||||
server API2_ADDRESS 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
Executable
+35
@@ -0,0 +1,35 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
template=/etc/nginx/nginx.conf.template
|
||||
rendered=/tmp/nginx.conf
|
||||
last_addresses=
|
||||
|
||||
resolve_address() {
|
||||
getent hosts "$1" | awk 'NR == 1 { print $1 ":8080" }'
|
||||
}
|
||||
|
||||
render() {
|
||||
api1="$(resolve_address api1 || true)"
|
||||
api2="$(resolve_address api2 || true)"
|
||||
[ -n "$api1" ] || api1="127.0.0.1:9"
|
||||
[ -n "$api2" ] || api2="127.0.0.1:9"
|
||||
printf '%s\n' "$api1 $api2"
|
||||
sed -e "s/API1_ADDRESS/$api1/" -e "s/API2_ADDRESS/$api2/" "$template" > "$rendered"
|
||||
}
|
||||
|
||||
current="$(render)"
|
||||
last_addresses="$current"
|
||||
nginx -c "$rendered" -g 'daemon off;' &
|
||||
nginx_pid=$!
|
||||
trap 'kill "$nginx_pid" 2>/dev/null || true; wait "$nginx_pid" 2>/dev/null || true' INT TERM EXIT
|
||||
|
||||
while kill -0 "$nginx_pid" 2>/dev/null; do
|
||||
sleep 2
|
||||
current="$(render)"
|
||||
if [ "$current" != "$last_addresses" ]; then
|
||||
nginx -s reload -c "$rendered"
|
||||
last_addresses="$current"
|
||||
fi
|
||||
done
|
||||
wait "$nginx_pid"
|
||||
@@ -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);
|
||||
@@ -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);
|
||||
@@ -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
|
||||
Executable
+10
@@ -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
|
||||
Executable
+12
@@ -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
|
||||
Reference in New Issue
Block a user