Author SHA1 Message Date
Lev_g 6e5bd84969 Обновить REPORT.md 2026-11-17 00:04:04 +03:00
Lev_g b9c8b21209 Обновить REPORT.md 2026-11-09 23:17:55 +03:00
Lev_g 21d4008691 lab2: PostgreSQL, сессии и Compose 2026-11-09 22:39:24 +03:00
18 changed files with 1113 additions and 18 deletions
+7 -4
View File
@@ -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
+19
View File
@@ -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}"]
+117 -14
View File
@@ -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 допустим только на локальном учебном стенде с синтетическими данными.
+35
View File
@@ -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:
Binary file not shown.
Binary file not shown.
+44
View File
@@ -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);
+6
View File
@@ -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
+4
View File
@@ -0,0 +1,4 @@
@echo off
cd /d "%~dp0\.."
docker compose --env-file .env restart
exit /b %ERRORLEVEL%
+4
View File
@@ -0,0 +1,4 @@
#!/bin/sh
set -eu
cd "$(dirname "$0")/.."
docker compose --env-file .env restart
View File
+223
View File
@@ -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}
+34
View File
@@ -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
+115
View File
@@ -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
+45
View File
@@ -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)
+72
View File
@@ -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")
+325
View File
@@ -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()
+63
View File
@@ -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)