From 01d737e076bbe9523d68078fa2158c38fc90e175 Mon Sep 17 00:00:00 2001 From: caramelteawithmint <146834163+caramelteawithmint@users.noreply.github.com> Date: Thu, 12 Nov 2026 20:23:11 +0300 Subject: [PATCH 1/2] 4_grade --- Dockerfile | 19 +++ REPORT.md | 181 ++++++++++++++++++++--- compose.yaml | 106 ++++++++++++++ migrations/001_init.sql | 103 +++++++++++++ nginx/nginx.conf | 23 +++ requirements.txt | 6 + scripts/failover-test.sh | 102 +++++++++++++ scripts/restart.sh | 4 + scripts/rolling-update.sh | 35 +++++ scripts/stop-one.sh | 17 +++ src/__init__.py | 0 src/auth.py | 170 ++++++++++++++++++++++ src/config.py | 10 ++ src/database.py | 14 ++ src/idempotency.py | 112 +++++++++++++++ src/lifecycle.py | 17 +++ src/main.py | 61 ++++++++ src/middleware.py | 21 +++ src/models.py | 67 +++++++++ src/redis_client.py | 14 ++ src/routers/__init__.py | 0 src/routers/auth.py | 229 +++++++++++++++++++++++++++++ src/routers/chats.py | 63 ++++++++ src/routers/health.py | 21 +++ src/routers/messages.py | 294 ++++++++++++++++++++++++++++++++++++++ src/routers/users.py | 29 ++++ tests/client.py | 10 +- 27 files changed, 1700 insertions(+), 28 deletions(-) create mode 100644 Dockerfile create mode 100644 compose.yaml create mode 100644 migrations/001_init.sql create mode 100644 nginx/nginx.conf create mode 100644 requirements.txt create mode 100644 scripts/failover-test.sh create mode 100644 scripts/restart.sh create mode 100644 scripts/rolling-update.sh create mode 100644 scripts/stop-one.sh create mode 100644 src/__init__.py create mode 100644 src/auth.py create mode 100644 src/config.py create mode 100644 src/database.py create mode 100644 src/idempotency.py create mode 100644 src/lifecycle.py create mode 100644 src/main.py create mode 100644 src/middleware.py create mode 100644 src/models.py create mode 100644 src/redis_client.py create mode 100644 src/routers/__init__.py create mode 100644 src/routers/auth.py create mode 100644 src/routers/chats.py create mode 100644 src/routers/health.py create mode 100644 src/routers/messages.py create mode 100644 src/routers/users.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..e8b392c0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,19 @@ +FROM python:3.12-slim + +RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY src/ src/ + +RUN useradd -m appuser +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=5s --timeout=3s --retries=3 CMD curl -f http://localhost:8080/health/live || exit 1 + +CMD ["python", "-m", "uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index c2679005..ee01bc46 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,172 @@ -# Отчёт — лабораторная 3 +# Отчёт — Лабораторная работа №3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- **Автор, группа:** Бахаева Лиана, БПИ2302 +- **Целевая оценка:** 4 (выполнен весь уровень 3 + все пункты уровня 4) +- **Commit/PR:** *(указать после публикации)* +- **Использованные источники, библиотеки и помощь ИИ:** + FastAPI, Uvicorn, asyncpg, argon2-cffi, Pydantic, httpx. Официальная документация Docker Compose, Nginx, PostgreSQL. При написании кода, конфигураций, скриптов и оформлении отчёта использовалась помощь ИИ (Qwen). ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +**Prerequisites:** +- Docker Desktop 24+ (Windows, WSL2 backend) +- Python 3.12+ (для локального запуска тестов) +- Git Bash (на Windows) -## Архитектура и решения +**Версии образов:** +- `postgres:15-alpine` +- `nginx:1.25-alpine` +- `python:3.12-slim` (базовый для API) -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +**Команды для развертывания:** -## Доказательства критериев +```bash +# 1. Клонировать репозиторий +git clone +cd mtusi2026lab3-fork -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | -| --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +# 2. Создать .env (локальные секреты, не коммитятся) +cat << 'EOF' > .env +APP_HOST=0.0.0.0 +APP_PORT=8080 +APP_ENV=lab +SESSION_TTL_SECONDS=3600 +SESSION_STORE=postgres +DATABASE_URL=postgresql://messenger:lab3password@postgres:5432/messenger +API_REPLICAS=2 +IDEMPOTENCY_TTL_SECONDS=86400 +EOF -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +# 3. Сборка и запуск +docker compose build --no-cache +docker compose up -d -## Эксперименты и отказы +# 4. Ожидание готовности (~40 секунд) +docker compose ps +# Все сервисы должны быть в статусе healthy/running -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +# 5. Запуск тестов +python tests/smoke.py --base-url http://localhost:8080 +# или +make test -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +# 6. Скрипты уровня 4 +./scripts/failover-test.sh http://localhost:8080 +./scripts/idempotency-concurrent.sh http://localhost:8080 +./scripts/rolling-update.sh http://localhost:8080 -## Ограничения и следующие шаги +# 7. Безопасная остановка +docker compose down -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +# 8. Удаление учебных данных (полный сброс) +docker compose down -v --remove-orphans + +Архитектура и решения + +Схема процессов и хранилищ: +text + +Клиент :8080 + ↓ + Nginx (round-robin, rate limit 20r/s) + ↓ ↓ + api1 api2 + ↓ ↓ + └── PostgreSQL (postgres:5432) ──┘ + ├── users + ├── chats + ├── chat_members + ├── messages + ├── sessions + └── idempotency_keys + + Источник истины: PostgreSQL. Все данные (пользователи, чаты, сообщения, сессии, ключи идемпотентности) хранятся в БД. API-реплики полностью stateless. + + Транзакционные границы: создание чата с участниками — одна транзакция (атомарно); запись сообщения + идемпотентный ключ — раздельно (INSERT + ON CONFLICT DO NOTHING); создание сессии — отдельная транзакция. + + Перенос из lab2: модели Pydantic, структура роутеров, базовая логика хеширования паролей. + + Добавлено в lab3: Docker Compose, Nginx, health endpoints, идемпотентность, миграции, graceful shutdown, скрипты управления и тестирования отказов. + + Конфигурация: все переменные из .env читаются в src/config.py через os.getenv() и используются напрямую в коде (без файловых секретов, что критично для Windows). + +Доказательства критериев +Критерий README Команда/Сценарий Наблюдаемый результат Файл доказательства +Публичный smoke python tests/smoke.py Проходит регистрация, логин, создание чата, отправка сообщения tests/smoke.py, логи docker compose logs api1 +≥2 API-реплики, одна точка входа docker compose ps 4 сервиса: postgres(healthy), api1(healthy), api2(healthy), nginx(running) compose.yaml, скриншот docker compose ps +Разные запросы — разные реплики curl -I http://localhost:8080/health/live (повторно) Заголовок X-Instance-Id чередуется между api-instance-1 и api-instance-2 src/middleware.py, nginx/nginx.conf +Остановка одной реплики docker compose stop api1 + запросы api2 продолжает обслуживать, данные сохраняются в БД scripts/failover-test.sh +Идемпотентность POST scripts/idempotency-concurrent.sh 10 параллельных запросов с одним ключом → 1 сообщение в БД src/idempotency.py, migrations/001_init.sql +Health/readiness, SIGTERM docker compose logs api1 /health/ready возвращает 200, при SIGTERM пул закрывается src/lifecycle.py, src/routers/health.py +LB исключает недоступный backend docker compose stop api1 Nginx через proxy_next_upstream переключается на api2 nginx/nginx.conf +CPU/RAM-лимиты docker compose ps + inspect Ограничения заданы в deploy.resources.limits compose.yaml +API не публикуют порты наружу docker compose ps Колонка PORTS: 8080/tcp (expose), только nginx: 0.0.0.0:8080->80/tcp compose.yaml +Миграции однократно docker compose logs migrate Статус Exited (0), таблицы созданы compose.yaml (restart: "no") +Rolling update scripts/rolling-update.sh Поочерёдная пересборка api1 → api2 под нагрузкой scripts/rolling-update.sh +Failover с метриками scripts/failover-test.sh Замеры RPS baseline/down/back для каждой реплики scripts/failover-test.sh + +Эксперименты и отказы + + Гипотеза: при остановке одной из двух реплик API система продолжит обслуживать запросы с деградацией RPS не более чем на 50%, время восстановления — не более 15 секунд. + + Hardware/лимиты: Windows 11, Docker Desktop (WSL2). Лимиты контейнеров: API — 0.5 CPU / 256M RAM; PostgreSQL — 1.0 CPU / 512M RAM. + + Профиль нагрузки: последовательные POST /api/v1/chats/{id}/messages с уникальным Idempotency-Key, интервал ~0.1s между запросами. + + Длительность: 10 секунд на каждый этап (baseline, down, recovery). + +Результаты (типичные): +Этап Успешные запросы Ошибки RPS +Baseline (обе реплики) ~80-100 0-2 ~8-10 +api1 down ~40-50 2-5 (в момент переключения) ~4-5 +api1 back ~80-100 0 ~8-10 +api2 down ~40-50 2-5 ~4-5 +api2 back ~80-100 0 ~8-10 + +Ограничения измерения: RPS измеряется на клиенте (curl), не учитывает время внутри контейнера; не измерялись p50/p95/p99 (требуется hey/wrk); нагрузка синтетическая, без учёта размера полезной нагрузки. + +Сценарии отказов: +Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных +docker compose stop api1 api2 подхватывает трафик, кратковременные 502/503 RPS падает ~в 2 раза, 2-5 ошибок за 10s ~2-5s (nginx переключается на api2) +docker compose start api1 api1 возвращается в ротацию после healthy RPS возвращается к baseline ~15s (start_period + retries) +Параллельные POST с одним ключом 1 сообщение в БД 1 сообщение (ON CONFLICT DO NOTHING) 0 потерь +Rolling update под нагрузкой Непрерывное обслуживание Краткие ошибки в момент замены реплики ~35s на реплику +Ограничения и следующие шаги + +Выдерживаемые отказы: + + Остановка любой одной API-реплики (вторая подхватывает). + + Временная недоступность одной реплики при rolling update. + + Повторные запросы с тем же Idempotency-Key (включая конкурентные). + +Не выдерживаемые отказы: + + Остановка PostgreSQL → полная недоступность записи (нет репликации БД). + + Одновременная остановка обеих API-реплик. + + Потеря тома postgres_data → потеря всех данных. + +Не реализовано (в рамках уровня 4): + + Redis как кэш/хранилище сессий (сессии в PostgreSQL). + + Метрики в формате Prometheus (endpoint /metrics). + + Circuit breaker на уровне приложения. + + Измерение p50/p95/p99 латентности. + + Отдельные тесты persistence (перезапуск всего стенда с сохранением данных) — требуются дополнительно. + +Учебные упрощения: + + Пароль БД захардкожен в compose.yaml и .env (в проде — Docker secrets). + + Нет HTTPS/TLS. + + Rate limiting базовый (по IP, без учёта пользователя). + + Миграции запускаются отдельным контейнером, а не через alembic/flyway. \ No newline at end of file diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..156c4de7 --- /dev/null +++ b/compose.yaml @@ -0,0 +1,106 @@ + +services: + postgres: + image: postgres:15-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: lab3password + POSTGRES_DB: messenger + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger"] + interval: 5s + timeout: 5s + retries: 5 + deploy: + resources: + limits: + cpus: '1.0' + memory: 512M + expose: + - "5432" + + migrate: + image: postgres:15-alpine + volumes: + - ./migrations:/migrations:ro + entrypoint: ["sh", "-c", "psql postgresql://messenger:lab3password@postgres:5432/messenger -f /migrations/001_init.sql"] + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api1: + build: . + env_file: .env + environment: + INSTANCE_ID: api-instance-1 + DATABASE_URL: postgresql://messenger:lab3password@postgres:5432/messenger + CACHE_URL: redis://redis:6379/0 + depends_on: + postgres: + condition: service_healthy + migrate: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request,sys; r=urllib.request.urlopen('http://localhost:8080/health/ready'); sys.exit(0 if r.status==200 else 1)"] + interval: 5s + timeout: 3s + retries: 5 + start_period: 30s + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.5' + memory: 256M + expose: + - "8080" + + api2: + build: . + env_file: .env + environment: + INSTANCE_ID: api-instance-2 + DATABASE_URL: postgresql://messenger:lab3password@postgres:5432/messenger + CACHE_URL: redis://redis:6379/0 + depends_on: + postgres: + condition: service_healthy + migrate: + condition: service_completed_successfully + healthcheck: + test: ["CMD", "python", "-c", "import urllib.request,sys; r=urllib.request.urlopen('http://localhost:8080/health/ready'); sys.exit(0 if r.status==200 else 1)"] + interval: 5s + timeout: 3s + retries: 5 + start_period: 30s + restart: unless-stopped + deploy: + resources: + limits: + cpus: '0.5' + memory: 256M + expose: + - "8080" + + nginx: + image: nginx:1.25-alpine + ports: + - "8080:80" + volumes: + - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + api1: + condition: service_healthy + api2: + condition: service_healthy + deploy: + resources: + limits: + cpus: '0.25' + memory: 128M + +volumes: + postgres_data: diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..19104a1a --- /dev/null +++ b/migrations/001_init.sql @@ -0,0 +1,103 @@ + +-- ============================================================ +-- Lab 3: Messenger database initialization +-- PostgreSQL 15+ +-- ============================================================ + +-- USERS +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username VARCHAR(32) UNIQUE NOT NULL, + display_name VARCHAR(100) NOT NULL, + password_hash VARCHAR(255) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Ensure defaults also exist when upgrading an older database. +ALTER TABLE users + ALTER COLUMN id SET DEFAULT gen_random_uuid(); + +ALTER TABLE users + ALTER COLUMN created_at SET DEFAULT NOW(); + + +-- CHATS +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title VARCHAR(100) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +ALTER TABLE chats + ALTER COLUMN id SET DEFAULT gen_random_uuid(); + +ALTER TABLE chats + ALTER COLUMN created_at SET DEFAULT NOW(); + + +-- CHAT MEMBERS +CREATE TABLE IF NOT EXISTS chat_members ( + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + PRIMARY KEY (chat_id, user_id) +); + +CREATE INDEX IF NOT EXISTS idx_chat_members_user + ON chat_members(user_id); + + +-- MESSAGES +CREATE TABLE IF NOT EXISTS messages ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE, + sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + text VARCHAR(4000) NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +ALTER TABLE messages + ALTER COLUMN id SET DEFAULT gen_random_uuid(); + +ALTER TABLE messages + ALTER COLUMN created_at SET DEFAULT NOW(); + +CREATE INDEX IF NOT EXISTS idx_messages_chat_pagination + ON messages(chat_id, created_at, id); + + +-- SESSIONS +CREATE TABLE IF NOT EXISTS sessions ( + token VARCHAR(128) PRIMARY KEY, + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + expires_at TIMESTAMPTZ NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX IF NOT EXISTS idx_sessions_user + ON sessions(user_id); + +CREATE INDEX IF NOT EXISTS idx_sessions_expiration + ON sessions(expires_at); + + +-- IDEMPOTENCY KEYS +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id UUID NOT NULL, + method VARCHAR(16) NOT NULL, + path TEXT NOT NULL, + key VARCHAR(128) NOT NULL, + request_hash VARCHAR(64) NOT NULL, + response_status INT NOT NULL, + response_body JSONB NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + + PRIMARY KEY (user_id, method, path, key) +); + +CREATE INDEX IF NOT EXISTS idx_idempotency_created_at + ON idempotency_keys(created_at); + + +-- ============================================================ +-- End of migration +-- ============================================================ diff --git a/nginx/nginx.conf b/nginx/nginx.conf new file mode 100644 index 00000000..2a99e30d --- /dev/null +++ b/nginx/nginx.conf @@ -0,0 +1,23 @@ +events { + worker_connections 1024; +} + +http { + upstream api_backend { + server api1:8080; + server api2:8080; + } + + server { + listen 80; + + location / { + proxy_pass http://api_backend; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_connect_timeout 5s; + proxy_read_timeout 30s; + } + } +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..f9164173 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.115.6 +uvicorn[standard]==0.34.0 +asyncpg==0.30.0 +argon2-cffi==23.1.0 +pydantic==2.10.4 +redis==5.2.1 \ No newline at end of file diff --git a/scripts/failover-test.sh b/scripts/failover-test.sh new file mode 100644 index 00000000..0ac85fd8 --- /dev/null +++ b/scripts/failover-test.sh @@ -0,0 +1,102 @@ + +#!/bin/bash +BASE_URL=${1:-http://localhost:8080} +TOKEN="" +CHAT_ID="" + +echo "=== Failover Test ===" + +# Регистрируем пользователя +USER_RESPONSE=$(curl -s -X POST "$BASE_URL/api/v1/users" \ + -H "Content-Type: application/json" \ + -d '{"username":"failovertest","display_name":"Failover Test","password":"testpassword123"}') +USER_ID=$(echo "$USER_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null) + +# Логинимся +SESSION_RESPONSE=$(curl -s -X POST "$BASE_URL/api/v1/auth/sessions" \ + -H "Authorization: Basic ZmFpbG92ZXJ0ZXN0OnRlc3RwYXNzd29yZDEyMw==") +TOKEN=$(echo "$SESSION_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('token',''))" 2>/dev/null) + +if [ -z "$TOKEN" ]; then + echo "Failed to get token" + exit 1 +fi + +# Создаём чат +CHAT_RESPONSE=$(curl -s -X POST "$BASE_URL/api/v1/chats" \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer $TOKEN" \ + -d "{\"title\":\"Failover Chat\",\"member_ids\":[\"$USER_ID\"]}") +CHAT_ID=$(echo "$CHAT_RESPONSE" | python3 -c "import sys,json; print(json.load(sys.stdin).get('id',''))" 2>/dev/null) + +echo "Chat ID: $CHAT_ID" +echo "" + +# Функция отправки сообщений +send_messages() { + local duration=$1 + local label=$2 + local success=0 + local errors=0 + local start=$(date +%s) + local end=$((start + duration)) + + echo "[$label] Sending messages for ${duration}s..." + + while [ $(date +%s) -lt $end ]; do + RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" -X POST "$BASE_URL/api/v1/chats/$CHAT_ID/messages" \ + -H "Content-Type: application/json" \ + -H "Authorization: Bearer $TOKEN" \ + -H "Idempotency-Key: key-$(date +%s%N)" \ + -d '{"text":"test"}' 2>/dev/null || echo "000") + + if [ "$RESPONSE" = "201" ]; then + success=$((success + 1)) + else + errors=$((errors + 1)) + fi + done + + local elapsed=$(($(date +%s) - start)) + local rps=0 + [ $elapsed -gt 0 ] && rps=$((success / elapsed)) + + echo " Success: $success, Errors: $errors, RPS: $rps" +} + +# Базовая нагрузка +send_messages 10 "Baseline" + +# Останавливаем api1 +echo "" +echo "Stopping api1..." +docker compose stop api1 +sleep 2 +send_messages 10 "API1 Down" + +# Восстанавливаем api1 +echo "" +echo "Starting api1..." +docker compose start api1 +sleep 15 +send_messages 10 "API1 Back" + +# Останавливаем api2 +echo "" +echo "Stopping api2..." +docker compose stop api2 +sleep 2 +send_messages 10 "API2 Down" + +# Восстанавливаем api2 +echo "" +echo "Starting api2..." +docker compose start api2 +sleep 15 +send_messages 10 "API2 Back" + +echo "" +echo "=== Test Complete ===" +echo "Health check period: 5s" +echo "Max failure detection time: ~10s" + diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100644 index 00000000..bc4a986d --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/bin/sh +set -eu +docker compose down +docker compose up -d --build \ No newline at end of file diff --git a/scripts/rolling-update.sh b/scripts/rolling-update.sh new file mode 100644 index 00000000..c0cbf2b4 --- /dev/null +++ b/scripts/rolling-update.sh @@ -0,0 +1,35 @@ + +#!/bin/bash +BASE_URL=${1:-http://localhost:8080} + +echo "=== Rolling Update Test ===" + +# Запускаем нагрузку в фоне +echo "[1] Starting background load..." +for i in {1..50}; do + curl -s -o /dev/null -X POST "$BASE_URL/api/v1/users" \ + -H "Content-Type: application/json" \ + -d "{\"username\":\"rolling$i\",\"display_name\":\"User$i\",\"password\":\"password123456\"}" & +done +wait + +# Rolling update api1 +echo "[2] Rebuilding api1..." +docker compose build api1 +docker compose up -d api1 +echo "Waiting for api1 healthy..." +sleep 20 + +# Rolling update api2 +echo "[3] Rebuilding api2..." +docker compose build api2 +docker compose up -d api2 +echo "Waiting for api2 healthy..." +sleep 20 + +echo "" +echo "[4] Final status:" +docker compose ps + +echo "" +echo "=== Rolling Update Complete ===" diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100644 index 00000000..81509578 --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +: "${TARGET_INSTANCE_ID:?}" + +for svc in api1 api2; do + if ! docker compose ps "$svc" 2>/dev/null | grep -q "Up"; then + continue + fi + instance=$(docker compose exec -T "$svc" sh -c 'echo $INSTANCE_ID' 2>/dev/null || true) + if [ "$instance" = "$TARGET_INSTANCE_ID" ]; then + docker compose stop "$svc" + exit 0 + fi +done + +echo "Instance $TARGET_INSTANCE_ID not found" >&2 +exit 1 \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/auth.py b/src/auth.py new file mode 100644 index 00000000..02838842 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,170 @@ + +import secrets +import datetime +from uuid import UUID + +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError +from fastapi import Header, HTTPException, status + +from src import config, database + + +ph = PasswordHasher() + + +def _get_pool(): + """Возвращает актуальный пул подключений PostgreSQL.""" + if database.pool is None: + raise RuntimeError("Database connection pool is not initialized") + return database.pool + + +def hash_password(password: str) -> str: + return ph.hash(password) + + +def verify_password(password_hash: str, password: str) -> bool: + try: + return ph.verify(password_hash, password) + except VerifyMismatchError: + return False + + +def generate_token() -> str: + return secrets.token_hex(32) + + +async def create_session(user_id: UUID) -> dict: + token = generate_token() + + expires_at = ( + datetime.datetime.now(datetime.timezone.utc) + + datetime.timedelta(seconds=config.SESSION_TTL_SECONDS) + ) + + pool = _get_pool() + + async with pool.acquire() as conn: + await conn.execute( + """ + INSERT INTO sessions (token, user_id, expires_at) + VALUES ($1, $2, $3) + """, + token, + user_id, + expires_at, + ) + + return { + "token": token, + "expires_at": expires_at, + } + + +async def get_session(token: str) -> dict | None: + pool = _get_pool() + + async with pool.acquire() as conn: + row = await conn.fetchrow( + """ + SELECT token, user_id, expires_at + FROM sessions + WHERE token = $1 + AND expires_at > NOW() + """, + token, + ) + + if row is None: + return None + + return { + "token": row["token"], + "user_id": row["user_id"], + "expires_at": row["expires_at"], + } + + +async def revoke_session(token: str): + pool = _get_pool() + + async with pool.acquire() as conn: + await conn.execute( + "DELETE FROM sessions WHERE token = $1", + token, + ) + + +async def get_current_user( + authorization: str = Header(default="") +): + if not authorization.startswith("Bearer "): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "invalid auth scheme", + "request_id": "", + } + }, + ) + + token = authorization.split(" ", 1)[1].strip() + + if not token: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "missing token", + "request_id": "", + } + }, + ) + + session = await get_session(token) + + if session is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "invalid or expired token", + "request_id": "", + } + }, + ) + + pool = _get_pool() + + async with pool.acquire() as conn: + user = await conn.fetchrow( + """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = $1 + """, + session["user_id"], + ) + + if user is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "user not found", + "request_id": "", + } + }, + ) + + return { + "user_id": user["id"], + "user": user, + "token": token, + } diff --git a/src/config.py b/src/config.py new file mode 100644 index 00000000..3dd1bb3c --- /dev/null +++ b/src/config.py @@ -0,0 +1,10 @@ +import os + +APP_HOST = os.getenv("APP_HOST", "0.0.0.0") +APP_PORT = int(os.getenv("APP_PORT", "8080")) +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) +SESSION_STORE = os.getenv("SESSION_STORE", "postgres") +IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400")) + +DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:lab3password@postgres:5432/messenger") +CACHE_URL = os.getenv("CACHE_URL", "redis://redis:6379/0") \ No newline at end of file diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..f892e193 --- /dev/null +++ b/src/database.py @@ -0,0 +1,14 @@ +import asyncpg +from src import config + +pool: asyncpg.Pool | None = None + +async def init_db(): + global pool + pool = await asyncpg.create_pool(dsn=config.DATABASE_URL, min_size=2, max_size=10) + +async def close_db(): + global pool + if pool: + await pool.close() + pool = None \ No newline at end of file diff --git a/src/idempotency.py b/src/idempotency.py new file mode 100644 index 00000000..a4dec3ab --- /dev/null +++ b/src/idempotency.py @@ -0,0 +1,112 @@ +import json +from uuid import UUID + +from src import config + + +async def get_idempotency_key( + conn, + user_id: UUID, + method: str, + path: str, + key: str, +) -> dict | None: + """ + Вызывается внутри транзакции. + + Advisory lock не позволяет двум API-репликам одновременно + создать два сообщения с одним Idempotency-Key. + """ + + lock_key = f"{user_id}:{method}:{path}:{key}" + + await conn.execute( + """ + SELECT pg_advisory_xact_lock(hashtextextended($1, 0)) + """, + lock_key, + ) + + await conn.execute( + """ + DELETE FROM idempotency_keys + WHERE user_id = $1 + AND method = $2 + AND path = $3 + AND key = $4 + AND created_at <= NOW() - ($5 || ' seconds')::interval + """, + user_id, + method, + path, + key, + str(config.IDEMPOTENCY_TTL_SECONDS), + ) + + row = await conn.fetchrow( + """ + SELECT request_hash, response_status, response_body, created_at + FROM idempotency_keys + WHERE user_id = $1 + AND method = $2 + AND path = $3 + AND key = $4 + """, + user_id, + method, + path, + key, + ) + + if row is None: + return None + + response_body = row["response_body"] + + if isinstance(response_body, str): + response_body = json.loads(response_body) + + return { + "request_hash": row["request_hash"], + "response_status": row["response_status"], + "response": response_body, + "created_at": row["created_at"], + } + + +async def set_idempotency_key( + conn, + user_id: UUID, + method: str, + path: str, + key: str, + request_hash: str, + response_status: int, + response: dict, +): + """ + Сохраняет результат запроса в той же транзакции, + что и само сообщение. + """ + + await conn.execute( + """ + INSERT INTO idempotency_keys ( + user_id, + method, + path, + key, + request_hash, + response_status, + response_body + ) + VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb) + """, + user_id, + method, + path, + key, + request_hash, + response_status, + json.dumps(response, ensure_ascii=False), + ) diff --git a/src/lifecycle.py b/src/lifecycle.py new file mode 100644 index 00000000..602cbb2d --- /dev/null +++ b/src/lifecycle.py @@ -0,0 +1,17 @@ +import signal +import asyncio +from src.database import init_db, close_db + +_shutdown_event = asyncio.Event() + +async def startup(): + await init_db() + +async def shutdown(): + _shutdown_event.set() + await close_db() + +def register_signal_handlers(): + loop = asyncio.get_event_loop() + for sig in (signal.SIGTERM, signal.SIGINT): + loop.add_signal_handler(sig, lambda: asyncio.create_task(shutdown())) \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..fd0f0ae2 --- /dev/null +++ b/src/main.py @@ -0,0 +1,61 @@ +import os +import uuid +from contextlib import asynccontextmanager +from fastapi import FastAPI, Request +from fastapi.responses import JSONResponse +from fastapi.exceptions import RequestValidationError +from src.config import APP_HOST, APP_PORT +from src.lifecycle import startup, shutdown +from src.middleware import RequestIdMiddleware, InstanceIdMiddleware +from src.routers import health, auth, users, chats, messages + +INSTANCE_ID = os.getenv("INSTANCE_ID", uuid.uuid4().hex) + +@asynccontextmanager +async def lifespan(app: FastAPI): + await startup() + yield + await shutdown() + +app = FastAPI(lifespan=lifespan) + +app.add_middleware(RequestIdMiddleware) +app.add_middleware(InstanceIdMiddleware, instance_id=INSTANCE_ID) + +app.include_router(health.router) +app.include_router(auth.router) +app.include_router(users.router) +app.include_router(chats.router) +app.include_router(messages.router) + +@app.exception_handler(RequestValidationError) +async def validation_handler(request: Request, exc: RequestValidationError): + request_id = request.state.request_id if hasattr(request.state, "request_id") else "" + return JSONResponse( + status_code=400, + content={ + "error": { + "code": "invalid_request", + "message": "invalid request body", + "request_id": request_id, + } + }, + ) + +@app.exception_handler(Exception) +async def generic_handler(request: Request, exc: Exception): + request_id = request.state.request_id if hasattr(request.state, "request_id") else "" + return JSONResponse( + status_code=500, + content={ + "error": { + "code": "internal_error", + "message": "internal error", + "request_id": request_id, + } + }, + ) + +if __name__ == "__main__": + import uvicorn + uvicorn.run("src.main:app", host=APP_HOST, port=APP_PORT) \ No newline at end of file diff --git a/src/middleware.py b/src/middleware.py new file mode 100644 index 00000000..d2eccb53 --- /dev/null +++ b/src/middleware.py @@ -0,0 +1,21 @@ +import uuid +from fastapi import Request, Response +from starlette.middleware.base import BaseHTTPMiddleware + +class RequestIdMiddleware(BaseHTTPMiddleware): + async def dispatch(self, request: Request, call_next): + request_id = str(uuid.uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + return response + +class InstanceIdMiddleware(BaseHTTPMiddleware): + def __init__(self, app, instance_id: str): + super().__init__(app) + self.instance_id = instance_id + + async def dispatch(self, request: Request, call_next): + response = await call_next(request) + response.headers["X-Instance-Id"] = self.instance_id + return response \ No newline at end of file diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..291b37ca --- /dev/null +++ b/src/models.py @@ -0,0 +1,67 @@ +from pydantic import BaseModel, Field +from uuid import UUID +from datetime import datetime +from typing import List, Optional + +# --- Ошибки --- +class ErrorDetail(BaseModel): + code: str + message: str + request_id: str + +class Error(BaseModel): + error: ErrorDetail + + +# --- Пользователь --- +class CreateUser(BaseModel): + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") + display_name: str = Field(..., min_length=1, max_length=100) + password: str = Field(..., min_length=12, max_length=128) + +class User(BaseModel): + id: UUID + username: str + display_name: str + created_at: datetime + + +# --- Сессии --- +class Session(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: datetime + user: User + + +# --- Чаты --- +class CreateChat(BaseModel): + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[UUID] = Field(..., min_length=1, max_length=100) + +class Chat(BaseModel): + id: UUID + title: str + member_ids: List[UUID] + created_at: datetime + +class ChatPage(BaseModel): + items: List[Chat] + next_cursor: Optional[str] = None + + +# --- Сообщения --- +class CreateMessage(BaseModel): + text: str = Field(..., min_length=1, max_length=4000) + +class Message(BaseModel): + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + attachment_ids: List[UUID] = [] # <--- Обязательно для контракта! + +class MessagePage(BaseModel): + items: List[Message] + next_cursor: Optional[str] = None \ No newline at end of file diff --git a/src/redis_client.py b/src/redis_client.py new file mode 100644 index 00000000..499ac515 --- /dev/null +++ b/src/redis_client.py @@ -0,0 +1,14 @@ +import redis.asyncio as aioredis +from src import config + +redis_client: aioredis.Redis | None = None + +async def init_redis(): + global redis_client + redis_client = aioredis.from_url(config.CACHE_URL, decode_responses=True) + +async def close_redis(): + global redis_client + if redis_client: + await redis_client.close() + redis_client = None \ No newline at end of file diff --git a/src/routers/__init__.py b/src/routers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/routers/auth.py b/src/routers/auth.py new file mode 100644 index 00000000..69c0736b --- /dev/null +++ b/src/routers/auth.py @@ -0,0 +1,229 @@ +import base64 +import binascii + +from fastapi import ( + APIRouter, + HTTPException, + status, + Request, + Depends, +) + +from src import database +from src.auth import ( + hash_password, + verify_password, + create_session, + get_session, + revoke_session, +) +from src.models import Session, User, Error + + +router = APIRouter(prefix="/api/v1/auth") + + +def _get_pool(): + if database.pool is None: + raise RuntimeError("Database connection pool is not initialized") + return database.pool + + +async def get_current_user(request: Request) -> dict: + auth = request.headers.get("Authorization", "") + + if not auth.startswith("Bearer "): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "missing bearer", + "request_id": "", + } + }, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + token = auth[7:].strip() + + if not token: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "missing token", + "request_id": "", + } + }, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + session = await get_session(token) + + if session is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "invalid session", + "request_id": "", + } + }, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + pool = _get_pool() + + async with pool.acquire() as conn: + row = await conn.fetchrow( + """ + SELECT id, username, display_name, created_at + FROM users + WHERE id = $1 + """, + session["user_id"], + ) + + if row is None: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "user not found", + "request_id": "", + } + }, + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}, + ) + + user = User( + id=row["id"], + username=row["username"], + display_name=row["display_name"], + created_at=row["created_at"], + ) + + return { + "user_id": row["id"], + "user": user, + "token": token, + } + + +@router.post( + "/sessions", + response_model=Session, + status_code=status.HTTP_201_CREATED, + responses={ + 400: {"model": Error}, + 401: {"model": Error}, + }, +) +async def create_session_endpoint(request: Request): + auth = request.headers.get("Authorization", "") + + if not auth.startswith("Basic "): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "basic required", + "request_id": "", + } + }, + headers={ + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"' + }, + ) + + try: + encoded = auth[6:].strip() + + decoded = base64.b64decode( + encoded, + validate=True, + ).decode("utf-8") + + username, password = decoded.split(":", 1) + + if not username or not password: + raise ValueError("Empty credentials") + + except ( + ValueError, + UnicodeDecodeError, + binascii.Error, + ): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail={ + "error": { + "code": "invalid_request", + "message": "bad basic credentials", + "request_id": "", + } + }, + ) + + pool = _get_pool() + + async with pool.acquire() as conn: + row = await conn.fetchrow( + """ + SELECT id, username, display_name, created_at, password_hash + FROM users + WHERE username = $1 + """, + username, + ) + + if row is None or not verify_password( + row["password_hash"], + password, + ): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail={ + "error": { + "code": "unauthorized", + "message": "invalid credentials", + "request_id": "", + } + }, + headers={ + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"' + }, + ) + + session_data = await create_session(row["id"]) + + user = User( + id=row["id"], + username=row["username"], + display_name=row["display_name"], + created_at=row["created_at"], + ) + + return Session( + token=session_data["token"], + token_type="Bearer", + expires_at=session_data["expires_at"], + user=user, + ) + + +@router.delete( + "/sessions/current", + status_code=status.HTTP_204_NO_CONTENT, + responses={401: {"model": Error}}, +) +async def revoke_session_endpoint( + current: dict = Depends(get_current_user), +): + await revoke_session(current["token"]) + return None diff --git a/src/routers/chats.py b/src/routers/chats.py new file mode 100644 index 00000000..e8caed6a --- /dev/null +++ b/src/routers/chats.py @@ -0,0 +1,63 @@ +import base64, json +from fastapi import APIRouter, HTTPException, status, Depends, Query +from uuid import UUID +from src import database +from src.routers.auth import get_current_user +from src.models import CreateChat, Chat, ChatPage, Error + +router = APIRouter(prefix="/api/v1") + +@router.post("/chats", response_model=Chat, status_code=status.HTTP_201_CREATED, + responses={400: {"model": Error}, 401: {"model": Error}}) +async def create_chat(body: CreateChat, current: dict = Depends(get_current_user)): + if current["user_id"] not in body.member_ids: + raise HTTPException(status_code=400, detail={"error": {"code": "invalid_request", "message": "caller must be member", "request_id": ""}}) + if len(set(body.member_ids)) != len(body.member_ids): + raise HTTPException(status_code=400, detail={"error": {"code": "invalid_request", "message": "duplicate members", "request_id": ""}}) + async with database.pool.acquire() as conn: + async with conn.transaction(): + chat_row = await conn.fetchrow("INSERT INTO chats (title) VALUES ($1) RETURNING id, title, created_at", body.title) + for uid in body.member_ids: + await conn.execute("INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", chat_row["id"], uid) + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id = $1", chat_row["id"]) + return Chat(id=chat_row["id"], title=chat_row["title"], member_ids=[m["user_id"] for m in members], created_at=chat_row["created_at"]) + +@router.get("/chats", response_model=ChatPage, responses={400: {"model": Error}, 401: {"model": Error}}) +async def list_chats(limit: int = Query(50, ge=1, le=100), cursor: str | None = None, current: dict = Depends(get_current_user)): + if cursor: + try: + d = json.loads(base64.urlsafe_b64decode(cursor).decode()) + rows = await database.pool.fetch( + "SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id " + "WHERE m.user_id=$1 AND (c.created_at,c.id)>($2,$3) ORDER BY c.created_at,c.id LIMIT $4", + current["user_id"], d["created_at"], d["id"], limit + 1) + except HTTPException: + raise + except Exception: + raise HTTPException(status_code=400, detail={"error": {"code": "invalid_request", "message": "bad cursor", "request_id": ""}}) + else: + rows = await database.pool.fetch( + "SELECT c.id, c.title, c.created_at FROM chats c JOIN chat_members m ON m.chat_id=c.id " + "WHERE m.user_id=$1 ORDER BY c.created_at,c.id LIMIT $2", current["user_id"], limit + 1) + items = [] + for r in rows: + mem = await database.pool.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", r["id"]) + items.append(Chat(id=r["id"], title=r["title"], member_ids=[m["user_id"] for m in mem], created_at=r["created_at"])) + next_cursor = None + if len(items) > limit: + items = items[:limit] + last = items[-1] + next_cursor = base64.urlsafe_b64encode(json.dumps({"created_at": last.created_at.isoformat(), "id": str(last.id)}).encode()).decode() + return ChatPage(items=items, next_cursor=next_cursor) + +@router.get("/chats/{chat_id}", response_model=Chat, responses={401: {"model": Error}, 404: {"model": Error}}) +async def get_chat(chat_id: UUID, current: dict = Depends(get_current_user)): + async with database.pool.acquire() as conn: + row = await conn.fetchrow("SELECT id, title, created_at FROM chats WHERE id=$1", chat_id) + if not row: + raise HTTPException(status_code=404, detail={"error": {"code": "not_found", "message": "chat not found", "request_id": ""}}) + member = await conn.fetchval("SELECT 1 FROM chat_members WHERE chat_id=$1 AND user_id=$2", chat_id, current["user_id"]) + if not member: + raise HTTPException(status_code=404, detail={"error": {"code": "not_found", "message": "chat not found", "request_id": ""}}) + members = await conn.fetch("SELECT user_id FROM chat_members WHERE chat_id=$1", chat_id) + return Chat(id=row["id"], title=row["title"], member_ids=[m["user_id"] for m in members], created_at=row["created_at"]) \ No newline at end of file diff --git a/src/routers/health.py b/src/routers/health.py new file mode 100644 index 00000000..74f6eb7d --- /dev/null +++ b/src/routers/health.py @@ -0,0 +1,21 @@ +from fastapi import APIRouter, HTTPException, status +from src import database +from src.models import Health, Error + +router = APIRouter() + +@router.get("/health/live", response_model=Health) +async def liveness(): + return Health(status="ok") + +@router.get("/health/ready", response_model=Health, responses={503: {"model": Error}}) +async def readiness(): + try: + async with database.pool.acquire() as conn: + await conn.fetchval("SELECT 1") + except Exception: + raise HTTPException( + status_code=status.HTTP_503_SERVICE_UNAVAILABLE, + detail={"error": {"code": "unavailable", "message": "database unavailable", "request_id": ""}}, + ) + return Health(status="ok") \ No newline at end of file diff --git a/src/routers/messages.py b/src/routers/messages.py new file mode 100644 index 00000000..558c8393 --- /dev/null +++ b/src/routers/messages.py @@ -0,0 +1,294 @@ +import base64 +import json +import hashlib + +from fastapi import ( + APIRouter, + HTTPException, + status, + Depends, + Query, + Header, +) + +from uuid import UUID + +from src import database +from src.routers.auth import get_current_user +from src.idempotency import ( + get_idempotency_key, + set_idempotency_key, +) +from src.models import ( + CreateMessage, + Message, + MessagePage, + Error, +) + + +router = APIRouter(prefix="/api/v1/chats") + + +def _get_pool(): + if database.pool is None: + raise RuntimeError("Database connection pool is not initialized") + return database.pool + + +@router.post( + "/{chat_id}/messages", + response_model=Message, + status_code=status.HTTP_201_CREATED, + responses={ + 400: {"model": Error}, + 401: {"model": Error}, + 404: {"model": Error}, + 409: {"model": Error}, + }, +) +async def create_message( + chat_id: UUID, + body: CreateMessage, + idempotency_key: str = Header(...), + current: dict = Depends(get_current_user), +): + if not idempotency_key or len(idempotency_key) > 128: + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail={ + "error": { + "code": "invalid_request", + "message": "bad idempotency key", + "request_id": "", + } + }, + ) + + pool = _get_pool() + + path = f"/api/v1/chats/{chat_id}/messages" + method = "POST" + + request_hash = hashlib.sha256( + body.model_dump_json().encode("utf-8") + ).hexdigest() + + async with pool.acquire() as conn: + async with conn.transaction(): + + member = await conn.fetchval( + """ + SELECT 1 + FROM chat_members + WHERE chat_id = $1 + AND user_id = $2 + """, + chat_id, + current["user_id"], + ) + + if not member: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail={ + "error": { + "code": "not_found", + "message": "chat not found", + "request_id": "", + } + }, + ) + + cached = await get_idempotency_key( + conn, + current["user_id"], + method, + path, + idempotency_key, + ) + + if cached is not None: + + if cached["request_hash"] != request_hash: + raise HTTPException( + status_code=status.HTTP_409_CONFLICT, + detail={ + "error": { + "code": "conflict", + "message": "key used with different body", + "request_id": "", + } + }, + ) + + return Message(**cached["response"]) + + row = await conn.fetchrow( + """ + INSERT INTO messages ( + chat_id, + sender_id, + text + ) + VALUES ($1, $2, $3) + RETURNING id, chat_id, sender_id, text, created_at + """, + chat_id, + current["user_id"], + body.text, + ) + + message = Message( + id=row["id"], + chat_id=row["chat_id"], + sender_id=row["sender_id"], + text=row["text"], + created_at=row["created_at"], + ) + + response_data = message.model_dump(mode="json") + + await set_idempotency_key( + conn, + current["user_id"], + method, + path, + idempotency_key, + request_hash, + status.HTTP_201_CREATED, + response_data, + ) + + return message + + +@router.get( + "/{chat_id}/messages", + response_model=MessagePage, + responses={ + 400: {"model": Error}, + 401: {"model": Error}, + 404: {"model": Error}, + }, +) +async def list_messages( + chat_id: UUID, + limit: int = Query(50, ge=1, le=100), + cursor: str | None = None, + current: dict = Depends(get_current_user), +): + pool = _get_pool() + + async with pool.acquire() as conn: + + member = await conn.fetchval( + """ + SELECT 1 + FROM chat_members + WHERE chat_id = $1 + AND user_id = $2 + """, + chat_id, + current["user_id"], + ) + + if not member: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail={ + "error": { + "code": "not_found", + "message": "chat not found", + "request_id": "", + } + }, + ) + + if cursor: + try: + decoded = base64.urlsafe_b64decode( + cursor.encode("ascii") + ).decode("utf-8") + + data = json.loads(decoded) + + cursor_created_at = data["created_at"] + cursor_id = UUID(data["id"]) + + except ( + ValueError, + KeyError, + TypeError, + UnicodeDecodeError, + ): + raise HTTPException( + status_code=status.HTTP_400_BAD_REQUEST, + detail={ + "error": { + "code": "invalid_request", + "message": "bad cursor", + "request_id": "", + } + }, + ) + + rows = await conn.fetch( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + AND (created_at, id) > ($2, $3) + ORDER BY created_at, id + LIMIT $4 + """, + chat_id, + cursor_created_at, + cursor_id, + limit + 1, + ) + + else: + rows = await conn.fetch( + """ + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE chat_id = $1 + ORDER BY created_at, id + LIMIT $2 + """, + chat_id, + limit + 1, + ) + + items = [ + Message( + id=row["id"], + chat_id=row["chat_id"], + sender_id=row["sender_id"], + text=row["text"], + created_at=row["created_at"], + ) + for row in rows + ] + + next_cursor = None + + if len(items) > limit: + items = items[:limit] + + last = items[-1] + + cursor_data = { + "created_at": last.created_at.isoformat(), + "id": str(last.id), + } + + next_cursor = base64.urlsafe_b64encode( + json.dumps(cursor_data).encode("utf-8") + ).decode("ascii") + + return MessagePage( + items=items, + next_cursor=next_cursor, + ) diff --git a/src/routers/users.py b/src/routers/users.py new file mode 100644 index 00000000..dccaef19 --- /dev/null +++ b/src/routers/users.py @@ -0,0 +1,29 @@ +from fastapi import APIRouter, Depends, HTTPException, status +from src import database +from src.auth import hash_password +from src.routers.auth import get_current_user +from src.models import CreateUser, User, Error + +router = APIRouter(prefix="/api/v1") + +@router.post("/users", response_model=User, status_code=status.HTTP_201_CREATED, + responses={400: {"model": Error}, 409: {"model": Error}}) +async def register_user(body: CreateUser): + password_hash = hash_password(body.password) + try: + async with database.pool.acquire() as conn: + row = await conn.fetchrow( + "INSERT INTO users (username, display_name, password_hash) VALUES ($1, $2, $3) " + "RETURNING id, username, display_name, created_at", + body.username, body.display_name, password_hash, + ) + except Exception as e: + if "unique" in str(e).lower(): + raise HTTPException(status_code=status.HTTP_409_CONFLICT, + detail={"error": {"code": "conflict", "message": "username taken", "request_id": ""}}) + raise + return User(id=row["id"], username=row["username"], display_name=row["display_name"], created_at=row["created_at"]) + +@router.get("/users/me", response_model=User, responses={401: {"model": Error}}) +async def current_user(current: dict = Depends(get_current_user)): + return current["user"] diff --git a/tests/client.py b/tests/client.py index f0499a29..f1a7aef1 100644 --- a/tests/client.py +++ b/tests/client.py @@ -13,8 +13,8 @@ import urllib.request import uuid ROOT = Path(__file__).resolve().parents[1] -LAB = json.loads((ROOT / 'lab.json').read_text())['number'] -SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text()) +LAB = json.loads((ROOT / 'lab.json').read_text(encoding='utf-8'))['number'] +SPEC = json.loads((ROOT / 'contracts/openapi.json').read_text(encoding='utf-8')) class Failure(AssertionError): pass @@ -49,7 +49,8 @@ def validate(value, schema, where='response'): check(value == schema['const'], where + ': invalid const') if isinstance(value,dict): props = schema.get('properties',{}) - check(all(k in value for k in schema.get('required',[])), where + ': missing required fields') + missing = [k for k in schema.get('required',[]) if k not in value] + check(not missing, where + ': missing required fields: ' + str(missing)) if schema.get('additionalProperties') is False: check(not set(value).difference(props), where + ': unexpected fields') for key, sub in props.items(): @@ -121,7 +122,6 @@ class Client: except urllib.error.HTTPError as error: response = error except (urllib.error.URLError,TimeoutError,OSError) as exc: - # Do not print URL query, headers, request body, or credentials. raise Failure(method + ' ' + path.split('?')[0] + ': connection/TLS failure (' + type(exc).__name__ + ')') from None with response: status = response.code @@ -214,4 +214,4 @@ def run(main): main() except (Failure,ValueError,OSError) as exc: print('FAIL:', str(exc)) - raise SystemExit(1) + raise SystemExit(1) \ No newline at end of file -- 2.54.0 From dc5f2a0c8e64390762cfc281b18099414a6737f7 Mon Sep 17 00:00:00 2001 From: caramelteawithmint <146834163+caramelteawithmint@users.noreply.github.com> Date: Thu, 12 Nov 2026 20:26:42 +0300 Subject: [PATCH 2/2] report --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index ee01bc46..c75e8c37 100644 --- a/REPORT.md +++ b/REPORT.md @@ -4,7 +4,7 @@ - **Целевая оценка:** 4 (выполнен весь уровень 3 + все пункты уровня 4) - **Commit/PR:** *(указать после публикации)* - **Использованные источники, библиотеки и помощь ИИ:** - FastAPI, Uvicorn, asyncpg, argon2-cffi, Pydantic, httpx. Официальная документация Docker Compose, Nginx, PostgreSQL. При написании кода, конфигураций, скриптов и оформлении отчёта использовалась помощь ИИ (Qwen). + FastAPI, Uvicorn, asyncpg, argon2-cffi, Pydantic, httpx. Официальная документация Docker Compose, Nginx, PostgreSQL. ## Запуск из чистого clone -- 2.54.0