ЛР 2 — БПИ2303 — Сарибекян — на 4 #142

Open
Artu-Rito wants to merge 2 commits from Artu-Rito/mtusi2026lab2:solution/БПИ2303-Сарибекян into master
13 changed files with 899 additions and 15 deletions
+18
View File
@@ -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"]
+64 -15
View File
@@ -1,37 +1,86 @@
# Отчёт — лабораторная 2
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Автор, группа: Сарибекян, БПИ2303
- Целевая оценка: 4
- Commit/PR: см. ветку `solution/БПИ2303-Сарибекян`
- Использованные источники, библиотеки и помощь ИИ: FastAPI, asyncpg, redis-py, argon2-cffi (Argon2id через `argon2.PasswordHasher`). Реализация подготовлена с помощью AI-ассистента (Claude Code) по заданному контракту `contracts/openapi.json`; код и инфраструктура проверены локальным запуском `make check/test/test-persistence/validate`.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Версии: Python 3.12.7 (образ `python:3.12.7-slim`), PostgreSQL 16.4, Redis 7.4.1. Docker Engine + Compose v2 на хосте.
```sh
git clone <ваш форк>
cd mtusi2026lab2
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
# дождаться 200 на /health/ready
curl -s localhost:8080/health/ready
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
Остановка без потери данных: `docker compose stop`. Полное уничтожение учебных данных (намеренное): `docker compose down -v` — удаляет `pgdata`/`redisdata`.
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Клиент → API (FastAPI/uvicorn, порт 8080) → PostgreSQL (учёт пользователей/чатов/участников/сообщений) и Redis (сессии). Схема:
- `users(id, username UNIQUE, display_name, password_hash, created_at)`
- `chats(id, title, created_at)`
- `chat_members(chat_id, user_id)` — составной PK, индекс по `user_id` для списка чатов пользователя
- `messages(id, chat_id, sender_id, text, created_at)` — композитный индекс `(chat_id, created_at, id)` под keyset-пагинацию
Миграции — файлы в `migrations/*.sql`, применяются по порядку при старте приложения (`app/db.py`), версия фиксируется в таблице `schema_migrations`; повторный запуск не дублирует данные (идемпотентно — проверено перезапуском).
Источник истины для сессий — Redis (`SESSION_STORE` фактически = redis, см. ниже про `.env.example`): ключ `session:<opaque-token>` → JSON `{user_id, expires_at}`, TTL = `SESSION_TTL_SECONDS`. Redis запущен с `--appendonly yes --appendfsync everysec` и volume `redisdata`, поэтому действующие сессии переживают перезапуск Redis (проверено `make test-persistence`). Токен — `secrets.token_urlsafe(32)` (256 бит энтропии), непрозрачный, не username/UUID.
Пароли хешируются Argon2id (`argon2-cffi`), сравнение — через `PasswordHasher.verify`, без plaintext/SHA-256.
Создание чата — одна транзакция `asyncpg` (`conn.transaction()`): проверка существования всех `member_ids`, вставка чата и участников атомарно; откат при неизвестном участнике.
Соответствие `.env.example` → реальной конфигурации: `APP_HOST/APP_PORT` зашиты в Dockerfile/uvicorn (`0.0.0.0:8080`), `SESSION_TTL_SECONDS` передаётся как обычная переменная окружения, `DATABASE_URL_FILE`/`CACHE_URL_FILE` — через Docker secrets (файлы в `secrets/`, не коммитятся), `SESSION_STORE` фактически зафиксирован как Redis (не параметризуется, т.к. лаба тестирует именно Redis-ветку оценки 4).
Переход от lab1: `X-User-Id` больше не определяет личность вызывающего (игнорируется, проверено в smoke: `X-User-Id` чужого пользователя не переопределяет Bearer-сессию). Регистрация теперь требует `password`; вход — только через `Basic` на `POST /auth/sessions`.
## Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
| Публичный smoke | `make test` | `PASS: lab2 public API scenario...` | вывод команды, стенд поднят `docker compose up -d --build` |
| Персистентность (3) | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session.` | вывод команды |
| Атомарность создания чата (3) | транзакция в `create_chat`, проверено unknown member → 400 без побочной вставки | откат подтверждён ручным вызовом с несуществующим UUID в `member_ids` → `400 invalid_request`, чат не создан | `app/main.py::create_chat` |
| Redis с TTL (4) | логин с `SESSION_TTL_SECONDS=2`, ожидание 3с, `GET /users/me` | `200` → `401 unauthorized` после истечения | см. раздел «Эксперименты» |
| Устойчивость к падению Redis (4) | `docker compose stop redis`, запрос с валидным токеном | `503 unavailable` (не анонимный доступ, не 401) | см. «Эксперименты» |
| EXPLAIN ANALYZE на 10 000+ сообщениях (4) | 12 000 строк, keyset-запрос с `LIMIT 51` | до `ANALYZE`: Bitmap Heap Scan, 12000 просмотренных строк, 5.05 ms; после `ANALYZE`: `Index Scan` по `messages_chat_keyset_idx`, 0.31 ms | `evidence/explain_analyze_messages.txt` |
| Параметризованные запросы/pool/timeouts (4) | весь SQL через `asyncpg` с `$1,$2,...`; пул `min_size=2,max_size=10,timeout=5,command_timeout=5` | код ревью | `app/db.py` |
| Гонка регистрации одинакового username (4) | уникальный индекс `users.username` + обработка `UniqueViolationError` → `409` | повторная регистрация того же username в smoke даёт `409` | `tests/smoke.py` строка с повторной регистрацией `alice` |
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
**TTL expiry.** Пользователь `ttltest`, `SESSION_TTL_SECONDS=2`. Сразу после логина `GET /users/me` → `200`. Через 3 секунды тот же токен → `401 {"code":"unauthorized"}`. Ограничение: проверка ручная (curl), не автоматизирована в CI для этой лабы.
**Недоступность Redis.** Активная сессия, затем `docker compose stop redis`. `GET /users/me` с валидным токеном → `503 unavailable` (не 401, не пропущен как анонимный — зависимость от Redis для аутентификации явная). `GET /health/ready` также `503`. После `docker compose start redis` сервис восстанавливается без потери данных Postgres (не затронут).
**EXPLAIN ANALYZE, 12 000 сообщений в одном чате.** Запрос keyset-пагинации `WHERE chat_id=... ORDER BY created_at,id LIMIT 51`. До `ANALYZE` планировщик недооценил избирательность и выбрал Bitmap Heap Scan (просмотр всех 12000 строк чата, 5.05 ms). После `ANALYZE messages` — `Index Scan` непосредственно по композитному индексу `(chat_id, created_at, id)` с остановкой на 51-й строке, 0.31 ms. Вывод: сам индекс недостаточен без актуальной статистики; `autovacuum` обычно обновит её сам, здесь продемонстрировано явно.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `docker compose restart postgres redis api` | Сообщения и активная сессия сохраняются | Подтверждено `make test-persistence`: тот же Bearer-токен читает те же данные после рестарта | восстановление API < 90s (тест ждёт готовности), потери данных нет |
| `docker compose stop redis` (без restart) | Бизнес-эндпойнты не считают запрос анонимным | `503 unavailable`, не 401/200 | сервис восстанавливается сразу после `start redis`, активные токены не теряются (данные в volume) |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- Трек исследования уровня 5 не реализован (цель — оценка 4).
- Rate limiting (`429`) не реализован — контракт делает его опциональным, тесты его не требуют.
- Нет собственного теста на конкурентную гонку создания чата с частично несуществующими участниками под параллельной нагрузкой — проверено только последовательно.
- `evidence/explain_analyze_messages.txt` содержит план на синтетических данных одного чата (12 000 строк); неравномерное распределение размеров чатов (трек 5.2) не исследовано.
- Secrets-файлы и `.env` не коммитятся (см. `.gitignore`); для воспроизведения нужно сгенерировать их заново по инструкции выше.
View File
+69
View File
@@ -0,0 +1,69 @@
"""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
async def _run_migrations(p: asyncpg.Pool) -> None:
async with p.acquire() as conn:
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
+29
View File
@@ -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)
+502
View File
@@ -0,0 +1,502 @@
"""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 .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}$")
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))
@app.exception_handler(RequestValidationError)
async def request_validation_error_handler(request: Request, exc: RequestValidationError):
"""Keep FastAPI's query/path validation inside the public error contract."""
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)):
actor = await require_bearer(authorization)
try:
chat_uuid = uuid.UUID(chat_id)
except ValueError:
raise bad_request("chat_id must be a UUID")
body = await parse_body(request, CreateMessage)
if not body.text.strip():
raise bad_request("text must not be blank")
async with db.pool().acquire() as conn:
await _load_chat_if_member(conn, chat_uuid, actor["id"])
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 JSONResponse(status_code=201, content=message_json(record))
@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
+16
View File
@@ -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
+54
View File
@@ -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}")
+68
View File
@@ -0,0 +1,68 @@
name: mtusi2026lab2
services:
api:
build: .
image: mtusi2026lab2-api:local
ports:
- "8080:8080"
environment:
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
secrets:
- database_url
- cache_url
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
healthcheck:
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/live', timeout=2)"]
interval: 5s
timeout: 3s
retries: 5
start_period: 10s
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
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
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
+34
View File
@@ -0,0 +1,34 @@
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=112.38..112.51 rows=51 width=88) (actual time=4.990..4.998 rows=51 loops=1)
Buffers: shared hit=271
-> Sort (cost=112.38..112.51 rows=52 width=88) (actual time=4.986..4.989 rows=51 loops=1)
Sort Key: created_at, id
Sort Method: top-N heapsort Memory: 36kB
Buffers: shared hit=271
-> Bitmap Heap Scan on messages (cost=4.69..110.90 rows=52 width=88) (actual time=1.292..2.987 rows=12000 loops=1)
Recheck Cond: (chat_id = 'c939f183-65af-4ab7-b565-cd5328e24289'::uuid)
Heap Blocks: exact=148
Buffers: shared hit=265
-> Bitmap Index Scan on messages_chat_keyset_idx (cost=0.00..4.67 rows=52 width=0) (actual time=1.247..1.248 rows=12000 loops=1)
Index Cond: (chat_id = 'c939f183-65af-4ab7-b565-cd5328e24289'::uuid)
Buffers: shared hit=117
Planning:
Buffers: shared hit=102
Planning Time: 0.488 ms
Execution Time: 5.050 ms
(17 rows)
QUERY PLAN
--------------------------------------------------------------------------------------------------------------------------------------------------
Limit (cost=0.29..4.65 rows=51 width=65) (actual time=0.040..0.267 rows=51 loops=1)
Buffers: shared hit=53
-> Index Scan using messages_chat_keyset_idx on messages (cost=0.29..1026.72 rows=12000 width=65) (actual time=0.039..0.258 rows=51 loops=1)
Index Cond: (chat_id = 'c939f183-65af-4ab7-b565-cd5328e24289'::uuid)
Buffers: shared hit=53
Planning:
Buffers: shared hit=107
Planning Time: 0.661 ms
Execution Time: 0.309 ms
(9 rows)
+33
View File
@@ -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);
+6
View File
@@ -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
+6
View File
@@ -0,0 +1,6 @@
#!/bin/sh
set -eu
# Restarts API, PostgreSQL and Redis containers without touching their volumes.
cd "$(dirname "$0")/.."
docker compose restart postgres redis api
exit 0