From 3bfaae3e0a601076fe809f22c14afe72a87d21a1 Mon Sep 17 00:00:00 2001 From: allerg1q Date: Mon, 16 Nov 2026 22:03:47 +0300 Subject: [PATCH] Implement lab2 PostgreSQL and persistent sessions --- .dockerignore | 19 +- .gitignore | 32 +- Dockerfile | 17 + REPORT.md | 113 ++++- compose.yaml | 41 ++ evidence/after-restart.txt | 2 + evidence/before-restart.txt | 2 + evidence/containers-after-restart.txt | 3 + evidence/containers.txt | 3 + evidence/migrations.txt | 2 + evidence/persistence.txt | 3 + evidence/restart-times.txt | 2 + evidence/smoke.txt | 1 + migrations/001_initial.sql | 74 +++ requirements.txt | 4 + scripts/restart.sh | 19 + src/__init__.py | 0 src/main.py | 679 ++++++++++++++++++++++++++ src/migrate.py | 53 ++ 19 files changed, 1006 insertions(+), 63 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 evidence/after-restart.txt create mode 100644 evidence/before-restart.txt create mode 100644 evidence/containers-after-restart.txt create mode 100644 evidence/containers.txt create mode 100644 evidence/migrations.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/restart-times.txt create mode 100644 evidence/smoke.txt create mode 100644 migrations/001_initial.sql create mode 100644 requirements.txt create mode 100755 scripts/restart.sh create mode 100644 src/__init__.py create mode 100644 src/main.py create mode 100644 src/migrate.py diff --git a/.dockerignore b/.dockerignore index bc16e556..3adfb3eb 100644 --- a/.dockerignore +++ b/.dockerignore @@ -1,20 +1,7 @@ .git -.github -.env -.env.* -!.env.example -secrets -certs -volumes -data -backups -*.key -*.pem -*.p12 -*.pfx -*.jks .venv __pycache__ -node_modules +.pytest_cache +.env +*.pyc evidence -.DS_Store diff --git a/.gitignore b/.gitignore index b5a71896..60f7f0bf 100644 --- a/.gitignore +++ b/.gitignore @@ -1,32 +1,6 @@ -# Local/private state .env -.env.* -!.env.example -secrets/ -certs/private/ -*.key -*.p12 -*.pfx -*.jks -*.pem -*.tfstate* -volumes/ -data/ -backups/ -# Runtime/build artifacts .venv/ __pycache__/ -*.py[cod] -node_modules/ -dist/ -build/ -target/ -bin/ -obj/ -coverage/ -*.log -.DS_Store -.idea/ -.vscode/ -# Keep small, sanitized evidence summaries in evidence/ under version control. -# Inspect git diff --cached: ignore rules are not a secret scanner. +.pytest_cache/ +*.pyc +evidence/*.tmp diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..8cdc325e --- /dev/null +++ b/Dockerfile @@ -0,0 +1,17 @@ +FROM python:3.12-slim + +WORKDIR /app + +COPY requirements.txt . + +RUN pip install --no-cache-dir -r requirements.txt + +COPY src/ ./src/ +COPY migrations/ ./migrations/ + +ENV HOST=0.0.0.0 +ENV PORT=8080 + +EXPOSE 8080 + +CMD ["sh", "-c", "python -m src.migrate && exec uvicorn src.main:app --host \"$HOST\" --port \"$PORT\""] diff --git a/REPORT.md b/REPORT.md index e42f2b05..2beff88b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,114 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- **Автор, группа:** Матвиенко Павел, БПИ2304 +- **Целевая оценка:** 3 +- **Commit/PR:** +- **Использованные источники и библиотеки:** `contracts/openapi.json`, `contracts/README.md`, Python 3.12, FastAPI 0.115.12, Uvicorn 0.34.2, PostgreSQL 16, psycopg 3.2.6, argon2-cffi 23.1.0, Docker Compose. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Для запуска необходимы Git, Docker Desktop, Python 3 и WSL Ubuntu с Make. + +Создать файл `.env` в корне проекта: + +```env +POSTGRES_PASSWORD=<случайный_пароль> +SESSION_TTL_SECONDS=3600 +``` + +Сборка и запуск: + +```bash +docker compose up -d --build +docker compose ps +curl http://127.0.0.1:8080/health/ready +``` + +Миграции автоматически выполняются при запуске API. Повторная проверка: + +```bash +docker compose exec -T api python -m src.migrate +``` + +Запуск тестов: + +```bash +make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +``` + +Остановка с сохранением данных: + +```bash +docker compose down +``` + +Полное удаление учебных данных вместе с volume: + +```bash +docker compose down -v +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Архитектура: **Клиент → FastAPI → PostgreSQL**. + +В Docker Compose работают два сервиса: `api` и `db`. PostgreSQL является основным хранилищем. Данные сохраняются в именованном volume `postgres_data`. + +Созданы таблицы `users`, `chats`, `chat_members`, `messages`, `sessions`, `schema_migrations`. Используются первичные и внешние ключи, ограничения уникальности и индексы. + +Пароли хешируются с помощью Argon2. Вход выполняется через Basic, после чего выдаётся Bearer-токен со сроком действия. Сессии сохраняются в PostgreSQL, поддерживается logout. + +Создание чата и добавление участников выполняются в одной транзакции. История сообщений использует пагинацию по `(created_at, id)`. + +Из lab1 перенесены пользователи, чаты и сообщения. Вместо хранения в памяти используется PostgreSQL, а `X-User-Id` заменён на Basic/Bearer. + +Настройки `POSTGRES_PASSWORD` и `SESSION_TTL_SECONDS` задаются через `.env`. Строка подключения `DATABASE_URL` формируется в `compose.yaml`. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Критерий | Команда | Результат | Доказательство | +|---|---|---|---| +| Публичный smoke | `python3 tests/smoke.py --base-url http://127.0.0.1:8080` | PASS | `evidence/smoke.txt` | +| Сохранение данных и сессий | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | PASS | `evidence/persistence.txt` | +| Работа контейнеров | `docker compose ps` | API и PostgreSQL healthy | `evidence/containers.txt` | +| Повторные миграции | `docker compose exec -T api python -m src.migrate` | Already applied: 001_initial.sql | `evidence/migrations.txt` | +| Перезапуск инфраструктуры | `bash scripts/restart.sh` | Оба сервиса перезапущены и healthy | `evidence/restart-times.txt`, `evidence/containers-after-restart.txt` | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Уровень 4 и трек 5 не заявлены. ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +**Гипотеза:** после перезапуска API и PostgreSQL с сохранением volume сообщения и действующие сессии не теряются. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +Среда: Windows, WSL Ubuntu, Docker Desktop, Python 3.12, PostgreSQL 16. + +Проведён тест `make test-persistence ACTION_SCRIPT=scripts/restart.sh`. Скрипт остановил API, перезапустил PostgreSQL и повторно запустил API. + +Результат: + +```text +PASS: persistence preserved confirmed data and existing session. +``` + +Также проверен повторный запуск миграций: + +```text +Already applied: 001_initial.sql +Migrations completed +``` + +| Воздействие | Ожидание | Результат | Потеря данных | +|---|---|---|---| +| Перезапуск API и PostgreSQL | Данные и сессии сохраняются | PASS | Не обнаружена | +| Повторный запуск миграций | Нет повторного применения | Успешно | Не обнаружена | + +Проверки проводились на небольшом объёме тестовых данных. Нагрузочные измерения RPS, p50/p95/p99 и CPU/RAM не выполнялись. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Приложение использует один экземпляр PostgreSQL без резервирования. При удалении volume данные теряются. Redis/Valkey и балансировка нагрузки не реализованы, так как не требуются для оценки 3. + +В дальнейшем можно добавить резервное копирование, пул соединений и мониторинг. + +**Вывод:** API работает с PostgreSQL, поддерживает регистрацию и Bearer-сессии. Публичный smoke и тест сохранности данных после перезапуска успешно пройдены. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..1d7f685e --- /dev/null +++ b/compose.yaml @@ -0,0 +1,41 @@ +services: + db: + image: postgres:16-alpine + environment: + POSTGRES_DB: messenger + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env} + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 5s + timeout: 3s + retries: 20 + restart: unless-stopped + + api: + build: . + ports: + - "127.0.0.1:8080:8080" + environment: + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD}@db:5432/messenger + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + HOST: 0.0.0.0 + PORT: 8080 + depends_on: + db: + condition: service_healthy + healthcheck: + test: + - CMD + - python + - -c + - "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=3)" + interval: 5s + timeout: 5s + retries: 20 + restart: unless-stopped + +volumes: + postgres_data: diff --git a/evidence/after-restart.txt b/evidence/after-restart.txt new file mode 100644 index 00000000..cd3b4b4f --- /dev/null +++ b/evidence/after-restart.txt @@ -0,0 +1,2 @@ +02cbb71a12da65cee583dccb81f71d312c4f7a780a8d620e8818c0768a4cd810 +0b95450ec72521750a4bbf111a59358a57e326c41b33552af698320cfc696f3b diff --git a/evidence/before-restart.txt b/evidence/before-restart.txt new file mode 100644 index 00000000..cd3b4b4f --- /dev/null +++ b/evidence/before-restart.txt @@ -0,0 +1,2 @@ +02cbb71a12da65cee583dccb81f71d312c4f7a780a8d620e8818c0768a4cd810 +0b95450ec72521750a4bbf111a59358a57e326c41b33552af698320cfc696f3b diff --git a/evidence/containers-after-restart.txt b/evidence/containers-after-restart.txt new file mode 100644 index 00000000..853e9d4f --- /dev/null +++ b/evidence/containers-after-restart.txt @@ -0,0 +1,3 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab2-api-1 mtusi2026lab2-api "sh -c 'python -m sr…" api 15 minutes ago Up 17 seconds (healthy) 127.0.0.1:8080->8080/tcp +mtusi2026lab2-db-1 postgres:16-alpine "docker-entrypoint.s…" db 15 minutes ago Up 22 seconds (healthy) 5432/tcp diff --git a/evidence/containers.txt b/evidence/containers.txt new file mode 100644 index 00000000..0b037abe --- /dev/null +++ b/evidence/containers.txt @@ -0,0 +1,3 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab2-api-1 mtusi2026lab2-api "sh -c 'python -m sr…" api 14 minutes ago Up 10 seconds (healthy) 127.0.0.1:8080->8080/tcp +mtusi2026lab2-db-1 postgres:16-alpine "docker-entrypoint.s…" db 14 minutes ago Up 15 seconds (healthy) 5432/tcp diff --git a/evidence/migrations.txt b/evidence/migrations.txt new file mode 100644 index 00000000..4d4af09f --- /dev/null +++ b/evidence/migrations.txt @@ -0,0 +1,2 @@ +Already applied: 001_initial.sql +Migrations completed diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..793b001d --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/restart-times.txt b/evidence/restart-times.txt new file mode 100644 index 00000000..3ffc157a --- /dev/null +++ b/evidence/restart-times.txt @@ -0,0 +1,2 @@ +/mtusi2026lab2-api-1 2026-11-16T18:57:17.462952441Z +/mtusi2026lab2-db-1 2026-11-16T18:57:11.64827961Z diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..92154196 --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1 @@ +PASS: lab2 public API scenario; infrastructure and grading evidence remain separate. diff --git a/migrations/001_initial.sql b/migrations/001_initial.sql new file mode 100644 index 00000000..0e4d5231 --- /dev/null +++ b/migrations/001_initial.sql @@ -0,0 +1,74 @@ + +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY, + username VARCHAR(32) NOT NULL UNIQUE, + display_name VARCHAR(100) NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + + CONSTRAINT username_format + CHECK (username ~ '^[a-z0-9_]{3,32}$'), + CONSTRAINT display_name_length + CHECK (char_length(display_name) BETWEEN 1 AND 100), + CONSTRAINT display_name_not_blank + CHECK (length(btrim(display_name)) > 0) +); + +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY, + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp(), + + CONSTRAINT title_not_blank + CHECK (length(btrim(title)) > 0) +); + +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), + position INTEGER NOT NULL, + + PRIMARY KEY (chat_id, user_id), + UNIQUE (chat_id, position) +); + +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY, + 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 clock_timestamp(), + + CONSTRAINT message_length + CHECK (char_length(text) BETWEEN 1 AND 4000), + CONSTRAINT message_not_blank + CHECK (length(btrim(text)) > 0) +); + +CREATE TABLE IF NOT EXISTS sessions ( + token_hash CHAR(64) PRIMARY KEY, + user_id UUID NOT NULL + REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + revoked BOOLEAN NOT NULL DEFAULT FALSE, + created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp() +); + +CREATE INDEX IF NOT EXISTS idx_chat_members_user + ON chat_members(user_id, chat_id); + +CREATE INDEX IF NOT EXISTS idx_chats_order + ON chats(created_at, id); + +CREATE INDEX IF NOT EXISTS idx_messages_history + ON messages(chat_id, created_at, id); + +CREATE INDEX IF NOT EXISTS idx_sessions_user + ON sessions(user_id); + +CREATE INDEX IF NOT EXISTS idx_sessions_expiry + ON sessions(expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..32e9b731 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +fastapi==0.115.12 +uvicorn==0.34.2 +psycopg[binary]==3.2.6 +argon2-cffi==23.1.0 diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..2f334a74 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,19 @@ +#!/usr/bin/env bash + +set -euo pipefail + +cd "$(dirname "$0")/.." + +echo "Stopping API..." +docker compose stop api + +echo "Restarting PostgreSQL..." +docker compose restart db + +echo "Waiting for database..." +docker compose up -d --wait db + +echo "Starting API..." +docker compose up -d --wait api + +echo "Restart completed; volumes preserved." diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..9092eec7 --- /dev/null +++ b/src/main.py @@ -0,0 +1,679 @@ + +import base64 +import hashlib +import json +import os +import re +import secrets +import uuid + +from datetime import datetime, timedelta, timezone + +import psycopg +from psycopg.rows import dict_row +from psycopg.errors import UniqueViolation + +from argon2 import PasswordHasher +from argon2.exceptions import ( + VerifyMismatchError, + VerificationError, + InvalidHashError, +) + +from fastapi import FastAPI, Request +from fastapi.responses import JSONResponse, Response +from fastapi.exceptions import RequestValidationError +from starlette.exceptions import HTTPException as StarletteHTTPException + + +app = FastAPI(title="MTUSI Messenger Lab2") + +DATABASE_URL = os.environ["DATABASE_URL"] +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + +password_hasher = PasswordHasher() + + +# ---------- Helpers ---------- + +class ApiError(Exception): + def __init__(self, status, code, message, headers=None): + self.status = status + self.code = code + self.message = message + self.headers = headers or {} + + +def fail(status, code, message, headers=None): + raise ApiError(status, code, message, headers) + + +def db(): + return psycopg.connect(DATABASE_URL, row_factory=dict_row) + + +def utc_string(value): + return value.astimezone(timezone.utc).isoformat( + timespec="microseconds" + ).replace("+00:00", "Z") + + +def user_json(row): + return { + "id": str(row["id"]), + "username": row["username"], + "display_name": row["display_name"], + "created_at": utc_string(row["created_at"]), + } + + +def message_json(row): + return { + "id": str(row["id"]), + "chat_id": str(row["chat_id"]), + "sender_id": str(row["sender_id"]), + "text": row["text"], + "created_at": utc_string(row["created_at"]), + } + + +def chat_json(conn, row): + members = conn.execute( + """ + SELECT user_id FROM chat_members + WHERE chat_id = %s + ORDER BY position + """, + (row["id"],) + ).fetchall() + + return { + "id": str(row["id"]), + "title": row["title"], + "member_ids": [str(m["user_id"]) for m in members], + "created_at": utc_string(row["created_at"]), + } + + +def valid_uuid(value): + if not isinstance(value, str): + return False + try: + return str(uuid.UUID(value)) == value + except ValueError: + return False + + +def valid_text(value, maximum): + return ( + isinstance(value, str) + and 1 <= len(value) <= maximum + and bool(value.strip()) + ) + + +def validate_limit(request): + value = request.query_params.get("limit", "50") + + if not re.fullmatch(r"[0-9]+", value): + fail(400, "invalid_request", "Invalid limit") + + number = int(value) + + if not 1 <= number <= 100: + fail(400, "invalid_request", "Invalid limit") + + return number + + +def make_cursor(resource, row): + payload = { + "resource": resource, + "created_at": utc_string(row["created_at"]), + "id": str(row["id"]), + } + + raw = json.dumps(payload).encode("utf-8") + + return base64.urlsafe_b64encode(raw).decode().rstrip("=") + + +def read_cursor(cursor, resource): + if not isinstance(cursor, str) or not cursor: + fail(400, "invalid_request", "Invalid cursor") + + try: + raw = base64.urlsafe_b64decode( + cursor + "=" * (-len(cursor) % 4) + ) + value = json.loads(raw) + + if value["resource"] != resource: + raise ValueError() + + if not valid_uuid(value["id"]): + raise ValueError() + + timestamp = datetime.fromisoformat( + value["created_at"].replace("Z", "+00:00") + ) + + if timestamp.tzinfo is None: + raise ValueError() + + return timestamp, value["id"] + + except (ValueError, KeyError, TypeError, UnicodeDecodeError): + fail(400, "invalid_request", "Invalid cursor") + + +async def json_body(request, required, allowed): + content_type = request.headers.get("content-type", "") + media_type = content_type.split(";")[0].strip().lower() + + if media_type != "application/json": + fail(415, "unsupported_media_type", "Expected JSON") + + try: + data = await request.json() + except Exception: + fail(400, "invalid_request", "Invalid JSON") + + if not isinstance(data, dict): + fail(400, "invalid_request", "Expected JSON object") + + if not set(required).issubset(data): + fail(400, "invalid_request", "Missing fields") + + if not set(data).issubset(allowed): + fail(400, "invalid_request", "Unexpected fields") + + return data + + +def unauthorized(kind="Bearer"): + if kind == "Basic": + header = 'Basic realm="messenger", charset="UTF-8"' + else: + header = 'Bearer realm="messenger"' + + fail( + 401, + "unauthorized", + "Authentication required", + {"WWW-Authenticate": header}, + ) + + +def current_user(request): + authorization = request.headers.get("Authorization", "") + + if not authorization.startswith("Bearer "): + unauthorized() + + token = authorization[7:] + + if not token: + unauthorized() + + token_hash = hashlib.sha256(token.encode()).hexdigest() + + with db() as conn: + row = conn.execute( + """ + SELECT u.id, u.username, u.display_name, u.created_at + FROM sessions s + JOIN users u ON u.id = s.user_id + WHERE s.token_hash = %s + AND s.revoked = FALSE + AND s.expires_at > clock_timestamp() + """, + (token_hash,) + ).fetchone() + + if row is None: + unauthorized() + + return row + + +def accessible_chat(conn, chat_id, user_id): + if not valid_uuid(chat_id): + fail(400, "invalid_request", "Invalid chat ID") + + row = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE c.id = %s AND m.user_id = %s + """, + (chat_id, user_id) + ).fetchone() + + if row is None: + fail(404, "not_found", "Chat not found") + + return row + + +# ---------- Request IDs and errors ---------- + +def error_response(request, status, code, message, headers=None): + request_id = request.state.request_id + + response_headers = { + "X-Request-Id": request_id, + **(headers or {}), + } + + return JSONResponse( + status_code=status, + content={ + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + }, + headers=response_headers, + ) + + +@app.middleware("http") +async def add_request_id(request, call_next): + request.state.request_id = str(uuid.uuid4()) + + try: + response = await call_next(request) + except psycopg.OperationalError: + response = error_response( + request, 503, "unavailable", "Database unavailable" + ) + except Exception: + response = error_response( + request, 500, "internal_error", "Internal server error" + ) + + response.headers["X-Request-Id"] = request.state.request_id + return response + + +@app.exception_handler(ApiError) +async def api_error_handler(request, exc): + return error_response( + request, exc.status, exc.code, exc.message, exc.headers + ) + + +@app.exception_handler(StarletteHTTPException) +async def http_error_handler(request, exc): + return error_response( + request, exc.status_code, + "not_found" if exc.status_code == 404 else "invalid_request", + "Resource not found" if exc.status_code == 404 else "Invalid request", + ) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request, exc): + return error_response( + request, 400, "invalid_request", "Invalid request" + ) + + +# ---------- Health ---------- + +@app.get("/health/live") +def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def health_ready(): + try: + with db() as conn: + conn.execute("SELECT 1") + return {"status": "ok"} + except psycopg.Error: + fail(503, "unavailable", "Database unavailable") + + +# ---------- Users ---------- + +@app.post("/api/v1/users", status_code=201) +async def create_user(request: Request): + data = await json_body( + request, + required=["username", "display_name", "password"], + allowed=["username", "display_name", "password"], + ) + + username = data["username"] + display_name = data["display_name"] + password = data["password"] + + if ( + not isinstance(username, str) + or not re.fullmatch(r"[a-z0-9_]{3,32}", username) + or not valid_text(display_name, 100) + or not isinstance(password, str) + or not 12 <= len(password) <= 128 + ): + fail(400, "invalid_request", "Invalid user fields") + + password_hash = password_hasher.hash(password) + user_id = str(uuid.uuid4()) + + try: + with db() as conn: + row = conn.execute( + """ + INSERT INTO users + (id, username, display_name, password_hash) + VALUES (%s, %s, %s, %s) + RETURNING id, username, display_name, created_at + """, + (user_id, username, display_name, password_hash) + ).fetchone() + + return user_json(row) + + except UniqueViolation: + fail(409, "conflict", "Username already exists") + + +@app.get("/api/v1/users/me") +def get_me(request: Request): + return user_json(current_user(request)) + + +# ---------- Sessions ---------- + +@app.post("/api/v1/auth/sessions", status_code=201) +async def create_session(request: Request): + authorization = request.headers.get("Authorization", "") + + if not authorization.startswith("Basic "): + unauthorized("Basic") + + try: + encoded = authorization[6:] + decoded = base64.b64decode(encoded, validate=True).decode("utf-8") + + if ":" not in decoded: + raise ValueError() + + username, password = decoded.split(":", 1) + + except (ValueError, UnicodeDecodeError): + unauthorized("Basic") + + if not re.fullmatch(r"[a-z0-9_]{3,32}", username): + unauthorized("Basic") + + with db() as conn: + row = conn.execute( + "SELECT * FROM users WHERE username = %s", + (username,) + ).fetchone() + + if row is None: + unauthorized("Basic") + + try: + password_hasher.verify(row["password_hash"], password) + except (VerifyMismatchError, VerificationError, InvalidHashError): + unauthorized("Basic") + + token = secrets.token_urlsafe(32) + token_hash = hashlib.sha256(token.encode()).hexdigest() + + expires_at = datetime.now(timezone.utc) + timedelta( + seconds=SESSION_TTL_SECONDS + ) + + with db() as conn: + conn.execute( + """ + INSERT INTO sessions (token_hash, user_id, expires_at) + VALUES (%s, %s, %s) + """, + (token_hash, row["id"], expires_at) + ) + + return { + "token": token, + "token_type": "Bearer", + "expires_at": utc_string(expires_at), + "user": user_json(row), + } + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def logout(request: Request): + current_user(request) + + token = request.headers["Authorization"][7:] + token_hash = hashlib.sha256(token.encode()).hexdigest() + + with db() as conn: + conn.execute( + "UPDATE sessions SET revoked = TRUE WHERE token_hash = %s", + (token_hash,) + ) + + return Response(status_code=204) + + +# ---------- Chats ---------- + +@app.post("/api/v1/chats", status_code=201) +async def create_chat(request: Request): + actor = current_user(request) + + data = await json_body( + request, + required=["title", "member_ids"], + allowed=["title", "member_ids"], + ) + + title = data["title"] + member_ids = data["member_ids"] + + if not valid_text(title, 100): + fail(400, "invalid_request", "Invalid title") + + if ( + not isinstance(member_ids, list) + or not 1 <= len(member_ids) <= 100 + or not all(valid_uuid(x) for x in member_ids) + or len(member_ids) != len(set(member_ids)) + or str(actor["id"]) not in member_ids + ): + fail(400, "invalid_request", "Invalid members") + + chat_id = str(uuid.uuid4()) + + with db() as conn: + # All operations use one transaction. + existing = conn.execute( + """ + SELECT id FROM users + WHERE id = ANY(%s::uuid[]) + FOR KEY SHARE + """, + (member_ids,) + ).fetchall() + + if len(existing) != len(member_ids): + fail(400, "invalid_request", "Unknown member") + + row = conn.execute( + """ + INSERT INTO chats (id, title) + VALUES (%s, %s) + RETURNING id, title, created_at + """, + (chat_id, title) + ).fetchone() + + for position, member_id in enumerate(member_ids): + conn.execute( + """ + INSERT INTO chat_members (chat_id, user_id, position) + VALUES (%s, %s, %s) + """, + (chat_id, member_id, position) + ) + + result = chat_json(conn, row) + + return result + + +@app.get("/api/v1/chats") +def list_chats(request: Request): + actor = current_user(request) + limit = validate_limit(request) + cursor = request.query_params.get("cursor") + + resource = "chats:" + str(actor["id"]) + + with db() as conn: + if cursor is None: + rows = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = %s + ORDER BY c.created_at, c.id + LIMIT %s + """, + (actor["id"], limit + 1) + ).fetchall() + else: + timestamp, last_id = read_cursor(cursor, resource) + + rows = conn.execute( + """ + SELECT c.id, c.title, c.created_at + FROM chats c + JOIN chat_members m ON m.chat_id = c.id + WHERE m.user_id = %s + AND (c.created_at, c.id) > (%s, %s) + ORDER BY c.created_at, c.id + LIMIT %s + """, + (actor["id"], timestamp, last_id, limit + 1) + ).fetchall() + + has_more = len(rows) > limit + page = rows[:limit] + + items = [chat_json(conn, row) for row in page] + + next_cursor = ( + make_cursor(resource, page[-1]) + if has_more else None + ) + + return {"items": items, "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: str, request: Request): + actor = current_user(request) + + with db() as conn: + row = accessible_chat(conn, chat_id, actor["id"]) + result = chat_json(conn, row) + + return result + + +# ---------- Messages ---------- + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +async def send_message(chat_id: str, request: Request): + actor = current_user(request) + + data = await json_body( + request, + required=["text"], + allowed=["text"], + ) + + if not valid_text(data["text"], 4000): + fail(400, "invalid_request", "Invalid message text") + + with db() as conn: + accessible_chat(conn, chat_id, actor["id"]) + + row = conn.execute( + """ + INSERT INTO messages + (id, chat_id, sender_id, text) + VALUES (%s, %s, %s, %s) + RETURNING id, chat_id, sender_id, text, created_at + """, + ( + str(uuid.uuid4()), + chat_id, + actor["id"], + data["text"], + ) + ).fetchone() + + return message_json(row) + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages(chat_id: str, request: Request): + actor = current_user(request) + limit = validate_limit(request) + cursor = request.query_params.get("cursor") + + resource = "messages:" + chat_id + + with db() as conn: + accessible_chat(conn, chat_id, actor["id"]) + + if cursor is None: + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + ORDER BY created_at, id + LIMIT %s + """, + (chat_id, limit + 1) + ).fetchall() + else: + timestamp, last_id = read_cursor(cursor, resource) + + rows = conn.execute( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = %s + AND (created_at, id) > (%s, %s) + ORDER BY created_at, id + LIMIT %s + """, + (chat_id, timestamp, last_id, limit + 1) + ).fetchall() + + has_more = len(rows) > limit + page = rows[:limit] + + next_cursor = ( + make_cursor(resource, page[-1]) + if has_more else None + ) + + items = [message_json(row) for row in page] + + return {"items": items, "next_cursor": next_cursor} diff --git a/src/migrate.py b/src/migrate.py new file mode 100644 index 00000000..c13aa99c --- /dev/null +++ b/src/migrate.py @@ -0,0 +1,53 @@ + +import os +from pathlib import Path + +import psycopg + + +DATABASE_URL = os.environ["DATABASE_URL"] +MIGRATIONS_DIR = Path(__file__).resolve().parent.parent / "migrations" + + +def run_migrations(): + with psycopg.connect(DATABASE_URL) as conn: + with conn.cursor() as cur: + # Prevent simultaneous migration runs. + cur.execute("SELECT pg_advisory_xact_lock(2026002)") + + cur.execute(""" + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL + DEFAULT clock_timestamp() + ) + """) + + for file in sorted(MIGRATIONS_DIR.glob("*.sql")): + cur.execute( + "SELECT 1 FROM schema_migrations WHERE version = %s", + (file.name,) + ) + + if cur.fetchone(): + print(f"Already applied: {file.name}") + continue + + sql = file.read_text(encoding="utf-8") + + for statement in sql.split(";"): + if statement.strip(): + cur.execute(statement) + + cur.execute( + "INSERT INTO schema_migrations (version) VALUES (%s)", + (file.name,) + ) + + print(f"Applied migration: {file.name}") + + print("Migrations completed") + + +if __name__ == "__main__": + run_migrations() -- 2.54.0