forked from mtusi2026/mtusi2026lab2
Реализация ЛР 2 на 3
This commit is contained in:
+26
@@ -0,0 +1,26 @@
|
||||
FROM python:3.12.7-slim@sha256:60d9996b6a8a3689d36db740b49f4327be3be09a21122bd02fb8895abb38b50d
|
||||
|
||||
ENV PYTHONDONTWRITEBYTECODE=1 \
|
||||
PYTHONUNBUFFERED=1 \
|
||||
APP_HOST=0.0.0.0 \
|
||||
APP_PORT=8080
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
RUN groupadd --system app && \
|
||||
useradd --system --gid app --create-home app
|
||||
|
||||
COPY requirements.txt /app/requirements.txt
|
||||
RUN pip install --no-cache-dir --timeout 60 -r requirements.txt
|
||||
|
||||
COPY --chown=app:app src/ /app/src/
|
||||
COPY --chown=app:app migrations/ /app/migrations/
|
||||
|
||||
USER app
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=10s --retries=3 \
|
||||
CMD python -c "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2)" || exit 1
|
||||
|
||||
CMD ["sh", "-c", "exec uvicorn src.main:app --host \"${APP_HOST}\" --port \"${APP_PORT}\" --timeout-graceful-shutdown 8"]
|
||||
@@ -0,0 +1,44 @@
|
||||
name: mtusi-lab2
|
||||
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.6-alpine
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: messenger
|
||||
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
|
||||
secrets:
|
||||
- postgres_password
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U messenger -d messenger"]
|
||||
interval: 5s
|
||||
timeout: 3s
|
||||
retries: 10
|
||||
|
||||
api:
|
||||
build: .
|
||||
image: mtusi-messenger:lab2
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
environment:
|
||||
APP_ENV: ${APP_ENV:-lab}
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
DATABASE_URL_FILE: /run/secrets/database_url
|
||||
secrets:
|
||||
- database_url
|
||||
ports:
|
||||
- "127.0.0.1:8080:8080"
|
||||
|
||||
secrets:
|
||||
postgres_password:
|
||||
file: ./secrets/postgres_password
|
||||
database_url:
|
||||
file: ./secrets/database_url
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
@@ -0,0 +1,63 @@
|
||||
-- 001_init: базовая схема лабы 2. Повторный запуск безопасен (IF NOT EXISTS).
|
||||
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id uuid PRIMARY KEY,
|
||||
username text NOT NULL,
|
||||
display_name text NOT NULL,
|
||||
password_hash text NOT NULL, -- Argon2id, никогда не отдаётся в API
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT users_username_unique UNIQUE (username),
|
||||
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
|
||||
CONSTRAINT users_display_name_len CHECK (
|
||||
char_length(display_name) BETWEEN 1 AND 100 AND btrim(display_name) <> ''
|
||||
)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id uuid PRIMARY KEY,
|
||||
title text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT chats_title_len CHECK (
|
||||
char_length(title) BETWEEN 1 AND 100 AND btrim(title) <> ''
|
||||
)
|
||||
);
|
||||
|
||||
-- Порядок списка чатов: (created_at, id)
|
||||
CREATE INDEX IF NOT EXISTS chats_created_idx ON chats (created_at, id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
position smallint NOT NULL, -- порядок member_ids как в запросе
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- Список чатов пользователя и проверка членства
|
||||
CREATE INDEX IF NOT EXISTS chat_members_user_idx ON chat_members (user_id, chat_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id uuid PRIMARY KEY,
|
||||
chat_id uuid NOT NULL REFERENCES chats (id) ON DELETE CASCADE,
|
||||
sender_id uuid NOT NULL REFERENCES users (id),
|
||||
text text NOT NULL,
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
CONSTRAINT messages_text_len CHECK (
|
||||
char_length(text) BETWEEN 1 AND 4000 AND btrim(text) <> ''
|
||||
)
|
||||
);
|
||||
|
||||
-- Keyset-пагинация истории: WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
-- ORDER BY created_at, id LIMIT n -> index scan без сортировки и полного прохода
|
||||
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
token_hash bytea PRIMARY KEY, -- SHA-256 токена; сам токен не хранится
|
||||
user_id uuid NOT NULL REFERENCES users (id),
|
||||
created_at timestamptz NOT NULL DEFAULT now(),
|
||||
expires_at timestamptz NOT NULL,
|
||||
revoked_at timestamptz,
|
||||
CONSTRAINT sessions_expiry_after_create CHECK (expires_at > created_at)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS sessions_user_idx ON sessions (user_id);
|
||||
CREATE INDEX IF NOT EXISTS sessions_expires_idx ON sessions (expires_at);
|
||||
@@ -0,0 +1,15 @@
|
||||
annotated-types==0.8.0
|
||||
anyio==4.15.1
|
||||
click==8.5.0
|
||||
fastapi==0.115.2
|
||||
h11==0.16.0
|
||||
idna==3.20
|
||||
pydantic==2.14.1
|
||||
pydantic-core==2.50.1
|
||||
starlette==0.40.0
|
||||
typing-extensions==4.16.0
|
||||
typing-inspection==0.4.4
|
||||
uvicorn==0.32.0
|
||||
asyncpg==0.30.0
|
||||
argon2-cffi==23.1.0
|
||||
argon2-cffi-bindings==21.2.0
|
||||
Executable
+7
@@ -0,0 +1,7 @@
|
||||
#!/bin/sh
|
||||
# Перезапуск API и PostgreSQL с сохранением volume (никаких down -v).
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
docker compose --env-file .env stop api
|
||||
docker compose --env-file .env restart postgres
|
||||
docker compose --env-file .env start api
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
import asyncio
|
||||
import base64
|
||||
import binascii
|
||||
import hashlib
|
||||
import secrets
|
||||
from typing import Optional, Tuple
|
||||
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import InvalidHashError, VerificationError
|
||||
from fastapi import HTTPException, Request
|
||||
|
||||
_hasher = PasswordHasher()
|
||||
# Хеш-заглушка: для несуществующего пользователя тратим столько же времени, сколько для существующего.
|
||||
_DUMMY_HASH = _hasher.hash("dummy-password-for-timing")
|
||||
|
||||
BEARER_CHALLENGE = {"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
BASIC_CHALLENGE = {"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'}
|
||||
|
||||
|
||||
async def hash_password(password: str) -> str:
|
||||
return await asyncio.to_thread(_hasher.hash, password) # Argon2 грузит CPU, не блокируем event loop
|
||||
|
||||
|
||||
async def verify_password(stored_hash: Optional[str], password: str) -> bool:
|
||||
try:
|
||||
return await asyncio.to_thread(_hasher.verify, stored_hash or _DUMMY_HASH, password)
|
||||
except (VerificationError, InvalidHashError):
|
||||
return False
|
||||
|
||||
|
||||
def new_token() -> str:
|
||||
return secrets.token_urlsafe(32) # 256 бит случайности
|
||||
|
||||
|
||||
def token_hash(token: str) -> bytes:
|
||||
return hashlib.sha256(token.encode()).digest()
|
||||
|
||||
|
||||
def parse_basic(header: Optional[str]) -> Optional[Tuple[str, str]]:
|
||||
if not header:
|
||||
return None
|
||||
scheme, _, value = header.partition(" ")
|
||||
if scheme.lower() != "basic" or not value:
|
||||
return None
|
||||
try:
|
||||
raw = base64.b64decode(value.strip(), validate=True).decode("utf-8")
|
||||
except (binascii.Error, UnicodeDecodeError, ValueError):
|
||||
return None
|
||||
username, sep, password = raw.partition(":") # двоеточие в пароле допустимо
|
||||
return (username, password) if sep else None
|
||||
|
||||
|
||||
def parse_bearer(header: Optional[str]) -> Optional[str]:
|
||||
if not header:
|
||||
return None
|
||||
scheme, _, value = header.partition(" ")
|
||||
value = value.strip()
|
||||
if scheme.lower() != "bearer" or not value or len(value) > 512:
|
||||
return None
|
||||
return value
|
||||
|
||||
|
||||
_SESSION_SQL = """
|
||||
SELECT u.id, u.username, u.display_name, u.created_at
|
||||
FROM sessions s JOIN users u ON u.id = s.user_id
|
||||
WHERE s.token_hash = $1 AND s.revoked_at IS NULL AND s.expires_at > now()
|
||||
"""
|
||||
|
||||
|
||||
async def current_user(request: Request):
|
||||
"""Зависимость для всех защищённых endpoint: только Bearer, X-User-Id игнорируется."""
|
||||
token = parse_bearer(request.headers.get("Authorization"))
|
||||
if token is None:
|
||||
raise HTTPException(401, headers=BEARER_CHALLENGE)
|
||||
digest = token_hash(token)
|
||||
row = await request.app.state.pool.fetchrow(_SESSION_SQL, digest)
|
||||
if row is None:
|
||||
raise HTTPException(401, headers=BEARER_CHALLENGE)
|
||||
request.state.token_hash = digest
|
||||
return row
|
||||
+208
@@ -0,0 +1,208 @@
|
||||
import base64
|
||||
import json
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
import asyncpg
|
||||
from fastapi import APIRouter, Depends, Query, Request
|
||||
from pydantic import BaseModel, ConfigDict, Field
|
||||
|
||||
from .auth import current_user
|
||||
from .common import iso, make_error_response
|
||||
|
||||
router = APIRouter()
|
||||
|
||||
|
||||
class StrictRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
|
||||
class CreateChatRequest(StrictRequest):
|
||||
title: str
|
||||
member_ids: List[str] = Field(min_length=1, max_length=100)
|
||||
|
||||
|
||||
class CreateMessageRequest(StrictRequest):
|
||||
text: str
|
||||
|
||||
|
||||
def _req_id(request: Request) -> str:
|
||||
return request.state.request_id
|
||||
|
||||
|
||||
# курсор: непрозрачная строка, привязанная к ресурсу (scope)
|
||||
def encode_cursor(scope: str, created_at: datetime, row_id: uuid.UUID) -> str:
|
||||
raw = json.dumps([scope, iso(created_at), str(row_id)]).encode()
|
||||
return base64.urlsafe_b64encode(raw).decode()
|
||||
|
||||
|
||||
def decode_cursor(cursor: str, scope: str) -> Tuple[datetime, uuid.UUID]:
|
||||
"""ValueError, если курсор повреждён или выдан для другого ресурса."""
|
||||
try:
|
||||
sc, ts, rid = json.loads(base64.urlsafe_b64decode(cursor.encode()))
|
||||
if sc != scope:
|
||||
raise ValueError("scope mismatch")
|
||||
return datetime.fromisoformat(ts), uuid.UUID(rid)
|
||||
except Exception as exc:
|
||||
raise ValueError("invalid cursor") from exc
|
||||
|
||||
|
||||
def _bad_text(value: str) -> bool:
|
||||
return not value.strip() or "\x00" in value # NUL нельзя хранить в PostgreSQL text
|
||||
|
||||
|
||||
_CHAT_COLUMNS = (
|
||||
"c.id, c.title, c.created_at, "
|
||||
"array(SELECT m2.user_id FROM chat_members m2 WHERE m2.chat_id = c.id ORDER BY m2.position) AS member_ids"
|
||||
)
|
||||
|
||||
|
||||
def chat_dict(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": [str(m) for m in row["member_ids"]],
|
||||
"created_at": iso(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def message_dict(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"chat_id": str(row["chat_id"]),
|
||||
"sender_id": str(row["sender_id"]),
|
||||
"text": row["text"],
|
||||
"created_at": iso(row["created_at"]),
|
||||
}
|
||||
|
||||
|
||||
def _check_limit(limit: int) -> bool:
|
||||
return 1 <= limit <= 100
|
||||
|
||||
|
||||
# чаты
|
||||
@router.post("/chats", status_code=201)
|
||||
async def create_chat(req: CreateChatRequest, request: Request, user=Depends(current_user)):
|
||||
req_id = _req_id(request)
|
||||
if not (1 <= len(req.title) <= 100) or _bad_text(req.title):
|
||||
return make_error_response(400, "invalid_request", "Invalid title", req_id)
|
||||
try:
|
||||
members = [uuid.UUID(m) for m in req.member_ids]
|
||||
except ValueError:
|
||||
return make_error_response(400, "invalid_request", "Invalid member id", req_id)
|
||||
if len(members) != len(set(members)):
|
||||
return make_error_response(400, "invalid_request", "Duplicate members found", req_id)
|
||||
if user["id"] not in members:
|
||||
return make_error_response(400, "invalid_request", "Caller must be in member_ids", req_id)
|
||||
|
||||
chat_id = uuid.uuid4()
|
||||
try:
|
||||
async with request.app.state.pool.acquire() as conn:
|
||||
# Чат и все участники - одна транзакция: неизвестный участник откатывает всё.
|
||||
async with conn.transaction():
|
||||
created_at = await conn.fetchval(
|
||||
"INSERT INTO chats (id, title, created_at) VALUES ($1, $2, clock_timestamp()) RETURNING created_at",
|
||||
chat_id, req.title,
|
||||
)
|
||||
await conn.execute(
|
||||
"INSERT INTO chat_members (chat_id, user_id, position) "
|
||||
"SELECT $1, t.u, (t.p - 1)::smallint FROM unnest($2::uuid[]) WITH ORDINALITY AS t(u, p)",
|
||||
chat_id, members,
|
||||
)
|
||||
except asyncpg.ForeignKeyViolationError:
|
||||
return make_error_response(400, "invalid_request", "Unknown member", req_id)
|
||||
|
||||
return {"id": str(chat_id), "title": req.title, "member_ids": [str(m) for m in members],
|
||||
"created_at": iso(created_at)}
|
||||
|
||||
|
||||
@router.get("/chats")
|
||||
async def list_chats(request: Request, limit: int = 50,
|
||||
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
|
||||
user=Depends(current_user)):
|
||||
req_id = _req_id(request)
|
||||
if not _check_limit(limit):
|
||||
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
|
||||
scope = "chats:" + str(user["id"])
|
||||
base = (f"SELECT {_CHAT_COLUMNS} FROM chats c "
|
||||
"JOIN chat_members m ON m.chat_id = c.id AND m.user_id = $1 ")
|
||||
if cursor is None:
|
||||
rows = await request.app.state.pool.fetch(
|
||||
base + "ORDER BY c.created_at, c.id LIMIT $2", user["id"], limit + 1)
|
||||
else:
|
||||
try:
|
||||
ts, rid = decode_cursor(cursor, scope)
|
||||
except ValueError:
|
||||
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
|
||||
rows = await request.app.state.pool.fetch(
|
||||
base + "WHERE (c.created_at, c.id) > ($2::timestamptz, $3::uuid) "
|
||||
"ORDER BY c.created_at, c.id LIMIT $4",
|
||||
user["id"], ts, rid, limit + 1)
|
||||
items = rows[:limit]
|
||||
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
|
||||
return {"items": [chat_dict(r) for r in items], "next_cursor": next_cursor}
|
||||
|
||||
|
||||
@router.get("/chats/{chat_id}")
|
||||
async def get_chat(chat_id: uuid.UUID, request: Request, user=Depends(current_user)):
|
||||
row = await request.app.state.pool.fetchrow(
|
||||
f"SELECT {_CHAT_COLUMNS} FROM chats c WHERE c.id = $1 "
|
||||
"AND EXISTS (SELECT 1 FROM chat_members m WHERE m.chat_id = c.id AND m.user_id = $2)",
|
||||
chat_id, user["id"],
|
||||
)
|
||||
if row is None:
|
||||
return make_error_response(404, "not_found", "Chat not found", _req_id(request))
|
||||
return chat_dict(row)
|
||||
|
||||
|
||||
# сообщения
|
||||
@router.post("/chats/{chat_id}/messages", status_code=201)
|
||||
async def send_message(chat_id: uuid.UUID, req: CreateMessageRequest, request: Request,
|
||||
user=Depends(current_user)):
|
||||
req_id = _req_id(request)
|
||||
if _bad_text(req.text):
|
||||
return make_error_response(400, "invalid_request", "Empty message text", req_id)
|
||||
if len(req.text) > 4000:
|
||||
return make_error_response(400, "invalid_request", "Message text exceeds 4000 characters", req_id)
|
||||
# Проверка членства и вставка - один атомарный оператор.
|
||||
row = await request.app.state.pool.fetchrow(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text, created_at) "
|
||||
"SELECT $1, $2, $3, $4, clock_timestamp() "
|
||||
"WHERE EXISTS (SELECT 1 FROM chat_members WHERE chat_id = $2 AND user_id = $3) "
|
||||
"RETURNING id, chat_id, sender_id, text, created_at",
|
||||
uuid.uuid4(), chat_id, user["id"], req.text,
|
||||
)
|
||||
if row is None:
|
||||
return make_error_response(404, "not_found", "Chat not found", req_id)
|
||||
return message_dict(row)
|
||||
|
||||
|
||||
@router.get("/chats/{chat_id}/messages")
|
||||
async def get_messages(chat_id: uuid.UUID, request: Request, limit: int = 50,
|
||||
cursor: Optional[str] = Query(default=None, min_length=1, max_length=512),
|
||||
user=Depends(current_user)):
|
||||
req_id = _req_id(request)
|
||||
if not _check_limit(limit):
|
||||
return make_error_response(400, "invalid_request", "Limit must be between 1 and 100", req_id)
|
||||
pool = request.app.state.pool
|
||||
is_member = await pool.fetchval(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2", chat_id, user["id"])
|
||||
if not is_member:
|
||||
return make_error_response(404, "not_found", "Chat not found", req_id)
|
||||
|
||||
scope = "msgs:" + str(chat_id)
|
||||
base = "SELECT id, chat_id, sender_id, text, created_at FROM messages WHERE chat_id = $1 "
|
||||
if cursor is None:
|
||||
rows = await pool.fetch(base + "ORDER BY created_at, id LIMIT $2", chat_id, limit + 1)
|
||||
else:
|
||||
try:
|
||||
ts, rid = decode_cursor(cursor, scope)
|
||||
except ValueError:
|
||||
return make_error_response(400, "invalid_request", "Invalid cursor", req_id)
|
||||
rows = await pool.fetch(
|
||||
base + "AND (created_at, id) > ($2::timestamptz, $3::uuid) ORDER BY created_at, id LIMIT $4",
|
||||
chat_id, ts, rid, limit + 1)
|
||||
items = rows[:limit]
|
||||
next_cursor = encode_cursor(scope, items[-1]["created_at"], items[-1]["id"]) if len(rows) > limit else None
|
||||
return {"items": [message_dict(r) for r in items], "next_cursor": next_cursor}
|
||||
@@ -0,0 +1,29 @@
|
||||
from datetime import datetime, timezone
|
||||
from typing import Optional
|
||||
|
||||
from fastapi.responses import JSONResponse
|
||||
|
||||
|
||||
def iso(dt: datetime) -> str:
|
||||
"""RFC 3339 UTC с Z; микросекунды нужны, чтобы курсор был точным."""
|
||||
return dt.astimezone(timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
|
||||
|
||||
|
||||
def make_error_response(status_code: int, code: str, message: str, req_id: str, headers: Optional[dict] = None):
|
||||
h = {"X-Request-Id": req_id}
|
||||
if headers:
|
||||
h.update(headers)
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": req_id}},
|
||||
headers=h,
|
||||
)
|
||||
|
||||
|
||||
def user_dict(row) -> dict:
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": iso(row["created_at"]),
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
def _read_secret(file_var: str, direct_var: str) -> str:
|
||||
"""Секрет из файла (DATABASE_URL_FILE), с запасным вариантом из переменной окружения."""
|
||||
path = os.environ.get(file_var)
|
||||
if path:
|
||||
return Path(path).read_text().strip()
|
||||
return os.environ.get(direct_var, "")
|
||||
|
||||
|
||||
DATABASE_URL = _read_secret("DATABASE_URL_FILE", "DATABASE_URL")
|
||||
SESSION_TTL_SECONDS = int(os.environ.get("SESSION_TTL_SECONDS", "3600"))
|
||||
|
||||
DB_POOL_MIN = int(os.environ.get("DB_POOL_MIN", "2"))
|
||||
DB_POOL_MAX = int(os.environ.get("DB_POOL_MAX", "10"))
|
||||
DB_CONNECT_TIMEOUT = float(os.environ.get("DB_CONNECT_TIMEOUT", "5"))
|
||||
DB_COMMAND_TIMEOUT = float(os.environ.get("DB_COMMAND_TIMEOUT", "5"))
|
||||
|
||||
MIGRATIONS_DIR = Path(os.environ.get("MIGRATIONS_DIR", Path(__file__).resolve().parent.parent / "migrations"))
|
||||
@@ -0,0 +1,56 @@
|
||||
import asyncio
|
||||
import logging
|
||||
|
||||
import asyncpg
|
||||
|
||||
from . import config
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
|
||||
# Произвольный константный ключ: один экземпляр выполняет миграции, остальные ждут.
|
||||
MIGRATION_LOCK_KEY = 727_001
|
||||
|
||||
|
||||
async def create_pool() -> asyncpg.Pool:
|
||||
# Пул ограничен по размеру; у соединений и команд есть таймауты.
|
||||
return await asyncpg.create_pool(
|
||||
dsn=config.DATABASE_URL,
|
||||
min_size=config.DB_POOL_MIN,
|
||||
max_size=config.DB_POOL_MAX,
|
||||
timeout=config.DB_CONNECT_TIMEOUT,
|
||||
command_timeout=config.DB_COMMAND_TIMEOUT,
|
||||
)
|
||||
|
||||
|
||||
async def create_pool_with_retry(attempts: int = 30, delay: float = 1.0) -> asyncpg.Pool:
|
||||
# БД в compose может подняться позже API.
|
||||
for attempt in range(1, attempts + 1):
|
||||
try:
|
||||
return await create_pool()
|
||||
except (OSError, asyncpg.PostgresError, asyncio.TimeoutError) as exc:
|
||||
logger.warning("DB not ready (%d/%d): %s", attempt, attempts, type(exc).__name__)
|
||||
await asyncio.sleep(delay)
|
||||
raise RuntimeError("database is unavailable")
|
||||
|
||||
|
||||
async def run_migrations(pool: asyncpg.Pool) -> None:
|
||||
# Применяет migrations/*.sql по порядку имён, каждую один раз.
|
||||
files = sorted(config.MIGRATIONS_DIR.glob("*.sql"))
|
||||
async with pool.acquire() as conn:
|
||||
await conn.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_KEY)
|
||||
try:
|
||||
await conn.execute(
|
||||
"CREATE TABLE IF NOT EXISTS schema_migrations ("
|
||||
" version text PRIMARY KEY,"
|
||||
" applied_at timestamptz NOT NULL DEFAULT now())"
|
||||
)
|
||||
applied = {r["version"] for r in await conn.fetch("SELECT version FROM schema_migrations")}
|
||||
for path in files:
|
||||
if path.name in applied:
|
||||
continue
|
||||
async with conn.transaction():
|
||||
await conn.execute(path.read_text())
|
||||
await conn.execute("INSERT INTO schema_migrations (version) VALUES ($1)", path.name)
|
||||
logger.info("Applied migration %s", path.name)
|
||||
finally:
|
||||
await conn.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_KEY)
|
||||
+183
@@ -0,0 +1,183 @@
|
||||
import asyncio
|
||||
import logging
|
||||
import re
|
||||
import sys
|
||||
import uuid
|
||||
from contextlib import asynccontextmanager
|
||||
|
||||
import asyncpg
|
||||
from fastapi import Depends, FastAPI, Request, Response
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from pydantic import BaseModel, ConfigDict
|
||||
from starlette.exceptions import HTTPException
|
||||
|
||||
from . import config
|
||||
from .auth import (BASIC_CHALLENGE, current_user, hash_password, new_token,
|
||||
parse_basic, token_hash, verify_password)
|
||||
from .chats import router as chats_router
|
||||
from .common import iso, make_error_response, user_dict
|
||||
from .db import create_pool_with_retry, run_migrations
|
||||
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format="%(asctime)s [%(levelname)s] [req_id=%(request_id)s] %(message)s",
|
||||
handlers=[logging.StreamHandler(sys.stdout)],
|
||||
)
|
||||
|
||||
|
||||
class RequestIdFilter(logging.Filter):
|
||||
def filter(self, record):
|
||||
if not hasattr(record, "request_id"):
|
||||
record.request_id = "-"
|
||||
return True
|
||||
|
||||
|
||||
logger = logging.getLogger("messenger")
|
||||
logger.addFilter(RequestIdFilter())
|
||||
|
||||
is_shutting_down = False
|
||||
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}")
|
||||
|
||||
|
||||
@asynccontextmanager
|
||||
async def lifespan(app: FastAPI):
|
||||
app.state.pool = await create_pool_with_retry()
|
||||
await run_migrations(app.state.pool)
|
||||
yield
|
||||
global is_shutting_down
|
||||
is_shutting_down = True
|
||||
await app.state.pool.close()
|
||||
logger.info("Application shutdown complete")
|
||||
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger - Lab 2", lifespan=lifespan)
|
||||
app.include_router(chats_router, prefix="/api/v1")
|
||||
|
||||
|
||||
@app.middleware("http")
|
||||
async def middleware_pipeline(request: Request, call_next):
|
||||
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
request.state.request_id = req_id
|
||||
if is_shutting_down and request.url.path != "/health/live":
|
||||
return make_error_response(503, "unavailable", "Server is shutting down", req_id)
|
||||
logger.info(f"Incoming request {request.method} {request.url.path}", extra={"request_id": req_id})
|
||||
response: Response = await call_next(request)
|
||||
response.headers["X-Request-Id"] = req_id
|
||||
logger.info(f"Completed {request.method} {request.url.path} with status {response.status_code}",
|
||||
extra={"request_id": req_id})
|
||||
return response
|
||||
|
||||
|
||||
def _req_id(request: Request) -> str:
|
||||
return getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
return make_error_response(400, "invalid_request", "Validation error", _req_id(request))
|
||||
|
||||
|
||||
@app.exception_handler(HTTPException)
|
||||
async def http_exception_handler(request: Request, exc: HTTPException):
|
||||
code = {
|
||||
400: "invalid_request", 401: "unauthorized", 404: "not_found", 409: "conflict",
|
||||
413: "payload_too_large", 415: "unsupported_media_type", 429: "rate_limited", 503: "unavailable",
|
||||
}.get(exc.status_code, "internal_error" if exc.status_code >= 500 else "invalid_request")
|
||||
return make_error_response(exc.status_code, code, "Request failed", _req_id(request), exc.headers)
|
||||
|
||||
|
||||
async def dependency_unavailable_handler(request: Request, exc: Exception):
|
||||
"""БД недоступна или не ответила в срок: ограниченная 503, без деталей и без доверия анониму."""
|
||||
logger.error("Dependency failure: %s", type(exc).__name__, extra={"request_id": _req_id(request)})
|
||||
return make_error_response(503, "unavailable", "Service temporarily unavailable", _req_id(request))
|
||||
|
||||
|
||||
for _exc in (asyncpg.PostgresError, asyncpg.InterfaceError, ConnectionError, asyncio.TimeoutError):
|
||||
app.add_exception_handler(_exc, dependency_unavailable_handler)
|
||||
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def generic_exception_handler(request: Request, exc: Exception):
|
||||
logger.error("Unhandled exception: %s", type(exc).__name__, extra={"request_id": _req_id(request)})
|
||||
return make_error_response(500, "internal_error", "Internal server error", _req_id(request))
|
||||
|
||||
|
||||
class StrictRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid", strict=True)
|
||||
|
||||
|
||||
class CreateUserRequest(StrictRequest):
|
||||
username: str
|
||||
display_name: str
|
||||
password: str
|
||||
|
||||
|
||||
@app.get("/health/live")
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def health_ready(request: Request):
|
||||
# Критичная зависимость для готовности - PostgreSQL.
|
||||
await request.app.state.pool.fetchval("SELECT 1", timeout=2)
|
||||
return {"status": "ok"}
|
||||
|
||||
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def register_user(req: CreateUserRequest, request: Request):
|
||||
req_id = _req_id(request)
|
||||
if not USERNAME_RE.fullmatch(req.username):
|
||||
return make_error_response(400, "invalid_request", "Invalid username format", req_id)
|
||||
if not (1 <= len(req.display_name) <= 100) or not req.display_name.strip() or "\x00" in req.display_name:
|
||||
return make_error_response(400, "invalid_request", "Invalid display_name", req_id)
|
||||
if not (12 <= len(req.password) <= 128):
|
||||
return make_error_response(400, "invalid_request", "Invalid password length", req_id)
|
||||
|
||||
pw_hash = await hash_password(req.password)
|
||||
try:
|
||||
row = await request.app.state.pool.fetchrow(
|
||||
"INSERT INTO users (id, username, display_name, password_hash, created_at) "
|
||||
"VALUES ($1, $2, $3, $4, clock_timestamp()) "
|
||||
"RETURNING id, username, display_name, created_at",
|
||||
uuid.uuid4(), req.username, req.display_name, pw_hash,
|
||||
)
|
||||
except asyncpg.UniqueViolationError: # гонку одинаковых username решает UNIQUE, а не SELECT
|
||||
return make_error_response(409, "conflict", "Username already exists", req_id)
|
||||
return user_dict(row)
|
||||
|
||||
@app.get("/api/v1/users/me")
|
||||
async def get_current_user(user=Depends(current_user)):
|
||||
return user_dict(user)
|
||||
|
||||
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def create_session(request: Request):
|
||||
req_id = _req_id(request)
|
||||
creds = parse_basic(request.headers.get("Authorization"))
|
||||
if creds is None:
|
||||
return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE)
|
||||
username, password = creds
|
||||
pool = request.app.state.pool
|
||||
row = await pool.fetchrow(
|
||||
"SELECT id, username, display_name, created_at, password_hash FROM users WHERE username = $1", username
|
||||
)
|
||||
ok = await verify_password(row["password_hash"] if row else None, password)
|
||||
if row is None or not ok:
|
||||
return make_error_response(401, "unauthorized", "Unauthorized", req_id, BASIC_CHALLENGE)
|
||||
|
||||
token = new_token()
|
||||
expires_at = await pool.fetchval(
|
||||
"INSERT INTO sessions (token_hash, user_id, created_at, expires_at) "
|
||||
"VALUES ($1, $2, now(), now() + make_interval(secs => $3)) RETURNING expires_at",
|
||||
token_hash(token), row["id"], float(config.SESSION_TTL_SECONDS),
|
||||
)
|
||||
return {"token": token, "token_type": "Bearer", "expires_at": iso(expires_at), "user": user_dict(row)}
|
||||
|
||||
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def logout(request: Request, user=Depends(current_user)):
|
||||
await request.app.state.pool.execute(
|
||||
"UPDATE sessions SET revoked_at = now() WHERE token_hash = $1", request.state.token_hash
|
||||
)
|
||||
return Response(status_code=204)
|
||||
Reference in New Issue
Block a user