diff --git a/.env.example b/.env.example index 714c8076..4f8472ab 100644 --- a/.env.example +++ b/.env.example @@ -2,10 +2,13 @@ # These are logical interface suggestions; map actual framework names in REPORT.md. APP_HOST=0.0.0.0 APP_PORT=8080 +# Host publish port; change if 8080 is busy locally. +HOST_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 -# Choose credentials locally. File paths contain no secret values. -DATABASE_URL_FILE=/run/secrets/database_url -# Optional on 3, required use on 4 in lab2; Redis OR Valkey: SESSION_STORE=postgres -CACHE_URL_FILE=/run/secrets/cache_url +# Compose lab stand uses DATABASE_URL. DATABASE_URL_FILE is also supported by the app. +DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger +# DATABASE_URL_FILE=/run/secrets/database_url +# Optional on 3, required use on 4 in lab2; Redis OR Valkey: +# CACHE_URL_FILE=/run/secrets/cache_url diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..6259ed59 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,19 @@ +FROM python:3.12.8-slim-bookworm + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY migrations/ ./migrations/ +COPY src/ ./src/ + +ENV PYTHONPATH=/app/src +ENV APP_HOST=0.0.0.0 +ENV APP_PORT=8080 +ENV APP_ENV=lab +ENV SESSION_TTL_SECONDS=3600 + +EXPOSE 8080 + +CMD ["sh", "-c", "exec uvicorn messenger.app:app --host ${APP_HOST} --port ${APP_PORT}"] diff --git a/REPORT.md b/REPORT.md index e42f2b05..d82ddb2c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,140 @@ # Отчёт — лабораторная 2 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Гадяцкий Л. Е., БПИ2302 +- Целевая оценка: 3 +- Commit/PR:`solution/BPI2302-Gadiatskiy` MR#167: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab2/pulls/167 +- Использованные источники и библиотеки: + - контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md` + - перенос из lab1: FastAPI, cursor-пагинация, формат ошибок, стиль Dockerfile + - runtime: FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, SQLAlchemy 2.0.36, psycopg 3.2.4, argon2-cffi 23.1.0 + - PostgreSQL: образ `postgres:16-alpine` +- Помощь ИИ использована при переносе lab1, реализации PostgreSQL/сессий/SQLAlchemy и отчёта. Результаты подтверждаются сохранёнными запусками. ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Prerequisites:** Docker и Docker Compose. Python 3.9+ нужен только для публичных проверок (`make check` / `make test` / `tests/resilience.py`). Runtime приложения — внутри образа. + +**Версии:** +- API: базовый образ `python:3.12.8-slim-bookworm` → локальный `mtusi-messenger:lab2` +- PostgreSQL: `postgres:16-alpine` +- зависимости: `requirements.txt` + +**Конфигурация:** секретов в Git нет. Локальный `.env` создаётся из примера и не коммитится: + +```sh +cp .env.example .env +``` + +Соответствие `.env.example`: +- `APP_HOST` / `APP_PORT` — bind uvicorn внутри контейнера +- `HOST_PORT` — порт на host (по умолчанию 8080; если занят — например 8081) +- `APP_ENV` — среда запуска (`lab`) +- `SESSION_TTL_SECONDS` — TTL сессии (по умолчанию 3600; для обычного smoke ≥ 300) +- `SESSION_STORE=postgres` — сессии в PostgreSQL +- `DATABASE_URL` — строка подключения API к PostgreSQL в compose-сети + (приложение также поддерживает `DATABASE_URL_FILE`) + +Учебные credentials compose (`messenger` / `messenger`) только для локального синтетического стенда. + +**Сборка и запуск:** + +```sh +docker compose --env-file .env up -d --build +``` + +Готовность (подставьте свой `HOST_PORT`): + +```sh +curl -i http://127.0.0.1:8080/health/ready +``` + +Ожидается HTTP 200, тело `{"status":"ok"}`, заголовок `X-Request-Id`. +Миграции `migrations/*.sql` применяются при старте API идемпотентно через таблицу `schema_migrations`. + +**Публичный smoke** (при уже запущенном стенде): + +```sh +python tests/smoke.py --base-url http://127.0.0.1:8080 +# или: make test BASE_URL=http://127.0.0.1:8080 +``` + +**Проверка сохранности:** + +```sh +# Unix: +chmod +x scripts/restart.sh +python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url http://127.0.0.1:8080 + +# Windows: +python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8080 +``` + +Hook выполняет `docker compose --env-file .env restart` для API и PostgreSQL **без** удаления volumes (`down -v` не используется). + +Локальная проверка автора выполнялась на `HOST_PORT=8081` (host-порт 8080 был занят другим контейнером). + +**Остановка:** + +```sh +docker compose --env-file .env down +``` + +Намеренное удаление учебных данных (volumes): + +```sh +docker compose --env-file .env down -v +``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab1, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +``` +HTTP-клиент + → api (uvicorn + FastAPI) + → SQLAlchemy ORM + → PostgreSQL + users, chats, chat_members, messages, sessions +``` + +- Источник истины — PostgreSQL. In-memory store lab1 заменён. +- ORM-модели: `src/messenger/tables.py`. Доступ к данным: `src/messenger/store.py`. +- Схема версионируется SQL-файлами в `migrations/`; runner — `apply_migrations()` в `src/messenger/db.py` (учёт в `schema_migrations`). Alembic не используется. +- Регистрация требует `password`; hash — Argon2id (`argon2-cffi`). В ответе User пароль/hash не возвращаются. +- `POST /auth/sessions` — только Basic; opaque Bearer-токен (`secrets.token_urlsafe(32)`, ≥256 бит энтропии). В БД хранится SHA-256 токена, `expires_at`, `revoked_at`. +- Защищённые endpoint принимают только Bearer. `X-User-Id` игнорируется и сам по себе доступа не даёт. Basic на бизнес-endpoint → 401. +- Создание чата (chat + members) — одна транзакция SQLAlchemy. +- Keyset-пагинация и формат ошибок перенесены из lab1. +- `/health/live` — процесс; `/health/ready` — доступность PostgreSQL (иначе 503). +- Compose: сервисы `api` + `postgres`, volume `pgdata`, secrets/`.env` в Git не коммитятся. ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Минимум lab1 + переход на auth; публичный smoke | `python tests/smoke.py --base-url http://127.0.0.1:8081` | `PASS: lab2 public API scenario...` | `evidence/smoke.txt` | +| Данные и действующие сессии переживают рестарт без удаления volumes | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8081` | `PASS: persistence preserved confirmed data and existing session...` | `evidence/restart.txt` | +| PostgreSQL: users/chats/members/messages; PK/FK; unique username; миграции с нуля; атомарный чат | `migrations/001_init.sql` + `store.create_chat` в транзакции; повторный restart API | в `schema_migrations` одна запись `001_init.sql`; число users не размножается при повторном migrate | код + проверка ниже | +| Basic только на login; Bearer; TTL/logout; X-User-Id не даёт доступ; password KDF | сценарии внутри smoke (wrong password, Basic на `/users/me`, `X-User-Id`, logout) | соответствующие 401 / logout → 401 | `evidence/smoke.txt` | +| Повторный запуск миграций без дублирования данных; secrets/volumes не в Git | restart API после persistence; `.gitignore` для `.env` и `volumes/` | `001_init.sql` применена один раз; users сохраняются | этот отчёт | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Повторная проверка идемпотентности миграций после persistence: + +```text +SELECT version FROM schema_migrations; → 001_init.sql (1 row) +SELECT COUNT(*) FROM users; → данные на месте, без дублирования схемы +``` ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Для оценки 3 отдельный нагрузочный трек не выполнялся. Проверена сохранность: | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker compose --env-file .env restart` (API + PostgreSQL), volumes сохранены | `/health/ready` ok; прежний Bearer читает те же users/chats/messages; сессия действует | persistence PASS | в бюджете теста (hook ≤90 с, ready ≤90 с); потери данных нет | + +Аппаратный профиль: локальный Docker Desktop на Windows; один API и один PostgreSQL без CPU/RAM limits. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +- Redis/Valkey, EXPLAIN на ≥10k сообщений, отдельные автотесты expiry/гонки/недоступности зависимостей не выполнялись. +- Сессии и бизнес-данные в одном PostgreSQL; недоступность БД → `/health/ready` = 503. +- Basic по HTTP допустим только на локальном учебном стенде с синтетическими данными. diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..b3652e61 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,35 @@ +services: + api: + build: . + image: mtusi-messenger:lab2 + ports: + - "127.0.0.1:${HOST_PORT:-8080}:8080" + environment: + APP_HOST: 0.0.0.0 + APP_PORT: "8080" + APP_ENV: lab + SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600} + DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger + SESSION_STORE: postgres + depends_on: + postgres: + condition: service_healthy + restart: unless-stopped + + postgres: + image: postgres:16-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: messenger + POSTGRES_DB: messenger + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"] + interval: 3s + timeout: 3s + retries: 20 + restart: unless-stopped + +volumes: + pgdata: diff --git a/evidence/restart.txt b/evidence/restart.txt new file mode 100644 index 00000000..c25cebac Binary files /dev/null and b/evidence/restart.txt differ diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..04938cf4 Binary files /dev/null and b/evidence/smoke.txt differ diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..37cafed8 --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,44 @@ +CREATE TABLE users ( + id UUID PRIMARY KEY, + username TEXT NOT NULL, + display_name TEXT NOT NULL, + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE UNIQUE INDEX users_username_uidx ON users (username); + +CREATE TABLE chats ( + id UUID PRIMARY KEY, + title TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE TABLE chat_members ( + chat_id UUID NOT NULL REFERENCES chats (id), + user_id UUID NOT NULL REFERENCES users (id), + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX chat_members_user_idx ON chat_members (user_id); + +CREATE TABLE messages ( + id UUID PRIMARY KEY, + chat_id UUID NOT NULL REFERENCES chats (id), + sender_id UUID NOT NULL REFERENCES users (id), + text TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE INDEX messages_chat_created_id_idx ON messages (chat_id, created_at, id); + +CREATE TABLE sessions ( + token_hash TEXT PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users (id), + expires_at TIMESTAMPTZ NOT NULL, + revoked_at TIMESTAMPTZ, + created_at TIMESTAMPTZ NOT NULL +); + +CREATE INDEX sessions_user_idx ON sessions (user_id); +CREATE INDEX sessions_expires_idx ON sessions (expires_at); diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..fb1be4f7 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.115.6 +uvicorn[standard]==0.34.0 +pydantic==2.10.4 +SQLAlchemy==2.0.36 +psycopg[binary]==3.2.4 +argon2-cffi==23.1.0 diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 00000000..afcfc98d --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,4 @@ +@echo off +cd /d "%~dp0\.." +docker compose --env-file .env restart +exit /b %ERRORLEVEL% diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..70976b0a --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +cd "$(dirname "$0")/.." +docker compose --env-file .env restart diff --git a/src/messenger/__init__.py b/src/messenger/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/messenger/app.py b/src/messenger/app.py new file mode 100644 index 00000000..3b0b14e9 --- /dev/null +++ b/src/messenger/app.py @@ -0,0 +1,223 @@ +from __future__ import annotations + +import base64 +import binascii +import uuid +from contextlib import asynccontextmanager +from typing import Optional +from uuid import UUID + +from fastapi import Depends, FastAPI, Header, Query, Request +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse, Response +from starlette.exceptions import HTTPException as StarletteHTTPException + +from .cursors import decode_cursor, encode_cursor +from .db import apply_migrations, close_engine, init_engine, ping +from .errors import AppError, error_response, request_id_of +from .models import CreateChat, CreateMessage, CreateUser +from .store import store + +BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} +BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'} + + +@asynccontextmanager +async def lifespan(_app: FastAPI): + init_engine() + apply_migrations() + yield + close_engine() + + +app = FastAPI(title="MTUSI Messenger lab2", version="1.2.0", lifespan=lifespan) + + +@app.middleware("http") +async def attach_request_id(request: Request, call_next): + incoming = request.headers.get("x-request-id") + request.state.request_id = incoming.strip() if incoming and incoming.strip() else str(uuid.uuid4()) + response = await call_next(request) + response.headers["X-Request-Id"] = request.state.request_id + return response + + +@app.exception_handler(AppError) +async def app_error_handler(request: Request, exc: AppError) -> JSONResponse: + return error_response( + exc.status_code, + exc.code, + exc.message, + request_id_of(request), + headers=exc.headers, + ) + + +@app.exception_handler(RequestValidationError) +async def validation_error_handler(request: Request, exc: RequestValidationError) -> JSONResponse: + return error_response( + 400, + "invalid_request", + "Request validation failed", + request_id_of(request), + ) + + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse: + code = "not_found" if exc.status_code == 404 else "invalid_request" + headers = None + if exc.status_code == 401: + code = "unauthorized" + headers = BEARER_CHALLENGE + elif exc.status_code >= 500: + code = "internal_error" + message = exc.detail if isinstance(exc.detail, str) else "Request failed" + return error_response( + exc.status_code, + code, + message, + request_id_of(request), + headers=headers, + ) + + +@app.exception_handler(Exception) +async def unhandled_error_handler(request: Request, exc: Exception) -> JSONResponse: + return error_response(500, "internal_error", "Internal server error", request_id_of(request)) + + +def current_user_id(authorization: Optional[str] = Header(default=None)) -> str: + if authorization is None or not authorization.strip(): + raise AppError(401, "unauthorized", "Missing bearer token", headers=BEARER_CHALLENGE) + scheme, _, credential = authorization.partition(" ") + if scheme.lower() != "bearer" or not credential.strip(): + raise AppError(401, "unauthorized", "Bearer token required", headers=BEARER_CHALLENGE) + return store.resolve_bearer(credential.strip()) + + +def require_chat_member(chat_id: UUID, user_id: str): + chat = store.get_chat(str(chat_id)) + if chat is None or user_id not in chat.member_ids: + raise AppError(404, "not_found", "Chat not found") + return chat + + +def parse_basic_credentials(authorization: Optional[str]) -> tuple[str, str]: + if authorization is None or not authorization.strip(): + raise AppError(401, "unauthorized", "Missing basic credentials", headers=BASIC_CHALLENGE) + scheme, _, credential = authorization.partition(" ") + if scheme.lower() != "basic" or not credential.strip(): + raise AppError(401, "unauthorized", "Basic credentials required", headers=BASIC_CHALLENGE) + try: + decoded = base64.b64decode(credential.strip(), validate=True).decode("utf-8") + except (binascii.Error, UnicodeDecodeError, ValueError) as exc: + raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) from exc + if ":" not in decoded: + raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) + username, password = decoded.split(":", 1) + if not username or not username.isascii(): + raise AppError(401, "unauthorized", "Invalid basic credentials", headers=BASIC_CHALLENGE) + return username, password + + +@app.get("/health/live") +def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +def health_ready(): + if not ping(): + raise AppError(503, "unavailable", "Database is unavailable") + return {"status": "ok"} + + +@app.post("/api/v1/users", status_code=201) +def register_user(body: CreateUser): + user = store.create_user(body.username, body.display_name, body.password) + return user.to_dict() + + +@app.post("/api/v1/auth/sessions", status_code=201) +def create_session(authorization: Optional[str] = Header(default=None)): + username, password = parse_basic_credentials(authorization) + session = store.create_session(username, password) + return session.to_dict() + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +def revoke_session(authorization: Optional[str] = Header(default=None)): + if authorization is None or not authorization.strip(): + raise AppError(401, "unauthorized", "Missing bearer token", headers=BEARER_CHALLENGE) + scheme, _, credential = authorization.partition(" ") + if scheme.lower() != "bearer" or not credential.strip(): + raise AppError(401, "unauthorized", "Bearer token required", headers=BEARER_CHALLENGE) + store.revoke_session(credential.strip()) + return Response(status_code=204) + + +@app.get("/api/v1/users/me") +def get_me(user_id: str = Depends(current_user_id)): + user = store.get_user(user_id) + if user is None: + raise AppError(401, "unauthorized", "Unknown user", headers=BEARER_CHALLENGE) + return user.to_dict() + + +@app.post("/api/v1/chats", status_code=201) +def create_chat(body: CreateChat, user_id: str = Depends(current_user_id)): + member_ids = [str(m) for m in body.member_ids] + if user_id not in member_ids: + raise AppError(400, "invalid_request", "Caller must be included in member_ids") + chat = store.create_chat(body.title, member_ids) + return chat.to_dict() + + +@app.get("/api/v1/chats") +def list_chats( + user_id: str = Depends(current_user_id), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +): + resource = f"chats:{user_id}" + after = decode_cursor(cursor, resource) if cursor else None + page, last_for_cursor = store.list_chats_for_user(user_id, limit, after) + next_cursor = None + if last_for_cursor is not None: + next_cursor = encode_cursor(last_for_cursor.created_at, last_for_cursor.id, resource) + return {"items": [c.to_dict() for c in page], "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}") +def get_chat(chat_id: UUID, user_id: str = Depends(current_user_id)): + chat = require_chat_member(chat_id, user_id) + return chat.to_dict() + + +@app.post("/api/v1/chats/{chat_id}/messages", status_code=201) +def create_message( + chat_id: UUID, + body: CreateMessage, + user_id: str = Depends(current_user_id), +): + require_chat_member(chat_id, user_id) + message = store.create_message(str(chat_id), user_id, body.text) + return message.to_dict() + + +@app.get("/api/v1/chats/{chat_id}/messages") +def list_messages( + chat_id: UUID, + user_id: str = Depends(current_user_id), + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1), +): + require_chat_member(chat_id, user_id) + resource = f"messages:{chat_id}" + after = decode_cursor(cursor, resource) if cursor else None + page, last_for_cursor = store.list_messages(str(chat_id), limit, after) + next_cursor = None + if last_for_cursor is not None: + next_cursor = encode_cursor(last_for_cursor.created_at, last_for_cursor.id, resource) + return {"items": [m.to_dict() for m in page], "next_cursor": next_cursor} diff --git a/src/messenger/cursors.py b/src/messenger/cursors.py new file mode 100644 index 00000000..67fdd0b4 --- /dev/null +++ b/src/messenger/cursors.py @@ -0,0 +1,34 @@ +from __future__ import annotations + +import base64 +import json +from typing import Tuple + +from .errors import AppError + + +def encode_cursor(created_at: str, item_id: str, resource: str) -> str: + raw = json.dumps( + {"t": created_at, "i": item_id, "r": resource}, + separators=(",", ":"), + ensure_ascii=False, + ).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=") + + +def decode_cursor(cursor: str, expected_resource: str) -> Tuple[str, str]: + try: + padded = cursor + "=" * (-len(cursor) % 4) + data = json.loads(base64.urlsafe_b64decode(padded.encode("ascii")).decode("utf-8")) + created_at = data["t"] + item_id = data["i"] + resource = data["r"] + if not isinstance(created_at, str) or not isinstance(item_id, str): + raise ValueError("bad cursor fields") + if resource != expected_resource: + raise AppError(400, "invalid_request", "Cursor does not belong to this resource") + return created_at, item_id + except AppError: + raise + except Exception as exc: + raise AppError(400, "invalid_request", "Invalid cursor") from exc diff --git a/src/messenger/db.py b/src/messenger/db.py new file mode 100644 index 00000000..feff3d18 --- /dev/null +++ b/src/messenger/db.py @@ -0,0 +1,115 @@ +from __future__ import annotations + +import os +from contextlib import contextmanager +from pathlib import Path +from typing import Iterator, Optional + +from sqlalchemy import create_engine, text +from sqlalchemy.engine import Engine +from sqlalchemy.orm import Session, sessionmaker + +_engine: Optional[Engine] = None +_SessionLocal: Optional[sessionmaker[Session]] = None + + +def _read_database_url() -> str: + url_file = os.environ.get("DATABASE_URL_FILE") + if url_file: + url = Path(url_file).read_text(encoding="utf-8").strip() + else: + url = os.environ.get("DATABASE_URL") + if not url: + raise RuntimeError("DATABASE_URL or DATABASE_URL_FILE is required") + url = url.strip() + if url.startswith("postgresql://"): + url = "postgresql+psycopg://" + url[len("postgresql://") :] + elif url.startswith("postgres://"): + url = "postgresql+psycopg://" + url[len("postgres://") :] + return url + + +def init_engine() -> Engine: + global _engine, _SessionLocal + if _engine is not None: + return _engine + _engine = create_engine( + _read_database_url(), + pool_size=5, + max_overflow=5, + pool_pre_ping=True, + pool_timeout=10, + ) + _SessionLocal = sessionmaker(bind=_engine, expire_on_commit=False) + return _engine + + +def get_engine() -> Engine: + if _engine is None: + raise RuntimeError("database engine is not initialized") + return _engine + + +@contextmanager +def session_scope() -> Iterator[Session]: + if _SessionLocal is None: + raise RuntimeError("database engine is not initialized") + session = _SessionLocal() + try: + yield session + session.commit() + except Exception: + session.rollback() + raise + finally: + session.close() + + +def close_engine() -> None: + global _engine, _SessionLocal + if _engine is not None: + _engine.dispose() + _engine = None + _SessionLocal = None + + +def migrations_dir() -> Path: + return Path(__file__).resolve().parents[2] / "migrations" + + +def apply_migrations() -> None: + engine = get_engine() + with engine.begin() as conn: + conn.execute( + text( + """ + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + ) + """ + ) + ) + applied = { + row[0] + for row in conn.execute(text("SELECT version FROM schema_migrations")).fetchall() + } + for path in sorted(migrations_dir().glob("*.sql")): + version = path.name + if version in applied: + continue + conn.exec_driver_sql(path.read_text(encoding="utf-8")) + conn.execute( + text("INSERT INTO schema_migrations (version) VALUES (:version)"), + {"version": version}, + ) + + +def ping() -> bool: + try: + engine = get_engine() + with engine.connect() as conn: + conn.execute(text("SELECT 1")) + return True + except Exception: + return False diff --git a/src/messenger/errors.py b/src/messenger/errors.py new file mode 100644 index 00000000..8adfcc2d --- /dev/null +++ b/src/messenger/errors.py @@ -0,0 +1,45 @@ +from __future__ import annotations + +from typing import Optional + +from fastapi import Request +from fastapi.responses import JSONResponse + + +class AppError(Exception): + def __init__( + self, + status_code: int, + code: str, + message: str, + headers: Optional[dict] = None, + ) -> None: + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers + super().__init__(message) + + +def request_id_of(request: Request) -> str: + return getattr(request.state, "request_id", "unknown") + + +def error_response( + status_code: int, + code: str, + message: str, + request_id: str, + headers: Optional[dict] = None, +) -> JSONResponse: + payload = { + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + } + response_headers = {"X-Request-Id": request_id} + if headers: + response_headers.update(headers) + return JSONResponse(status_code=status_code, content=payload, headers=response_headers) diff --git a/src/messenger/models.py b/src/messenger/models.py new file mode 100644 index 00000000..b2b53251 --- /dev/null +++ b/src/messenger/models.py @@ -0,0 +1,72 @@ +from __future__ import annotations + +import re +from typing import List +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator + +USERNAME_RE = re.compile(r"^[a-z0-9_]{3,32}$") + + +def _not_blank(value: str, field_name: str) -> str: + if value.strip() == "": + raise ValueError(f"{field_name} must not be blank") + return value + + +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) + + @field_validator("username") + @classmethod + def validate_username(cls, value: str) -> str: + if not USERNAME_RE.fullmatch(value): + raise ValueError("username must match [a-z0-9_]{3,32}") + return value + + @field_validator("display_name") + @classmethod + def validate_display_name(cls, value: str) -> str: + return _not_blank(value, "display_name") + + @field_validator("password") + @classmethod + def validate_password(cls, value: str) -> str: + if len(value) < 12 or len(value) > 128: + raise ValueError("password length must be 12-128") + return value + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field(min_length=1, max_length=100) + member_ids: List[UUID] = Field(min_length=1, max_length=100) + + @field_validator("title") + @classmethod + def validate_title(cls, value: str) -> str: + return _not_blank(value, "title") + + @field_validator("member_ids") + @classmethod + def validate_members(cls, value: List[UUID]) -> List[UUID]: + if len(value) != len(set(value)): + raise ValueError("member_ids must be unique") + return value + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field(min_length=1, max_length=4000) + + @field_validator("text") + @classmethod + def validate_text(cls, value: str) -> str: + return _not_blank(value, "text") diff --git a/src/messenger/store.py b/src/messenger/store.py new file mode 100644 index 00000000..183ab66b --- /dev/null +++ b/src/messenger/store.py @@ -0,0 +1,325 @@ +from __future__ import annotations + +import hashlib +import os +import secrets +import uuid +from dataclasses import dataclass +from datetime import datetime, timedelta, timezone +from typing import List, Optional, Tuple +from uuid import UUID + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError +from sqlalchemy import func, select, tuple_ +from sqlalchemy.exc import IntegrityError + +from .db import session_scope +from .errors import AppError +from .tables import ChatMemberRow, ChatRow, MessageRow, SessionRow, UserRow + +password_hasher = PasswordHasher() + + +def utc_now() -> datetime: + return datetime.now(timezone.utc) + + +def format_ts(value: datetime) -> str: + if value.tzinfo is None: + value = value.replace(tzinfo=timezone.utc) + return value.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z") + + +def parse_ts(value: str) -> datetime: + return datetime.fromisoformat(value.replace("Z", "+00:00")) + + +def session_ttl_seconds() -> int: + raw = os.environ.get("SESSION_TTL_SECONDS", "3600") + return max(1, int(raw)) + + +def hash_token(token: str) -> str: + return hashlib.sha256(token.encode("utf-8")).hexdigest() + + +@dataclass +class User: + id: str + username: str + display_name: str + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "username": self.username, + "display_name": self.display_name, + "created_at": self.created_at, + } + + +@dataclass +class Chat: + id: str + title: str + member_ids: List[str] + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "title": self.title, + "member_ids": list(self.member_ids), + "created_at": self.created_at, + } + + +@dataclass +class Message: + id: str + chat_id: str + sender_id: str + text: str + created_at: str + + def to_dict(self) -> dict: + return { + "id": self.id, + "chat_id": self.chat_id, + "sender_id": self.sender_id, + "text": self.text, + "created_at": self.created_at, + } + + +@dataclass +class Session: + token: str + token_type: str + expires_at: str + user: User + + def to_dict(self) -> dict: + return { + "token": self.token, + "token_type": self.token_type, + "expires_at": self.expires_at, + "user": self.user.to_dict(), + } + + +def _user_from_row(row: UserRow) -> User: + return User( + id=str(row.id), + username=row.username, + display_name=row.display_name, + created_at=format_ts(row.created_at), + ) + + +def _chat_from_row(row: ChatRow, member_ids: List[str]) -> Chat: + return Chat( + id=str(row.id), + title=row.title, + member_ids=member_ids, + created_at=format_ts(row.created_at), + ) + + +def _message_from_row(row: MessageRow) -> Message: + return Message( + id=str(row.id), + chat_id=str(row.chat_id), + sender_id=str(row.sender_id), + text=row.text, + created_at=format_ts(row.created_at), + ) + + +def _member_ids(session, chat_id: UUID) -> List[str]: + rows = session.scalars( + select(ChatMemberRow.user_id) + .where(ChatMemberRow.chat_id == chat_id) + .order_by(ChatMemberRow.user_id) + ).all() + return [str(user_id) for user_id in rows] + + +class Store: + def create_user(self, username: str, display_name: str, password: str) -> User: + row = UserRow( + id=uuid.uuid4(), + username=username, + display_name=display_name, + password_hash=password_hasher.hash(password), + created_at=utc_now(), + ) + try: + with session_scope() as session: + session.add(row) + session.flush() + return _user_from_row(row) + except IntegrityError as exc: + raise AppError(409, "conflict", "Username is already taken") from exc + + def get_user(self, user_id: str) -> Optional[User]: + with session_scope() as session: + row = session.get(UserRow, UUID(user_id)) + return _user_from_row(row) if row else None + + def create_session(self, username: str, password: str) -> Session: + with session_scope() as session: + row = session.scalar(select(UserRow).where(UserRow.username == username)) + if row is None: + raise AppError( + 401, + "unauthorized", + "Invalid credentials", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) + try: + password_hasher.verify(row.password_hash, password) + except VerifyMismatchError as exc: + raise AppError( + 401, + "unauthorized", + "Invalid credentials", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}, + ) from exc + + token = secrets.token_urlsafe(32) + expires_at = utc_now() + timedelta(seconds=session_ttl_seconds()) + session.add( + SessionRow( + token_hash=hash_token(token), + user_id=row.id, + expires_at=expires_at, + created_at=utc_now(), + ) + ) + user = _user_from_row(row) + return Session( + token=token, + token_type="Bearer", + expires_at=format_ts(expires_at), + user=user, + ) + + def resolve_bearer(self, token: str) -> str: + with session_scope() as session: + row = session.get(SessionRow, hash_token(token)) + challenge = {"WWW-Authenticate": 'Bearer realm="messenger"'} + if row is None: + raise AppError(401, "unauthorized", "Invalid session", headers=challenge) + if row.revoked_at is not None: + raise AppError(401, "unauthorized", "Session revoked", headers=challenge) + expires_at = row.expires_at + if expires_at.tzinfo is None: + expires_at = expires_at.replace(tzinfo=timezone.utc) + if expires_at <= utc_now(): + raise AppError(401, "unauthorized", "Session expired", headers=challenge) + return str(row.user_id) + + def revoke_session(self, token: str) -> None: + with session_scope() as session: + row = session.get(SessionRow, hash_token(token), with_for_update=True) + challenge = {"WWW-Authenticate": 'Bearer realm="messenger"'} + if row is None: + raise AppError(401, "unauthorized", "Invalid session", headers=challenge) + if row.revoked_at is not None: + raise AppError(401, "unauthorized", "Session revoked", headers=challenge) + expires_at = row.expires_at + if expires_at.tzinfo is None: + expires_at = expires_at.replace(tzinfo=timezone.utc) + if expires_at <= utc_now(): + raise AppError(401, "unauthorized", "Session expired", headers=challenge) + row.revoked_at = utc_now() + + def create_chat(self, title: str, member_ids: List[str]) -> Chat: + chat_id = uuid.uuid4() + member_uuids = [UUID(m) for m in member_ids] + with session_scope() as session: + existing = session.scalar( + select(func.count()).select_from(UserRow).where(UserRow.id.in_(member_uuids)) + ) + if existing != len(member_uuids): + raise AppError(400, "invalid_request", "Unknown member in member_ids") + chat = ChatRow(id=chat_id, title=title, created_at=utc_now()) + session.add(chat) + for member_id in member_uuids: + session.add(ChatMemberRow(chat_id=chat_id, user_id=member_id)) + session.flush() + return _chat_from_row(chat, list(member_ids)) + + def get_chat(self, chat_id: str) -> Optional[Chat]: + with session_scope() as session: + row = session.get(ChatRow, UUID(chat_id)) + if row is None: + return None + return _chat_from_row(row, _member_ids(session, row.id)) + + def list_chats_for_user( + self, + user_id: str, + limit: int, + after: Optional[Tuple[str, str]] = None, + ) -> Tuple[List[Chat], Optional[Chat]]: + with session_scope() as session: + stmt = ( + select(ChatRow) + .join(ChatMemberRow, ChatMemberRow.chat_id == ChatRow.id) + .where(ChatMemberRow.user_id == UUID(user_id)) + ) + if after is not None: + stmt = stmt.where( + tuple_(ChatRow.created_at, ChatRow.id) + > (parse_ts(after[0]), UUID(after[1])) + ) + stmt = stmt.order_by(ChatRow.created_at.asc(), ChatRow.id.asc()).limit(limit + 1) + rows = list(session.scalars(stmt).all()) + chats = [_chat_from_row(row, _member_ids(session, row.id)) for row in rows] + page = chats[:limit] + has_more = len(chats) > limit + last = page[-1] if page and has_more else None + return page, last + + def create_message(self, chat_id: str, sender_id: str, text: str) -> Message: + row = MessageRow( + id=uuid.uuid4(), + chat_id=UUID(chat_id), + sender_id=UUID(sender_id), + text=text, + created_at=utc_now(), + ) + with session_scope() as session: + session.add(row) + session.flush() + return _message_from_row(row) + + def list_messages( + self, + chat_id: str, + limit: int, + after: Optional[Tuple[str, str]] = None, + ) -> Tuple[List[Message], Optional[Message]]: + with session_scope() as session: + stmt = select(MessageRow).where(MessageRow.chat_id == UUID(chat_id)) + if after is not None: + stmt = stmt.where( + tuple_(MessageRow.created_at, MessageRow.id) + > (parse_ts(after[0]), UUID(after[1])) + ) + stmt = stmt.order_by(MessageRow.created_at.asc(), MessageRow.id.asc()).limit( + limit + 1 + ) + rows = list(session.scalars(stmt).all()) + messages = [_message_from_row(row) for row in rows] + page = messages[:limit] + has_more = len(messages) > limit + last = page[-1] if page and has_more else None + return page, last + + +store = Store() diff --git a/src/messenger/tables.py b/src/messenger/tables.py new file mode 100644 index 00000000..740e6563 --- /dev/null +++ b/src/messenger/tables.py @@ -0,0 +1,63 @@ +from __future__ import annotations + +import uuid +from datetime import datetime +from typing import List, Optional + +from sqlalchemy import DateTime, ForeignKey, String, Text, Uuid +from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship + + +class Base(DeclarativeBase): + pass + + +class UserRow(Base): + __tablename__ = "users" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + username: Mapped[str] = mapped_column(Text, nullable=False, unique=True) + display_name: Mapped[str] = mapped_column(Text, nullable=False) + password_hash: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + +class ChatRow(Base): + __tablename__ = "chats" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + title: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + members: Mapped[List["ChatMemberRow"]] = relationship(back_populates="chat") + + +class ChatMemberRow(Base): + __tablename__ = "chat_members" + + chat_id: Mapped[uuid.UUID] = mapped_column( + Uuid, ForeignKey("chats.id"), primary_key=True + ) + user_id: Mapped[uuid.UUID] = mapped_column( + Uuid, ForeignKey("users.id"), primary_key=True + ) + chat: Mapped[ChatRow] = relationship(back_populates="members") + + +class MessageRow(Base): + __tablename__ = "messages" + + id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True) + chat_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("chats.id"), nullable=False) + sender_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False) + text: Mapped[str] = mapped_column(Text, nullable=False) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + + +class SessionRow(Base): + __tablename__ = "sessions" + + token_hash: Mapped[str] = mapped_column(String, primary_key=True) + user_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("users.id"), nullable=False) + expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False) + revoked_at: Mapped[Optional[datetime]] = mapped_column(DateTime(timezone=True), nullable=True) + created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)