lab3: Compose+Nginx, две API-реплики и идемпотентность
This commit is contained in:
+4
-5
@@ -1,13 +1,12 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
# Host publish port of the load balancer; 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
|
||||
DATABASE_URL=postgresql://messenger:messenger@postgres:5432/messenger
|
||||
# DATABASE_URL_FILE=/run/secrets/database_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
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/
|
||||
COPY scripts/migrate.py ./scripts/migrate.py
|
||||
|
||||
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}"]
|
||||
@@ -1,37 +1,153 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Гадяцкий Л. Е., БПИ2302
|
||||
- Целевая оценка: 3
|
||||
- Commit/PR: solution/BPI2302-Gadiatskiy
|
||||
- Использованные источники и библиотеки:
|
||||
- контракт и семантика: `contracts/openapi.json`, `contracts/README.md`, `README.md`, `COURSE.md`
|
||||
- перенос из lab2: FastAPI, PostgreSQL/сессии, SQLAlchemy, миграции, формат ошибок
|
||||
- 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`; LB: `nginx:1.27-alpine`
|
||||
- Помощь ИИ использована при переносе lab2, частично при настройке Compose+Nginx и при написании отчёта. Результаты подтверждаются сохранёнными запусками.
|
||||
|
||||
## Запуск из чистого 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:lab3`
|
||||
- PostgreSQL: `postgres:16-alpine`
|
||||
- Nginx: `nginx:1.27-alpine`
|
||||
- зависимости: `requirements.txt`
|
||||
|
||||
**Конфигурация:** секретов в Git нет. Локальный `.env` создаётся из примера и не коммитится:
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
```
|
||||
|
||||
Соответствие `.env.example`:
|
||||
- `APP_HOST` / `APP_PORT` — bind uvicorn внутри контейнеров API
|
||||
- `HOST_PORT` — порт LB на host (по умолчанию 8080; если занят — например 8081)
|
||||
- `APP_ENV` — среда запуска (`lab`)
|
||||
- `SESSION_TTL_SECONDS` — TTL сессии (по умолчанию 3600; для обычного smoke ≥ 300)
|
||||
- `SESSION_STORE=postgres` — сессии в PostgreSQL (общие для всех реплик)
|
||||
- `DATABASE_URL` — строка подключения API/migrate к PostgreSQL в compose-сети
|
||||
(приложение также поддерживает `DATABASE_URL_FILE`)
|
||||
- `IDEMPOTENCY_TTL_SECONDS` — срок хранения идемпотентных записей (по умолчанию 86400)
|
||||
- `API_REPLICAS=2` — в `compose.yaml` зафиксированы сервисы `api1` и `api2`
|
||||
|
||||
Учебные credentials compose (`messenger` / `messenger`) только для локального синтетического стенда.
|
||||
|
||||
**Сборка и запуск:**
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env up -d --build
|
||||
```
|
||||
|
||||
Миграции `migrations/*.sql` применяет one-shot сервис `migrate` до старта `api1`/`api2` (учёт в `schema_migrations`). Реплики API миграции при старте не выполняют.
|
||||
|
||||
Готовность через LB (подставьте свой `HOST_PORT`):
|
||||
|
||||
```sh
|
||||
curl -i http://127.0.0.1:8080/health/ready
|
||||
```
|
||||
|
||||
Ожидается HTTP 200, тело `{"status":"ok"}`, заголовки `X-Request-Id` и `X-Instance-Id` (`api1` или `api2`).
|
||||
|
||||
**Публичный 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` для `postgres`, `api1`, `api2`, `lb` **без** удаления volumes (`down -v` не используется).
|
||||
|
||||
**Проверка отказа одной API-реплики:**
|
||||
|
||||
```sh
|
||||
# Unix:
|
||||
chmod +x scripts/stop-one.sh
|
||||
python tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url http://127.0.0.1:8080
|
||||
|
||||
# Windows:
|
||||
python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:8080
|
||||
```
|
||||
|
||||
`TARGET_INSTANCE_ID` = `X-Instance-Id` (`api1`/`api2`); hook делает `docker compose stop` только этой реплики и оставляет её остановленной. После теста: `docker compose --env-file .env start api1` (или `api2`). Для защиты повторить на второй реплике после восстановления первой.
|
||||
|
||||
Локальная проверка автора выполнялась на `HOST_PORT=8082` (host-порты 8080/8081 были заняты другими контейнерами).
|
||||
|
||||
**Остановка:**
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env down
|
||||
```
|
||||
|
||||
Намеренное удаление учебных данных (volumes):
|
||||
|
||||
```sh
|
||||
docker compose --env-file .env down -v
|
||||
```
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
```
|
||||
HTTP-клиент
|
||||
→ lb (Nginx)
|
||||
→ api1 / api2 (uvicorn + FastAPI)
|
||||
→ PostgreSQL
|
||||
users, chats, chat_members, messages, sessions, idempotency_records
|
||||
```
|
||||
|
||||
- Источник истины — PostgreSQL. Локального состояния, от которого зависит корректность, в API нет.
|
||||
- Сессии в PostgreSQL: один Bearer работает через любую реплику без sticky sessions.
|
||||
- `X-Instance-Id` стабилен на жизнь процесса (`INSTANCE_ID` сервиса).
|
||||
- `Idempotency-Key` обязателен на `POST .../messages`; область: пользователь + метод + путь + ключ; запись результата атомарна с сообщением; другой body при том же ключе → 409; TTL 24ч.
|
||||
- ORM-модели: `src/messenger/tables.py`. Доступ к данным: `src/messenger/store.py`.
|
||||
- Миграции: SQL в `migrations/` + one-shot `migrate`; Alembic не используется.
|
||||
- Порты API наружу не публикуются; публичная точка входа — LB (`infra/nginx.conf`: `least_conn`, `max_fails=1`, `proxy_next_upstream`).
|
||||
- Compose: `lb` + `api1` + `api2` + `postgres` + `migrate`, volume `pgdata`; `.env` в Git не коммитится.
|
||||
|
||||
Перенесено из lab2: auth Basic→Bearer, Argon2id, чаты/сообщения, keyset-пагинация, формат ошибок.
|
||||
Добавлено в lab3: Nginx LB, две реплики API, `X-Instance-Id`, общая идемпотентность, отдельный migrate, `scripts/stop-one`.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke (lab2 + Idempotency-Key / X-Instance-Id) | `python tests/smoke.py --base-url http://127.0.0.1:8082` | `PASS: lab3 public API scenario...` | `evidence/smoke.txt` |
|
||||
| Стенд: ≥2 API, один LB, общая БД и сессии | `docker compose --env-file .env ps` | `lb`, `api1`, `api2`, `postgres`; migrate Exited 0 | `evidence/compose-ps.txt` |
|
||||
| Разные реплики через LB с одной сессией | серия запросов через LB | `api1` и `api2` | `evidence/instances.txt` |
|
||||
| Persistence: рестарт без удаления volumes, прежний токен | `python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://127.0.0.1:8082` | `PASS: persistence preserved...` | `evidence/restart.txt` |
|
||||
| Failover: остановка одной API-реплики | `python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://127.0.0.1:8082` | 2 instance до отказа; first_recovery ≈2.75 с; без дублей | `evidence/failover.txt` |
|
||||
| Идемпотентность POST сообщений | smoke replay + failover retries | тот же ключ → то же Message; другой body → 409 | `evidence/smoke.txt`, `evidence/failover.txt` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Для оценки 3 отдельный нагрузочный трек не выполнялся. Проверены сохранность и отказ API-реплики:
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| `docker compose --env-file .env restart` (postgres+api1+api2+lb), volumes сохранены | `/health/ready` ok; прежний Bearer читает те же данные; сессия действует | persistence PASS | в бюджете теста (hook ≤90 с, ready ≤90 с); потери данных нет |
|
||||
| `docker compose stop` одной API-реплики | LB обслуживает живую; записи ≤10 с; без дублей по retry | failover PASS; `first_recovery_seconds≈2.75` | подтверждённые сообщения на месте |
|
||||
|
||||
Аппаратный профиль: локальный Docker Desktop на Windows; 2 API + Nginx + PostgreSQL без CPU/RAM limits.
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
- Redis/Valkey, CPU/RAM limits, rolling update под нагрузкой и трек 5 не выполнялись.
|
||||
- Единственный PostgreSQL и единственный Nginx — SPOF; отказ host/узла не выдерживается.
|
||||
- Basic по HTTP допустим только на локальном учебном стенде с синтетическими данными.
|
||||
|
||||
+105
@@ -0,0 +1,105 @@
|
||||
x-api: &api
|
||||
build: .
|
||||
image: mtusi-messenger:lab3
|
||||
expose:
|
||||
- "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
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
depends_on:
|
||||
migrate:
|
||||
condition: service_completed_successfully
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test:
|
||||
[
|
||||
"CMD",
|
||||
"python",
|
||||
"-c",
|
||||
"import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)",
|
||||
]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
start_period: 5s
|
||||
restart: unless-stopped
|
||||
|
||||
services:
|
||||
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
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: mtusi-messenger:lab3
|
||||
environment:
|
||||
DATABASE_URL: postgresql://messenger:messenger@postgres:5432/messenger
|
||||
command: ["python", "/app/scripts/migrate.py"]
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
|
||||
api1:
|
||||
<<: *api
|
||||
hostname: api1
|
||||
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
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
INSTANCE_ID: api1
|
||||
|
||||
api2:
|
||||
<<: *api
|
||||
hostname: api2
|
||||
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
|
||||
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:-86400}
|
||||
INSTANCE_ID: api2
|
||||
|
||||
lb:
|
||||
image: nginx:1.27-alpine
|
||||
ports:
|
||||
- "127.0.0.1:${HOST_PORT:-8080}:80"
|
||||
volumes:
|
||||
- ./infra/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
depends_on:
|
||||
api1:
|
||||
condition: service_healthy
|
||||
api2:
|
||||
condition: service_healthy
|
||||
healthcheck:
|
||||
test: ["CMD", "wget", "-qO-", "http://127.0.0.1/health/live"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,5 @@
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
mtusi2026lab3-fork-api1-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api1 24 minutes ago Up 32 seconds (healthy) 8080/tcp
|
||||
mtusi2026lab3-fork-api2-1 mtusi-messenger:lab3 "sh -c 'exec uvicorn…" api2 24 minutes ago Up 54 seconds (healthy) 8080/tcp
|
||||
mtusi2026lab3-fork-lb-1 nginx:1.27-alpine "/docker-entrypoint.…" lb 24 minutes ago Up 54 seconds (healthy) 127.0.0.1:8082->80/tcp
|
||||
mtusi2026lab3-fork-postgres-1 postgres:16-alpine "docker-entrypoint.s…" postgres 24 minutes ago Up 54 seconds (healthy) 5432/tcp
|
||||
@@ -0,0 +1,3 @@
|
||||
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
|
||||
{"observed_instances_before": 2, "successful_writes": 67, "failed_attempts": 1, "first_recovery_seconds": 0.625}
|
||||
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1,2 @@
|
||||
observed=api1,api2
|
||||
{'api2': 20, 'api1': 20}
|
||||
@@ -0,0 +1,2 @@
|
||||
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
|
||||
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
|
||||
@@ -0,0 +1 @@
|
||||
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
|
||||
@@ -0,0 +1,40 @@
|
||||
worker_processes auto;
|
||||
error_log /var/log/nginx/error.log warn;
|
||||
pid /var/run/nginx.pid;
|
||||
|
||||
events {
|
||||
worker_connections 1024;
|
||||
}
|
||||
|
||||
http {
|
||||
include /etc/nginx/mime.types;
|
||||
default_type application/octet-stream;
|
||||
access_log /var/log/nginx/access.log;
|
||||
sendfile on;
|
||||
keepalive_timeout 65;
|
||||
|
||||
upstream api_backends {
|
||||
least_conn;
|
||||
server api1:8080 max_fails=1 fail_timeout=3s;
|
||||
server api2:8080 max_fails=1 fail_timeout=3s;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 80;
|
||||
server_name _;
|
||||
|
||||
location / {
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header Connection "";
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
proxy_connect_timeout 2s;
|
||||
proxy_send_timeout 10s;
|
||||
proxy_read_timeout 10s;
|
||||
proxy_next_upstream error timeout http_502 http_503 http_504;
|
||||
proxy_next_upstream_tries 2;
|
||||
proxy_pass http://api_backends;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
@@ -0,0 +1,9 @@
|
||||
CREATE TABLE idempotency_records (
|
||||
scope_key TEXT PRIMARY KEY,
|
||||
request_hash TEXT NOT NULL,
|
||||
message_id UUID NOT NULL REFERENCES messages (id),
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
expires_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX idempotency_records_expires_idx ON idempotency_records (expires_at);
|
||||
@@ -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
|
||||
@@ -0,0 +1,15 @@
|
||||
#!/usr/bin/env python3
|
||||
from messenger.db import apply_migrations, close_engine, init_engine
|
||||
|
||||
|
||||
def main() -> None:
|
||||
init_engine()
|
||||
try:
|
||||
apply_migrations()
|
||||
print("migrations applied")
|
||||
finally:
|
||||
close_engine()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,4 @@
|
||||
@echo off
|
||||
cd /d "%~dp0\.."
|
||||
docker compose --env-file .env restart postgres api1 api2 lb
|
||||
exit /b %ERRORLEVEL%
|
||||
@@ -0,0 +1,4 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env restart postgres api1 api2 lb
|
||||
@@ -0,0 +1,12 @@
|
||||
@echo off
|
||||
cd /d "%~dp0\.."
|
||||
if "%TARGET_INSTANCE_ID%"=="" (
|
||||
echo TARGET_INSTANCE_ID is required >&2
|
||||
exit /b 1
|
||||
)
|
||||
if /I not "%TARGET_INSTANCE_ID%"=="api1" if /I not "%TARGET_INSTANCE_ID%"=="api2" (
|
||||
echo unknown TARGET_INSTANCE_ID: %TARGET_INSTANCE_ID% >&2
|
||||
exit /b 1
|
||||
)
|
||||
docker compose --env-file .env stop %TARGET_INSTANCE_ID%
|
||||
exit /b %ERRORLEVEL%
|
||||
@@ -0,0 +1,14 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
|
||||
case "$TARGET_INSTANCE_ID" in
|
||||
api1|api2)
|
||||
docker compose --env-file .env stop "$TARGET_INSTANCE_ID"
|
||||
;;
|
||||
*)
|
||||
printf '%s\n' "unknown TARGET_INSTANCE_ID: $TARGET_INSTANCE_ID" >&2
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
@@ -0,0 +1,245 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import binascii
|
||||
import os
|
||||
import re
|
||||
import socket
|
||||
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 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"'}
|
||||
IDEMPOTENCY_KEY_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
||||
INSTANCE_ID = os.environ.get("INSTANCE_ID") or socket.gethostname()
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(_app: FastAPI):
|
||||
init_engine()
|
||||
yield
|
||||
close_engine()
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger lab3", version="1.3.0", lifespan=lifespan)
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def attach_request_and_instance(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
|
||||
response.headers["X-Instance-Id"] = INSTANCE_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
|
||||
|
||||
|
||||
def require_idempotency_key(idempotency_key: Optional[str] = Header(default=None, alias="Idempotency-Key")) -> str:
|
||||
if idempotency_key is None or not idempotency_key.strip():
|
||||
raise AppError(400, "invalid_request", "Idempotency-Key is required")
|
||||
key = idempotency_key.strip()
|
||||
if not IDEMPOTENCY_KEY_RE.fullmatch(key):
|
||||
raise AppError(400, "invalid_request", "Idempotency-Key format is invalid")
|
||||
return key
|
||||
|
||||
|
||||
@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,
|
||||
request: Request,
|
||||
user_id: str = Depends(current_user_id),
|
||||
idempotency_key: str = Depends(require_idempotency_key),
|
||||
):
|
||||
require_chat_member(chat_id, user_id)
|
||||
message = store.create_message(
|
||||
str(chat_id),
|
||||
user_id,
|
||||
body.text,
|
||||
idempotency_key=idempotency_key,
|
||||
request_path=request.url.path,
|
||||
)
|
||||
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}
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
@@ -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")
|
||||
@@ -0,0 +1,404 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
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 delete, func, select, tuple_
|
||||
from sqlalchemy.exc import IntegrityError
|
||||
|
||||
from .db import session_scope
|
||||
from .errors import AppError
|
||||
from .tables import (
|
||||
ChatMemberRow,
|
||||
ChatRow,
|
||||
IdempotencyRow,
|
||||
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 idempotency_ttl_seconds() -> int:
|
||||
raw = os.environ.get("IDEMPOTENCY_TTL_SECONDS", "86400")
|
||||
return max(1, int(raw))
|
||||
|
||||
|
||||
def hash_token(token: str) -> str:
|
||||
return hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def request_body_hash(text: str) -> str:
|
||||
normalized = json.dumps({"text": text, "attachment_ids": []}, separators=(",", ":"), ensure_ascii=False)
|
||||
return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def idempotency_scope(user_id: str, method: str, path: str, key: str) -> str:
|
||||
return f"{user_id}|{method.upper()}|{path}|{key}"
|
||||
|
||||
|
||||
@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]
|
||||
|
||||
|
||||
def _aware(value: datetime) -> datetime:
|
||||
if value.tzinfo is None:
|
||||
return value.replace(tzinfo=timezone.utc)
|
||||
return value
|
||||
|
||||
|
||||
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)
|
||||
if _aware(row.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)
|
||||
if _aware(row.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,
|
||||
*,
|
||||
idempotency_key: str,
|
||||
request_path: str,
|
||||
) -> Message:
|
||||
scope = idempotency_scope(sender_id, "POST", request_path, idempotency_key)
|
||||
body_hash = request_body_hash(text)
|
||||
|
||||
for _ in range(5):
|
||||
try:
|
||||
with session_scope() as session:
|
||||
existing = session.get(IdempotencyRow, scope, with_for_update=True)
|
||||
if existing is not None:
|
||||
if _aware(existing.expires_at) > utc_now():
|
||||
if existing.request_hash != body_hash:
|
||||
raise AppError(
|
||||
409,
|
||||
"conflict",
|
||||
"Idempotency-Key reused with a different request body",
|
||||
)
|
||||
message = session.get(MessageRow, existing.message_id)
|
||||
if message is None:
|
||||
raise AppError(500, "internal_error", "Idempotent message missing")
|
||||
return _message_from_row(message)
|
||||
session.execute(
|
||||
delete(IdempotencyRow).where(IdempotencyRow.scope_key == scope)
|
||||
)
|
||||
session.flush()
|
||||
|
||||
message = MessageRow(
|
||||
id=uuid.uuid4(),
|
||||
chat_id=UUID(chat_id),
|
||||
sender_id=UUID(sender_id),
|
||||
text=text,
|
||||
created_at=utc_now(),
|
||||
)
|
||||
session.add(message)
|
||||
session.flush()
|
||||
session.add(
|
||||
IdempotencyRow(
|
||||
scope_key=scope,
|
||||
request_hash=body_hash,
|
||||
message_id=message.id,
|
||||
created_at=utc_now(),
|
||||
expires_at=utc_now() + timedelta(seconds=idempotency_ttl_seconds()),
|
||||
)
|
||||
)
|
||||
session.flush()
|
||||
return _message_from_row(message)
|
||||
except IntegrityError:
|
||||
continue
|
||||
|
||||
with session_scope() as session:
|
||||
existing = session.get(IdempotencyRow, scope)
|
||||
if existing is not None and _aware(existing.expires_at) > utc_now():
|
||||
if existing.request_hash != body_hash:
|
||||
raise AppError(
|
||||
409,
|
||||
"conflict",
|
||||
"Idempotency-Key reused with a different request body",
|
||||
)
|
||||
message = session.get(MessageRow, existing.message_id)
|
||||
if message is not None:
|
||||
return _message_from_row(message)
|
||||
raise AppError(503, "unavailable", "Could not complete idempotent write")
|
||||
|
||||
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()
|
||||
@@ -0,0 +1,73 @@
|
||||
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)
|
||||
|
||||
|
||||
class IdempotencyRow(Base):
|
||||
__tablename__ = "idempotency_records"
|
||||
|
||||
scope_key: Mapped[str] = mapped_column(Text, primary_key=True)
|
||||
request_hash: Mapped[str] = mapped_column(Text, nullable=False)
|
||||
message_id: Mapped[uuid.UUID] = mapped_column(Uuid, ForeignKey("messages.id"), nullable=False)
|
||||
created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False)
|
||||
Reference in New Issue
Block a user