Релизованный минимум на 3, подготовка к написанию REPORT.md

This commit is contained in:
2026-11-17 17:05:08 +03:00
parent f880e234db
commit 38c463cd8b
8 changed files with 424 additions and 411 deletions
-3
View File
@@ -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
+53 -25
View File
@@ -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:
pgdata:
networks:
backend:
+29
View File
@@ -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;
}
}
}
+3 -13
View File
@@ -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
echo Restarting API and Database...
docker compose restart api-1 api-2 postgres
exit /b 0
+13
View File
@@ -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%
+215 -229
View File
@@ -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()
+97 -141
View File
@@ -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))
raise HTTPException(404, detail="User not in chat")
raise HTTPException(400, detail=str(e))
+14
View File
@@ -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);