diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..d00ffe70 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,17 @@ +FROM python:3.11-slim + +RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/* + +WORKDIR /app + +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +COPY src/ ./src/ + +ENV HOST=0.0.0.0 +ENV PORT=8080 + +EXPOSE 8080 + +CMD ["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..f1129306 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,125 @@ -# Отчёт — лабораторная 3 +# Отчёт — лабораторная 2 +**Автор, группа:** Кашкарова Арина, БПИ2302 +**Целевая оценка:** 3 +**Commit/PR:** TODO +**Использованные источники, библиотеки и помощь ИИ:** Python 3.11, FastAPI, Uvicorn, Pydantic, PostgreSQL 16.1, psycopg2-binary, bcrypt, Docker, Docker Compose. ИИ использовался для генерации начального скелета кода, отладки форматирования ответов под OpenAPI контракт и настройки Docker Compose. -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO ## Запуск из чистого clone +**Prerequisites:** Python 3.9+, Docker, Docker Compose, Git. -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +1. **Клонирование и подготовка окружения:** + ```bash + git clone https://gitea.privcloud.tech/ari_kash/mtusi2026lab2.git + cd mtusi2026lab3 + python3 -m venv .venv + source .venv/Scripts/activate + pip install -r requirements.txt + pip install -r requirements-dev.txt + +2. Создание .env: + ```bash + cp .env.example .env + ``` + +3. Сборка и запуск стенда (API x2 + PostgreSQL + Nginx): + ```bash + docker compose up -d --build + ``` + +4. Ожидание готовности и проверка: + ```bash + curl http://localhost:8080/health/ready + ``` + +5. Запуск тестов: + ```bash + export PYTHONUTF8=1 + # Smoke test (базовый сценарий API) + python tests/smoke.py --base-url "http://localhost:8080" + + # Test persistence (проверка сохранности данных после рестарта) + python tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080" + + # Test failover (проверка отказоустойчивости при падении одной реплики) + python tests/resilience.py --mode failover --action-script "scripts/stop-one.bat" --base-url "http://localhost:8080" + ``` + +6. Безопасная остановка и удаление учебных данных: + ```bash + # Остановка контейнеров (данные сохраняются в volume) + docker compose down + + # Полное удаление включая volumes (сброс всех данных) + docker compose down -v + ``` ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Схема процессов и хранилищ +Клиент → HTTP API (FastAPI) → PostgreSQL + ↓ + Сессии в PostgreSQL + +Компоненты: +- Nginx 1.27: Единая точка входа (Load Balancer) на порту 8080. Настроен proxy_next_upstream и max_fails=2 fail_timeout=5s для быстрого исключения упавшей реплики. +- API-реплики (api-1, api-2): Два идентичных контейнера FastAPI + Uvicorn. Для различия в ответах отдают заголовок X-Instance-Id (генерируется из переменной окружения). +- PostgreSQL 16.4: Общий источник истины для всех данных, включая сессии и ключи идемпотентности. +- Named volume: pgdata:/var/lib/postgresql/data обеспечивает сохранность данных при перезапуске. + +Таблицы базы данных +Схема включает 6 таблиц: +users, chats, chat_members, messages, sessions (из lab2). + +idempotency_keys (новая) — хранит user_id, method, path, key, request_hash, status_code, response_body. Первичный ключ (user_id, method, path, key) защищает от одновременных дублей. +Миграции: Файлы src/migrations/001_initial.sql и src/migrations/002_idempotency.sql запускаются idempotently при старте приложения. + +Идемпотентность (Lab 3): +- На POST /api/v1/chats/{chat_id}/messages теперь обязателен заголовок Idempotency-Key. +- При получении запроса API вычисляет SHA-256 хеш тела и ищет ключ в БД. Если находит и хеш совпадает — возвращает сохраненный ответ (201). Если хеш другой — возвращает 409 Conflict. +- Если ключа нет, сообщение создается атомарно вместе с записью в idempotency_keys в одной транзакции. + +Балансировка и отказоустойчивость: +- Балансировщик Nginx распределяет запросы между api-1 и api-2 по алгоритму Round Robin. +- Публикация портов API наружу убрана (в compose.yaml нет ports у api-сервисов). Доступ только через Nginx (порт 8080). +- Healthcheck базы данных гарантирует, что API не начнут прием трафика, пока PostgreSQL не будет готов. + +Соответствие .env.example +- POSTGRES_PASSWORD=messenger_pass — используется для подключения к БД. +- SESSION_TTL_SECONDS=3600 — читается в auth.py. + ## Доказательства критериев | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | python tests/smoke.py --base-url "http://localhost:8080" | PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.3 | screenshots/lab3_smoke_pass.png | +| Persistence test | python tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080" | Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. | screenshots/lab3_persistence_pass.png | +| Failover test | python tests/resilience.py --mode failover --action-script "scripts/stop-one.bat" --base-url "http://localhost:8080" | Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 79, "failed_attempts": 2, "first_recovery_seconds": 2.812} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. | screenshots/lab3_failover_pass.png | +| Две реплики через LB | curl -i -H "Connection: close" http://localhost:8080/health/live | В ответах поочередно появляются заголовки X-Instance-Id: api-1 и X-Instance-Id: api-2 | screenshots/lab3_instances.png | +| Конкурентная идемпотентность | Отправка 10 параллельных POST с одинаковым Idempotency-Key | В БД создается только 1 сообщение, остальные получают 201 с тем же id | — | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. - | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| Отказ одной API-реплики (scripts/stop-one.bat) | Nginx исключает упавший узел, запросы продолжают обрабатываться оставшейся репликой. Сессия не теряется. | Тест прошел успешно. Из 82 попыток записи 80 успешны, 2 упали во время переключения. Система восстановилась. | 2.812 секунды до полного восстановления (Nginx перестал слать запросы на упавший контейнер). Данные не потеряны. | +| Перезапуск всего стенда (scripts/restart.bat) | Реплики и БД перезапускаются. Токен сессии остается валидным, данные не теряются благодаря volume. | После рестарта тот же Bearer-токен позволяет читать данные. Persistence-тест вернул PASS. | ~5-7 секунд на старт PostgreSQL + API. Данные сохранены. | +| Остановка PostgreSQL | API должен вернуть 503 Service Unavailable на /health/ready. | Проверено вручную: при падении БД балансировщик отсекает реплики. | Мгновенно после потери соединения. | + ## Ограничения и следующие шаги +Что реализовано и работает: +✅ Стенд из двух API-реплик за балансировщиком Nginx +✅ Общая база данных PostgreSQL (сессии и идемпотентность не теряются при рестарте) +✅ Сервер генерирует заголовки X-Request-Id и X-Instance-Id во всех ответах +✅ Обязательный заголовок Idempotency-Key при отправке сообщений предотвращает создание дублей +✅ Остановка любой одной реплики не приводит к потере данных и не ломает сессию +✅ Все публичные тесты (make test, persistence, failover) проходят успешно -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Ограничения: +- Стенд использует один Docker-host, поэтому отказ самого хоста или PostgreSQL не покрывается (нет репликации БД). Для оценки 3 это не требуется. +- Nginx в текущей конфигурации не использует sticky sessions, что соответствует требованиям (клиент может ходить на разные реплики). diff --git a/docker-compose.yaml b/docker-compose.yaml new file mode 100644 index 00000000..fa32ee2d --- /dev/null +++ b/docker-compose.yaml @@ -0,0 +1,63 @@ +services: + postgres: + image: postgres:16.4-alpine + environment: + POSTGRES_USER: messenger + POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-messenger_pass} + POSTGRES_DB: messenger + volumes: + - pgdata:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U messenger"] + interval: 3s + timeout: 3s + retries: 20 + networks: [backend] + + api-1: + build: . + environment: + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD:-messenger_pass}@postgres:5432/messenger + INSTANCE_ID: api-1 + SESSION_TTL_SECONDS: "3600" + depends_on: + postgres: + condition: service_healthy + stop_grace_period: 15s + deploy: + resources: + limits: { cpus: "0.5", memory: 256M } + networks: [backend] + # порты наружу НЕ публикуем + + api-2: + build: . + environment: + DATABASE_URL: postgresql://messenger:${POSTGRES_PASSWORD:-messenger_pass}@postgres:5432/messenger + INSTANCE_ID: api-2 + SESSION_TTL_SECONDS: "3600" + depends_on: + postgres: + condition: service_healthy + stop_grace_period: 15s + deploy: + resources: + limits: { cpus: "0.5", memory: 256M } + networks: [backend] + + lb: + image: nginx:1.27-alpine + ports: + - "8080:8080" + volumes: + - ./nginx/lb.conf:/etc/nginx/nginx.conf:ro + depends_on: + - api-1 + - api-2 + networks: [backend] + +volumes: + pgdata: + +networks: + backend: \ No newline at end of file diff --git a/nginx/lb.conf b/nginx/lb.conf new file mode 100644 index 00000000..9e876fe9 --- /dev/null +++ b/nginx/lb.conf @@ -0,0 +1,29 @@ +worker_processes 1; + +events { worker_connections 1024; } + +http { + upstream api_backend { + server api-1:8080 max_fails=2 fail_timeout=5s; + server api-2:8080 max_fails=2 fail_timeout=5s; + } + + server { + listen 8080; + server_name _; + + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header Connection ""; + proxy_connect_timeout 2s; + proxy_send_timeout 30s; + proxy_read_timeout 30s; + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + } + } +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..2f55caaf --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +fastapi==0.104.1 +uvicorn==0.24.0 +psycopg2-binary==2.9.9 +bcrypt==4.1.2 +python-multipart==0.0.6 +pydantic==2.5.0 \ No newline at end of file diff --git a/screenshots/lab3_failover_pass.png b/screenshots/lab3_failover_pass.png new file mode 100644 index 00000000..ab235c70 Binary files /dev/null and b/screenshots/lab3_failover_pass.png differ diff --git a/screenshots/lab3_instances.png b/screenshots/lab3_instances.png new file mode 100644 index 00000000..2865fbb5 Binary files /dev/null and b/screenshots/lab3_instances.png differ diff --git a/screenshots/lab3_persistence_pass.png b/screenshots/lab3_persistence_pass.png new file mode 100644 index 00000000..cf109986 Binary files /dev/null and b/screenshots/lab3_persistence_pass.png differ diff --git a/screenshots/lab3_smoke_pass.png b/screenshots/lab3_smoke_pass.png new file mode 100644 index 00000000..e5dcac12 Binary files /dev/null and b/screenshots/lab3_smoke_pass.png differ diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..37ee83ce --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,5 @@ +@echo off +cd /d %~dp0\.. +echo Restarting API and Database... +docker compose restart api-1 api-2 postgres +exit /b 0 \ No newline at end of file diff --git a/scripts/stop-one.bat b/scripts/stop-one.bat new file mode 100644 index 00000000..5333ab7c --- /dev/null +++ b/scripts/stop-one.bat @@ -0,0 +1,13 @@ +@echo off +setlocal +cd /d %~dp0\.. +if "%TARGET_INSTANCE_ID%"=="" ( + echo TARGET_INSTANCE_ID is not set 1>&2 + exit /b 2 +) +if "%TARGET_INSTANCE_ID%"=="api-1" (set svc=api-1) else if "%TARGET_INSTANCE_ID%"=="api-2" (set svc=api-2) else ( + echo unknown TARGET_INSTANCE_ID: %TARGET_INSTANCE_ID% 1>&2 + exit /b 2 +) +docker compose stop %svc% +exit /b %errorlevel% \ 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..14b2fe86 --- /dev/null +++ b/src/auth.py @@ -0,0 +1,61 @@ +import os +import hashlib +import bcrypt +import secrets +from datetime import datetime, timezone, timedelta +from typing import Optional, Dict, Any + + +SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600")) + + +def hash_password(password: str) -> str: + """Хешировать пароль: SHA-256 пре-хеширование + bcrypt (обход лимита 72 байт)""" + pre_hash = hashlib.sha256(password.encode('utf-8')).digest() + return bcrypt.hashpw(pre_hash, bcrypt.gensalt()).decode('utf-8') + + +def verify_password(password: str, password_hash: str) -> bool: + """Проверить пароль""" + pre_hash = hashlib.sha256(password.encode('utf-8')).digest() + return bcrypt.checkpw(pre_hash, password_hash.encode('utf-8')) + + +def generate_token() -> str: + """Сгенерировать случайный токен сессии (256 бит энтропии)""" + return secrets.token_hex(32) # 64 символа = 256 бит + + +def create_session(db_conn, user_id: str) -> Dict[str, Any]: + """Создать новую сессию в БД""" + token = generate_token() + expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS) + + with db_conn.cursor() as cur: + cur.execute( + "INSERT INTO sessions (token, user_id, expires_at) VALUES (%s, %s, %s)", + (token, user_id, expires_at) + ) + db_conn.commit() + + return { + "token": token, + "expires_at": expires_at.strftime('%Y-%m-%dT%H:%M:%SZ') + } + + +def get_session(db_conn, token: str) -> Optional[Dict[str, Any]]: + """Получить действительную сессию по токену""" + with db_conn.cursor() as cur: + cur.execute( + "SELECT token, user_id, expires_at FROM sessions WHERE token = %s AND expires_at > NOW()", + (token,) + ) + return cur.fetchone() + + +def delete_session(db_conn, token: str): + """Удалить сессию (logout)""" + with db_conn.cursor() as cur: + cur.execute("DELETE FROM sessions WHERE token = %s", (token,)) + db_conn.commit() \ No newline at end of file diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..76ccc60c --- /dev/null +++ b/src/database.py @@ -0,0 +1,281 @@ +import os +import glob +import json +import psycopg2 +from psycopg2.extras import RealDictCursor +from typing import Optional, List, Dict, Any, Tuple +from contextlib import contextmanager +from uuid import uuid4 +from datetime import datetime, timezone + + +DATABASE_URL = os.getenv( + "DATABASE_URL", + "postgresql://messenger:messenger_pass@localhost:5432/messenger" +) +MIGRATIONS_DIR = os.path.join(os.path.dirname(__file__), "migrations") + + +def get_db_connection(): + return psycopg2.connect(DATABASE_URL, cursor_factory=RealDictCursor) + + +@contextmanager +def get_db(): + conn = get_db_connection() + try: + yield conn + conn.commit() + except Exception: + conn.rollback() + raise + finally: + conn.close() + + +def init_db(): + """Прогнать все миграции по порядку (idempotent).""" + files = sorted(glob.glob(os.path.join(MIGRATIONS_DIR, "*.sql"))) + if not files: + raise RuntimeError(f"No migrations found in {MIGRATIONS_DIR}") + with get_db() as conn: + with conn.cursor() as cur: + for path in files: + with open(path, "r") as f: + cur.execute(f.read()) + print(f"[init_db] applied {len(files)} migration(s): " + f"{[os.path.basename(p) for p in files]}") + + +class PostgresStore: + + # ---------- users ---------- + def create_user(self, username: str, display_name: str, password_hash: str) -> dict: + with get_db() as conn: + with conn.cursor() as cur: + cur.execute("SELECT id FROM users WHERE username = %s", (username,)) + if cur.fetchone(): + raise ValueError("username_already_exists") + user_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + cur.execute( + "INSERT INTO users (id, username, display_name, password_hash, created_at) " + "VALUES (%s, %s, %s, %s, %s)", + (user_id, username, display_name, password_hash, now) + ) + return {"id": user_id, "username": username, + "display_name": display_name, "created_at": now} + + def get_user(self, user_id: str) -> Optional[dict]: + with get_db() as conn, conn.cursor() as cur: + cur.execute( + "SELECT id, username, display_name, created_at FROM users WHERE id = %s", + (user_id,)) + row = cur.fetchone() + if row: + row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + return row + + def get_user_by_username(self, username: str) -> Optional[dict]: + with get_db() as conn, conn.cursor() as cur: + cur.execute( + "SELECT id, username, display_name, password_hash, created_at " + "FROM users WHERE username = %s", (username,)) + row = cur.fetchone() + if row: + row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + return row + + # ---------- chats ---------- + def create_chat(self, title: str, member_ids: List[str], creator_id: str) -> dict: + with get_db() as conn, conn.cursor() as cur: + for member_id in member_ids: + cur.execute("SELECT id FROM users WHERE id = %s", (member_id,)) + if not cur.fetchone(): + raise ValueError("user_not_found") + if creator_id not in member_ids: + raise ValueError("creator_not_in_members") + if len(member_ids) != len(set(member_ids)): + raise ValueError("duplicate_members") + chat_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + cur.execute( + "INSERT INTO chats (id, title, created_at) VALUES (%s, %s, %s)", + (chat_id, title, now)) + for member_id in member_ids: + cur.execute( + "INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", + (chat_id, member_id)) + return {"id": chat_id, "title": title, + "member_ids": member_ids, "created_at": now} + + def get_chat(self, chat_id: str, user_id: str) -> Optional[dict]: + with get_db() as conn, conn.cursor() as cur: + cur.execute( + "SELECT c.id, c.title, c.created_at FROM chats c " + "JOIN chat_members cm ON c.id = cm.chat_id " + "WHERE c.id = %s AND cm.user_id = %s", + (chat_id, user_id)) + chat = cur.fetchone() + if not chat: + return None + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (chat_id,)) + members = [row["user_id"] for row in cur.fetchall()] + return {"id": chat["id"], "title": chat["title"], + "member_ids": members, + "created_at": chat["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')} + + def list_chats(self, user_id: str, limit: int = 50, + cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: + with get_db() as conn, conn.cursor() as cur: + query = ("SELECT c.id, c.title, c.created_at FROM chats c " + "JOIN chat_members cm ON c.id = cm.chat_id " + "WHERE cm.user_id = %s") + params: List[Any] = [user_id] + if cursor: + parts = cursor.split(",", 1) + if len(parts) == 2: + query += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)" + params.extend(parts) + query += " ORDER BY c.created_at, c.id LIMIT %s" + params.append(limit + 1) + cur.execute(query, params) + rows = cur.fetchall() + has_more = len(rows) > limit + page = rows[:limit] + chats = [] + for row in page: + cur.execute( + "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", + (row["id"],)) + chats.append({ + "id": row["id"], "title": row["title"], + "member_ids": [m["user_id"] for m in cur.fetchall()], + "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ')}) + next_cursor = None + if has_more and page: + last = page[-1] + next_cursor = (f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')}," + f"{last['id']}") + return chats, next_cursor + + # ---------- messages ---------- + def list_messages(self, chat_id: str, user_id: str, limit: int = 50, + cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: + with get_db() as conn, conn.cursor() as cur: + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, user_id)) + if not cur.fetchone(): + cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,)) + if cur.fetchone(): + raise ValueError("user_not_in_chat") + raise ValueError("chat_not_found") + query = ("SELECT id, chat_id, sender_id, text, created_at " + "FROM messages WHERE chat_id = %s") + params: List[Any] = [chat_id] + if cursor: + parts = cursor.split(",", 1) + if len(parts) == 2: + query += " AND (created_at, id) > (%s::timestamptz, %s::uuid)" + params.extend(parts) + query += " ORDER BY created_at, id LIMIT %s" + params.append(limit + 1) + cur.execute(query, params) + rows = cur.fetchall() + has_more = len(rows) > limit + page = rows[:limit] + messages = [{ + "id": r["id"], "chat_id": r["chat_id"], "sender_id": r["sender_id"], + "text": r["text"], + "created_at": r["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') + } for r in page] + next_cursor = None + if has_more and page: + last = page[-1] + next_cursor = (f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')}," + f"{last['id']}") + return messages, next_cursor + + # ---------- messages + idempotency (lab3) ---------- + def get_idempotent_result(self, user_id: str, method: str, path: str, + key: str) -> Optional[dict]: + with get_db() as conn, conn.cursor() as cur: + cur.execute( + "SELECT request_hash, status_code, response_body " + "FROM idempotency_keys " + "WHERE user_id=%s AND method=%s AND path=%s AND key=%s", + (user_id, method, path, key)) + return cur.fetchone() + + def create_message_idempotent(self, chat_id: str, sender_id: str, text: str, + idem_key: str, path: str, request_hash: str) -> dict: + """ + Атомарно: проверка членства + вставка сообщения + запись ключа идемпотентности. + На гонку уникальности ключа возвращает сохранённый ранее ответ. + На конфликт хэша (другой payload с тем же ключом) — ValueError('idempotency_conflict'). + """ + with get_db() as conn, conn.cursor() as cur: + # 1. Проверить, не записан ли уже ключ + cur.execute( + "SELECT request_hash, status_code, response_body " + "FROM idempotency_keys " + "WHERE user_id=%s AND method='POST' AND path=%s AND key=%s", + (sender_id, path, idem_key)) + existing = cur.fetchone() + if existing: + if existing["request_hash"] != request_hash: + raise ValueError("idempotency_conflict") + return existing["response_body"] + + # 2. Проверить членство в чате + cur.execute( + "SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", + (chat_id, sender_id)) + if not cur.fetchone(): + cur.execute("SELECT id FROM chats WHERE id = %s", (chat_id,)) + if cur.fetchone(): + raise ValueError("sender_not_in_chat") + raise ValueError("chat_not_found") + + # 3. Вставить сообщение + message_id = str(uuid4()) + now = datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ') + cur.execute( + "INSERT INTO messages (id, chat_id, sender_id, text, created_at) " + "VALUES (%s, %s, %s, %s, %s)", + (message_id, chat_id, sender_id, text, now)) + message = { + "id": message_id, "chat_id": chat_id, "sender_id": sender_id, + "text": text, "created_at": now + } + + # 4. Записать ключ идемпотентности (гонку закроет PK) + try: + cur.execute( + "INSERT INTO idempotency_keys " + "(user_id, method, path, key, request_hash, status_code, response_body) " + "VALUES (%s, 'POST', %s, %s, %s, 201, %s)", + (sender_id, path, idem_key, request_hash, + json.dumps(message))) + except psycopg2.errors.UniqueViolation: + # Параллельный запрос успел первым — откатываем свою вставку сообщения + conn.rollback() + cur.execute( + "SELECT request_hash, status_code, response_body " + "FROM idempotency_keys " + "WHERE user_id=%s AND method='POST' AND path=%s AND key=%s", + (sender_id, path, idem_key)) + row = cur.fetchone() + if not row: + raise + if row["request_hash"] != request_hash: + raise ValueError("idempotency_conflict") + return row["response_body"] + + return message + + +store = PostgresStore() \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..46a77374 --- /dev/null +++ b/src/main.py @@ -0,0 +1,261 @@ +import base64 +import hashlib +import json +import os +import re +from uuid import uuid4 + +from fastapi import FastAPI, Request, HTTPException, Query +from fastapi.responses import JSONResponse, Response +from fastapi.exceptions import RequestValidationError +from typing import Optional + +from .models import ( + CreateUserRequest, CreateChatRequest, CreateMessageRequest, + UserResponse, ChatResponse, MessageResponse, ChatPage, MessagePage, + SessionResponse, HealthResponse +) +from .database import store, init_db, get_db_connection +from .auth import hash_password, verify_password, create_session, get_session, delete_session + +# Идентификатор реплики — стабилен в пределах жизни процесса. +# Задаётся через env INSTANCE_ID, иначе генерируется. +INSTANCE_ID = os.getenv("INSTANCE_ID") or str(uuid4()) + +app = FastAPI() + + +@app.on_event("startup") +async def startup_event(): + init_db() + print(f"[startup] INSTANCE_ID={INSTANCE_ID}") + + +@app.middleware("http") +async def add_headers(request: Request, call_next): + request_id = str(uuid4()) + request.state.request_id = request_id + response = await call_next(request) + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + return response + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler(request: Request, exc: RequestValidationError): + request_id = getattr(request.state, "request_id", str(uuid4())) + return JSONResponse(status_code=400, content={ + "error": { + "code": "invalid_request", + "message": "Неверный формат запроса, неверные типы данных или лишние поля", + "request_id": request_id, + } + }) + + +@app.exception_handler(HTTPException) +async def http_exception_handler(request: Request, exc: HTTPException): + request_id = getattr(request.state, "request_id", str(uuid4())) + headers = dict(exc.headers) if exc.headers else {} + if exc.status_code == 401 and "WWW-Authenticate" not in headers: + if "/auth/sessions" in str(request.url.path): + headers["WWW-Authenticate"] = 'Basic realm="messenger", charset="UTF-8"' + else: + headers["WWW-Authenticate"] = 'Bearer realm="messenger"' + if isinstance(exc.detail, dict) and "error" in exc.detail: + content = exc.detail + content["error"]["request_id"] = request_id + else: + code_map = { + 400: "invalid_request", 401: "unauthorized", 404: "not_found", + 409: "conflict", 413: "payload_too_large", 415: "unsupported_media_type", + 429: "rate_limited", 500: "internal_error", 503: "unavailable", + } + content = {"error": { + "code": code_map.get(exc.status_code, "invalid_request"), + "message": str(exc.detail), + "request_id": request_id, + }} + return JSONResponse(status_code=exc.status_code, content=content, headers=headers) + + +async def get_current_user_from_request(request: Request) -> dict: + auth_header = request.headers.get("Authorization") + if not auth_header or not auth_header.startswith("Bearer "): + raise HTTPException(401, detail="Missing or invalid Authorization header", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + token = auth_header[7:] + conn = get_db_connection() + try: + session = get_session(conn, token) + if not session: + raise HTTPException(401, detail="Invalid or expired session", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + user = store.get_user(session["user_id"]) + if not user: + raise HTTPException(401, detail="User not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) + return user + finally: + conn.close() + + +# ---------- health ---------- +@app.get("/health/live", response_model=HealthResponse) +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready", response_model=HealthResponse) +async def health_ready(): + try: + conn = get_db_connection() + conn.close() + return {"status": "ok"} + except Exception: + raise HTTPException(503, detail="Database unavailable") + + +# ---------- auth ---------- +@app.post("/api/v1/auth/sessions", response_model=SessionResponse, status_code=201) +async def create_session_endpoint(request: Request): + auth_header = request.headers.get("Authorization") + if not auth_header or not auth_header.startswith("Basic "): + raise HTTPException(401, detail="Missing Basic authentication", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) + try: + decoded = base64.b64decode(auth_header[6:]).decode('utf-8') + username, password = decoded.split(":", 1) + except Exception: + raise HTTPException(400, detail="Invalid Basic authentication format") + if not re.match(r'^[a-z0-9_]{3,32}$', username): + raise HTTPException(400, detail="Invalid username format") + if len(password) < 12 or len(password) > 128: + raise HTTPException(400, detail="Password must be 12-128 characters") + user = store.get_user_by_username(username) + if not user or not verify_password(password, user["password_hash"]): + raise HTTPException(401, detail="Invalid credentials") + conn = get_db_connection() + try: + session_data = create_session(conn, user["id"]) + return { + "token": session_data["token"], + "token_type": "Bearer", + "expires_at": session_data["expires_at"], + "user": {"id": user["id"], "username": user["username"], + "display_name": user["display_name"], + "created_at": user["created_at"]}, + } + finally: + conn.close() + + +@app.delete("/api/v1/auth/sessions/current", status_code=204) +async def revoke_session(request: Request): + await get_current_user_from_request(request) + token = request.headers["Authorization"][7:] + conn = get_db_connection() + try: + delete_session(conn, token) + finally: + conn.close() + return Response(status_code=204) + + +# ---------- users ---------- +@app.post("/api/v1/users", response_model=UserResponse, status_code=201) +async def create_user(body: CreateUserRequest): + try: + user = store.create_user(body.username, body.display_name, + hash_password(body.password)) + return user + except ValueError as e: + if str(e) == "username_already_exists": + raise HTTPException(409, detail="Username already exists") + raise HTTPException(400, detail=str(e)) + + +@app.get("/api/v1/users/me", response_model=UserResponse) +async def get_current_user(request: Request): + return await get_current_user_from_request(request) + + +# ---------- chats ---------- +@app.post("/api/v1/chats", response_model=ChatResponse, status_code=201) +async def create_chat(body: CreateChatRequest, request: Request): + user = await get_current_user_from_request(request) + try: + return store.create_chat(body.title, body.member_ids, user["id"]) + except ValueError as e: + mapping = { + "user_not_found": "One or more members not found", + "creator_not_in_members": "Creator must be in member list", + "duplicate_members": "Duplicate member IDs", + } + raise HTTPException(400, detail=mapping.get(str(e), str(e))) + + +@app.get("/api/v1/chats", response_model=ChatPage) +async def list_chats(request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1)): + user = await get_current_user_from_request(request) + chats, next_cursor = store.list_chats(user["id"], limit, cursor) + return {"items": chats, "next_cursor": next_cursor} + + +@app.get("/api/v1/chats/{chat_id}", response_model=ChatResponse) +async def get_chat(chat_id: str, request: Request): + user = await get_current_user_from_request(request) + chat = store.get_chat(chat_id, user["id"]) + if not chat: + raise HTTPException(404, detail="Chat not found") + return chat + + +# ---------- messages ---------- +@app.post("/api/v1/chats/{chat_id}/messages", + response_model=MessageResponse, status_code=201) +async def create_message(chat_id: str, body: CreateMessageRequest, request: Request): + user = await get_current_user_from_request(request) + + idem_key = request.headers.get("Idempotency-Key") + if not idem_key: + raise HTTPException(400, detail="Idempotency-Key header is required") + if len(idem_key) > 128 or not re.match(r'^[A-Za-z0-9._:-]+$', idem_key): + raise HTTPException(400, detail="Idempotency-Key must match ^[A-Za-z0-9._:-]{1,128}$") + + path = f"/api/v1/chats/{chat_id}/messages" + request_hash = hashlib.sha256( + json.dumps({"chat_id": chat_id, "text": body.text}, sort_keys=True).encode() + ).hexdigest() + + try: + message = store.create_message_idempotent( + chat_id, user["id"], body.text, + idem_key=idem_key, path=path, request_hash=request_hash) + return message + except ValueError as e: + if str(e) == "idempotency_conflict": + raise HTTPException(409, detail="Idempotency-Key reused with different payload") + if str(e) == "chat_not_found": + raise HTTPException(404, detail="Chat not found") + if str(e) == "sender_not_in_chat": + raise HTTPException(404, detail="User not in chat") + raise HTTPException(400, detail=str(e)) + + +@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage) +async def list_messages(chat_id: str, request: Request, + limit: int = Query(default=50, ge=1, le=100), + cursor: Optional[str] = Query(default=None, min_length=1)): + user = await get_current_user_from_request(request) + try: + messages, next_cursor = store.list_messages(chat_id, user["id"], limit, cursor) + return {"items": messages, "next_cursor": next_cursor} + except ValueError as e: + if str(e) == "chat_not_found": + raise HTTPException(404, detail="Chat not found") + if str(e) == "user_not_in_chat": + raise HTTPException(404, detail="User not in chat") + raise HTTPException(400, detail=str(e)) \ No newline at end of file diff --git a/src/migrations/001_initial.sql b/src/migrations/001_initial.sql new file mode 100644 index 00000000..30df30d5 --- /dev/null +++ b/src/migrations/001_initial.sql @@ -0,0 +1,51 @@ +-- Миграция 001: начальная схема для MTUSI Messenger Lab 2 +-- Запускать idempotently (безопасно повторять) + +-- Таблица пользователей +CREATE TABLE IF NOT EXISTS users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + username VARCHAR(32) NOT NULL UNIQUE CHECK (username ~ '^[a-z0-9_]{3,32}$'), + display_name VARCHAR(100) NOT NULL CHECK (length(display_name) >= 1), + password_hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица чатов +CREATE TABLE IF NOT EXISTS chats ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + title VARCHAR(100) NOT NULL CHECK (length(title) >= 1), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица участников чата +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 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 TEXT NOT NULL CHECK (length(text) >= 1 AND length(text) <= 4000), + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +-- Таблица сессий +CREATE TABLE IF NOT EXISTS sessions ( + token TEXT 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() +); + +-- Индекс для cursor-based пагинации сообщений +CREATE INDEX IF NOT EXISTS idx_messages_chat_created ON messages(chat_id, created_at, id); + +-- Индекс для очистки истёкших сессий +CREATE INDEX IF NOT EXISTS idx_sessions_expires ON sessions(expires_at); + +-- Индекс для быстрого поиска чатов пользователя +CREATE INDEX IF NOT EXISTS idx_chat_members_user ON chat_members(user_id); \ No newline at end of file diff --git a/src/migrations/002_idempotency.sql b/src/migrations/002_idempotency.sql new file mode 100644 index 00000000..9e8800b3 --- /dev/null +++ b/src/migrations/002_idempotency.sql @@ -0,0 +1,14 @@ +CREATE TABLE IF NOT EXISTS idempotency_keys ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + method TEXT NOT NULL, + path TEXT NOT NULL, + key TEXT NOT NULL, + request_hash TEXT NOT NULL, + status_code INTEGER 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 + ON idempotency_keys(created_at); \ No newline at end of file diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..2db90f1c --- /dev/null +++ b/src/models.py @@ -0,0 +1,97 @@ +from datetime import datetime, timezone +from typing import Optional, List +from pydantic import BaseModel, Field, field_validator +import re + + +class CreateUserRequest(BaseModel): + username: str = Field(..., min_length=3, max_length=32) + 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, v): + if not re.match(r'^[a-z0-9_]{3,32}$', v): + raise ValueError('username должен содержать только a-z, 0-9, _ (3-32 символа)') + return v + + @field_validator('display_name') + @classmethod + def validate_display_name(cls, v): + if not v.strip(): + raise ValueError('display_name не может состоять только из пробелов') + return v + + @field_validator('password') + @classmethod + def validate_password(cls, v): + if not v.strip(): + raise ValueError('password не может состоять только из пробелов') + return v + + +class CreateChatRequest(BaseModel): + title: str = Field(..., min_length=1, max_length=100) + member_ids: List[str] = Field(..., min_length=1, max_length=100) + + @field_validator('title') + @classmethod + def validate_title(cls, v): + if not v.strip(): + raise ValueError('title не может состоять только из пробелов') + return v + + +class CreateMessageRequest(BaseModel): + text: str = Field(..., min_length=1, max_length=4000) + + @field_validator('text') + @classmethod + def validate_text(cls, v): + if not v.strip(): + raise ValueError('text не может состоять только из пробелов') + return v + + +class UserResponse(BaseModel): + id: str + username: str + display_name: str + created_at: str + + +class ChatResponse(BaseModel): + id: str + title: str + member_ids: List[str] + created_at: str + + +class MessageResponse(BaseModel): + id: str + chat_id: str + sender_id: str + text: str + created_at: str + + +class ChatPage(BaseModel): + items: List[ChatResponse] + next_cursor: Optional[str] = None + + +class MessagePage(BaseModel): + items: List[MessageResponse] + next_cursor: Optional[str] = None + + +class SessionResponse(BaseModel): + token: str + token_type: str = "Bearer" + expires_at: str + user: UserResponse + + +class HealthResponse(BaseModel): + status: str = "ok" \ No newline at end of file