Релизованный минимум на 3, подготовка к написанию REPORT.md
This commit is contained in:
@@ -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
@@ -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:
|
||||
@@ -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
@@ -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
|
||||
@@ -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
@@ -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
@@ -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))
|
||||
@@ -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);
|
||||
Reference in New Issue
Block a user