diff --git a/Dockerfile b/Dockerfile index 51c0d3ed..d00ffe70 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,15 +1,12 @@ FROM python:3.11-slim -# Устанавливаем curl для healthcheck 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 diff --git a/docker-compose.yaml b/docker-compose.yaml index 1f4b53a5..fa32ee2d 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -1,35 +1,63 @@ services: - api: - build: . - ports: - - "8080:8080" + postgres: + image: postgres:16.4-alpine environment: - - DATABASE_URL=postgresql://messenger:messenger_pass@postgres:5432/messenger - - SESSION_TTL_SECONDS=3600 + 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 - healthcheck: - test: ["CMD", "curl", "-f", "http://localhost:8080/health/ready"] - interval: 5s - timeout: 3s - retries: 5 - restart: unless-stopped + stop_grace_period: 15s + deploy: + resources: + limits: { cpus: "0.5", memory: 256M } + networks: [backend] + # порты наружу НЕ публикуем - postgres: - image: postgres:16.1 + api-2: + build: . environment: - - POSTGRES_DB=messenger - - POSTGRES_USER=messenger - - POSTGRES_PASSWORD=messenger_pass + 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: - - postgres_data:/var/lib/postgresql/data - healthcheck: - test: ["CMD-SHELL", "pg_isready -U messenger"] - interval: 5s - timeout: 3s - retries: 5 - restart: unless-stopped + - ./nginx/lb.conf:/etc/nginx/nginx.conf:ro + depends_on: + - api-1 + - api-2 + networks: [backend] volumes: - postgres_data: \ No newline at end of file + 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/scripts/restart.bat b/scripts/restart.bat index 9a57e077..37ee83ce 100644 --- a/scripts/restart.bat +++ b/scripts/restart.bat @@ -1,15 +1,5 @@ @echo off cd /d %~dp0\.. -docker compose restart api postgres - -set /a count=0 -:check_loop -timeout /t 2 /nobreak >nul -curl -s -f http://localhost:8080/health/ready >nul 2>&1 -if %errorlevel% equ 0 exit /b 0 - -set /a count+=1 -if %count% lss 15 goto check_loop - -echo API failed to become ready -exit /b 1 \ No newline at end of file +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/database.py b/src/database.py index 134ab938..76ccc60c 100644 --- a/src/database.py +++ b/src/database.py @@ -1,4 +1,6 @@ import os +import glob +import json import psycopg2 from psycopg2.extras import RealDictCursor from typing import Optional, List, Dict, Any, Tuple @@ -7,17 +9,19 @@ from uuid import uuid4 from datetime import datetime, timezone -DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://messenger:messenger_pass@localhost:5432/messenger") +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(): - """Создать подключение к PostgreSQL""" return psycopg2.connect(DATABASE_URL, cursor_factory=RealDictCursor) @contextmanager def get_db(): - """Контекстный менеджер для работы с БД""" conn = get_db_connection() try: yield conn @@ -30,266 +34,248 @@ def get_db(): def init_db(): - """Инициализировать БД (запустить миграции idempotently)""" - migration_path = os.path.join(os.path.dirname(__file__), "migrations", "001_initial.sql") - with open(migration_path, "r") as f: - migration_sql = f.read() - + """Прогнать все миграции по порядку (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: - cur.execute(migration_sql) + 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: - """Store layer для PostgreSQL — заменяет InMemoryStore из Lab 1""" + # ---------- users ---------- def create_user(self, username: str, display_name: str, password_hash: str) -> dict: with get_db() as conn: with conn.cursor() as cur: - # Проверяем уникальность username 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 - } + 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: - with 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: - # Преобразуем datetime в строку ISO8601 - row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') - return row + 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: - with 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: - # Преобразуем datetime в строку ISO8601 - row["created_at"] = row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') - return row + 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: - with 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") - - # Проверяем уникальность member_ids - 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') - - # Атомарно: создаём чат и всех участников в одной транзакции + 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 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 - } + "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: - with 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 - - # Получаем список участников + 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", - (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') - } + (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 - def list_chats(self, user_id: str, limit: int = 50, cursor: Optional[str] = None) -> Tuple[List[dict], Optional[str]]: - with get_db() as conn: - with 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 = [user_id] - - if cursor: - cursor_parts = cursor.split(",", 1) - if len(cursor_parts) == 2: - cursor_time, cursor_id = cursor_parts - query += " AND (c.created_at, c.id) > (%s::timestamptz, %s::uuid)" - params.extend([cursor_time, cursor_id]) - - query += " ORDER BY c.created_at, c.id LIMIT %s" - params.append(limit + 1) # Берём на 1 больше для определения has_more - - cur.execute(query, params) - rows = cur.fetchall() - - has_more = len(rows) > limit - page_rows = rows[:limit] - - chats = [] - for row in page_rows: - cur.execute( - "SELECT user_id FROM chat_members WHERE chat_id = %s ORDER BY user_id", - (row["id"],) - ) - members = [m["user_id"] for m in cur.fetchall()] - chats.append({ - "id": row["id"], - "title": row["title"], - "member_ids": members, - "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') - }) - - next_cursor = None - if has_more and chats: - last = page_rows[-1] - next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{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 - def create_message(self, chat_id: str, sender_id: str, text: str) -> dict: - with get_db() as conn: - with conn.cursor() as cur: - # Проверяем, что чат существует и отправитель является участником - 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") - - 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) - ) - - return { - "id": message_id, - "chat_id": chat_id, - "sender_id": sender_id, - "text": text, - "created_at": now - } + # ---------- 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 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: - with conn.cursor() as cur: - # Проверяем, что пользователь является участником чата + 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( - "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 = [chat_id] - - if cursor: - cursor_parts = cursor.split(",", 1) - if len(cursor_parts) == 2: - cursor_time, cursor_id = cursor_parts - query += " AND (created_at, id) > (%s::timestamptz, %s::uuid)" - params.extend([cursor_time, cursor_id]) - - 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 = rows[:limit] - - messages = [{ - "id": row["id"], - "chat_id": row["chat_id"], - "sender_id": row["sender_id"], - "text": row["text"], - "created_at": row["created_at"].strftime('%Y-%m-%dT%H:%M:%SZ') - } for row in page_rows] - - next_cursor = None - if has_more and messages: - last = page_rows[-1] - next_cursor = f"{last['created_at'].strftime('%Y-%m-%dT%H:%M:%SZ')},{last['id']}" - - return messages, next_cursor + "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 index 1d5bdd25..46a77374 100644 --- a/src/main.py +++ b/src/main.py @@ -1,9 +1,15 @@ 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 uuid import uuid4 + from .models import ( CreateUserRequest, CreateChatRequest, CreateMessageRequest, UserResponse, ChatResponse, MessageResponse, ChatPage, MessagePage, @@ -12,53 +18,50 @@ from .models import ( 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}") -# Middleware для генерации X-Request-Id @app.middleware("http") -async def add_request_id(request: Request, call_next): +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 -# Обработчик ошибок валидации Pydantic (422 → 400) @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): request_id = getattr(request.state, "request_id", str(uuid4())) - content = { + return JSONResponse(status_code=400, content={ "error": { "code": "invalid_request", "message": "Неверный формат запроса, неверные типы данных или лишние поля", - "request_id": request_id + "request_id": request_id, } - } - return JSONResponse(status_code=400, content=content) + }) -# Глобальный обработчик HTTP ошибок @app.exception_handler(HTTPException) async def http_exception_handler(request: Request, exc: HTTPException): request_id = getattr(request.state, "request_id", str(uuid4())) - - # Копируем headers из HTTPException, если они есть headers = dict(exc.headers) if exc.headers else {} - - # Если нет WWW-Authenticate, добавляем по умолчанию для 401 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 @@ -66,55 +69,38 @@ async def http_exception_handler(request: Request, exc: HTTPException): 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" + 429: "rate_limited", 500: "internal_error", 503: "unavailable", } - code = code_map.get(exc.status_code, "invalid_request") - content = { - "error": { - "code": code, - "message": str(exc.detail), - "request_id": request_id - } - } - + 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) -# Вспомогательная функция для получения текущего пользователя из Bearer токена 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( - status_code=401, - detail="Missing or invalid Authorization header", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - - token = auth_header[7:] # Убираем "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( - status_code=401, - detail="Invalid or expired session", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - + 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( - status_code=401, - detail="User not found", - headers={"WWW-Authenticate": 'Bearer realm="messenger"'} - ) - + raise HTTPException(401, detail="User not found", + headers={"WWW-Authenticate": 'Bearer realm="messenger"'}) return user finally: conn.close() -# --- Health endpoints --- + +# ---------- health ---------- @app.get("/health/live", response_model=HealthResponse) async def health_live(): return {"status": "ok"} @@ -127,62 +113,38 @@ async def health_ready(): conn.close() return {"status": "ok"} except Exception: - raise HTTPException(status_code=503, detail="Database unavailable") + raise HTTPException(503, detail="Database unavailable") -# --- Auth endpoints --- +# ---------- auth ---------- @app.post("/api/v1/auth/sessions", response_model=SessionResponse, status_code=201) async def create_session_endpoint(request: Request): - # Проверяем Basic auth auth_header = request.headers.get("Authorization") if not auth_header or not auth_header.startswith("Basic "): - raise HTTPException( - status_code=401, - detail="Missing Basic authentication", - headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'} - ) - + raise HTTPException(401, detail="Missing Basic authentication", + headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}) try: - # Декодируем base64(username:password) decoded = base64.b64decode(auth_header[6:]).decode('utf-8') - # Пароль может содержать двоеточие, поэтому split только по первому username, password = decoded.split(":", 1) except Exception: - raise HTTPException(status_code=400, detail="Invalid Basic authentication format") - - # Валидация username (ASCII [a-z0-9_]{3,32}) - import re + raise HTTPException(400, detail="Invalid Basic authentication format") if not re.match(r'^[a-z0-9_]{3,32}$', username): - raise HTTPException(status_code=400, detail="Invalid username format") - - # Валидация пароля (12-128 code points) + raise HTTPException(400, detail="Invalid username format") if len(password) < 12 or len(password) > 128: - raise HTTPException(status_code=400, detail="Password must be 12-128 characters") - - # Ищем пользователя + raise HTTPException(400, detail="Password must be 12-128 characters") user = store.get_user_by_username(username) - if not user: - raise HTTPException(status_code=401, detail="Invalid credentials") - - # Проверяем пароль - if not verify_password(password, user["password_hash"]): - raise HTTPException(status_code=401, detail="Invalid credentials") - - # Создаём сессию + 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"] - } + "user": {"id": user["id"], "username": user["username"], + "display_name": user["display_name"], + "created_at": user["created_at"]}, } finally: conn.close() @@ -190,67 +152,53 @@ async def create_session_endpoint(request: Request): @app.delete("/api/v1/auth/sessions/current", status_code=204) async def revoke_session(request: Request): - user = await get_current_user_from_request(request) - - auth_header = request.headers.get("Authorization") - token = auth_header[7:] # Убираем "Bearer " - + 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 endpoints --- +# ---------- users ---------- @app.post("/api/v1/users", response_model=UserResponse, status_code=201) -async def create_user(request_body: CreateUserRequest): +async def create_user(body: CreateUserRequest): try: - password_hash = hash_password(request_body.password) - user = store.create_user( - request_body.username, - request_body.display_name, - password_hash - ) + 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(status_code=409, detail="Username already exists") - raise HTTPException(status_code=400, detail=str(e)) + 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): - user = await get_current_user_from_request(request) - return user + return await get_current_user_from_request(request) -# --- Chats endpoints --- +# ---------- chats ---------- @app.post("/api/v1/chats", response_model=ChatResponse, status_code=201) -async def create_chat(request_body: CreateChatRequest, request: Request): +async def create_chat(body: CreateChatRequest, request: Request): user = await get_current_user_from_request(request) - try: - chat = store.create_chat(request_body.title, request_body.member_ids, user["id"]) - return chat + return store.create_chat(body.title, body.member_ids, user["id"]) except ValueError as e: - if str(e) == "user_not_found": - raise HTTPException(status_code=400, detail="One or more members not found") - if str(e) == "creator_not_in_members": - raise HTTPException(status_code=400, detail="Creator must be in member list") - if str(e) == "duplicate_members": - raise HTTPException(status_code=400, detail="Duplicate member IDs") - raise HTTPException(status_code=400, detail=str(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) -): +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} @@ -261,45 +209,53 @@ 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(status_code=404, detail="Chat not found") + raise HTTPException(404, detail="Chat not found") return chat -# --- Messages endpoints --- -@app.post("/api/v1/chats/{chat_id}/messages", response_model=MessageResponse, status_code=201) -async def create_message( - chat_id: str, - request_body: CreateMessageRequest, - request: Request -): +# ---------- 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(chat_id, user["id"], request_body.text) + 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(status_code=404, detail="Chat not found") + raise HTTPException(404, detail="Chat not found") if str(e) == "sender_not_in_chat": - raise HTTPException(status_code=404, detail="User not in chat") - raise HTTPException(status_code=400, detail=str(e)) + 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) -): +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(status_code=404, detail="Chat not found") + raise HTTPException(404, detail="Chat not found") if str(e) == "user_not_in_chat": - raise HTTPException(status_code=404, detail="User not in chat") - raise HTTPException(status_code=400, detail=str(e)) \ No newline at end of file + 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/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