Files
mtusi2026lab2/src/main.py
T
scarletsky 7e8e18be16
Skeleton contracts / contracts (pull_request) Canceled after 0s
Фиксы подтверждённых проблем
2026-10-23 01:33:01 +03:00

379 lines
13 KiB
Python

import base64
import json
import logging
import re
from contextlib import asynccontextmanager
from datetime import datetime
from typing import Any, Callable, Dict, Optional, Tuple
from uuid import UUID, uuid4
import psycopg
from fastapi import Depends, FastAPI, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse
from psycopg_pool import PoolTimeout
from starlette.exceptions import HTTPException as StarletteHTTPException
from starlette.middleware.base import BaseHTTPMiddleware
from .config import load_settings
from .db import create_pool, wait_and_migrate
from .models import (
Chat,
ChatCreate,
ChatPage,
Message,
MessageCreate,
MessagePage,
Session,
User,
UserCreate,
)
from .security import hash_password, parse_basic, parse_bearer, verify_password
from .sessions import SessionCache, SessionService
from .storage import Storage, UnknownMember, UsernameTaken
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
log = logging.getLogger("messenger.api")
BASIC_CHALLENGE = 'Basic realm="messenger", charset="UTF-8"'
BEARER_CHALLENGE = 'Bearer realm="messenger"'
REQUEST_ID_RE = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
@asynccontextmanager
async def lifespan(app: FastAPI):
settings = load_settings()
applied = wait_and_migrate(settings)
log.info("migrations applied at startup: %s", applied or "none")
pool = create_pool(settings)
storage = Storage(pool)
cache = SessionCache(settings)
app.state.settings = settings
app.state.storage = storage
app.state.cache = cache
app.state.sessions = SessionService(storage, cache, settings)
log.info(
"started: session_ttl=%ss cache=%s pool=%s..%s",
settings.session_ttl_seconds,
"redis" if cache.client is not None else "disabled",
settings.db_pool_min,
settings.db_pool_max,
)
try:
yield
finally:
pool.close()
if cache.client is not None:
cache.client.close()
app = FastAPI(
title="MTUSI Messenger (PostgreSQL + Redis)",
version="2.0.0",
lifespan=lifespan,
)
# Request ID
class RequestIdMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request: Request, call_next: Callable):
incoming = request.headers.get("X-Request-Id", "")
request_id = incoming if REQUEST_ID_RE.match(incoming) else str(uuid4())
request.state.request_id = request_id
response = await call_next(request)
response.headers["X-Request-Id"] = request_id
return response
app.add_middleware(RequestIdMiddleware)
# errors
class ApiError(Exception):
def __init__(self, status_code: int, code: str, message: str, headers: Optional[Dict[str, str]] = None):
self.status_code = status_code
self.code = code
self.message = message
self.headers = headers or {}
def unauthorized(challenge: str = BEARER_CHALLENGE) -> ApiError:
return ApiError(401, "unauthorized", "Authentication required", {"WWW-Authenticate": challenge})
def bad_request(message: str = "Invalid request") -> ApiError:
return ApiError(400, "invalid_request", message)
def not_found() -> ApiError:
return ApiError(404, "not_found", "Not found")
def error_response(
request: Request,
status_code: int,
code: str,
message: str,
headers: Optional[Dict[str, str]] = None,
) -> JSONResponse:
request_id = getattr(request.state, "request_id", None) or str(uuid4())
all_headers = {"X-Request-Id": request_id}
all_headers.update(headers or {})
return JSONResponse(
status_code=status_code,
content={"error": {"code": code, "message": message, "request_id": request_id}},
headers=all_headers,
)
@app.exception_handler(ApiError)
async def api_error_handler(request: Request, exc: ApiError) -> JSONResponse:
return error_response(request, exc.status_code, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request: Request, exc: RequestValidationError) -> JSONResponse:
return error_response(request, 400, "invalid_request", "Invalid request")
@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request: Request, exc: StarletteHTTPException) -> JSONResponse:
status_to_code = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
}
status_code = exc.status_code if exc.status_code in status_to_code else 500
code = status_to_code.get(status_code, "internal_error")
message = str(exc.detail) if status_code != 500 else "Internal server error"
return error_response(request, status_code, code, message)
async def dependency_unavailable(request: Request, exc: Exception) -> JSONResponse:
# Наружу — только общий 503, без SQL, адресов и текста драйвера.
log.warning("database unavailable: %s", type(exc).__name__)
return error_response(request, 503, "unavailable", "Service temporarily unavailable")
app.add_exception_handler(psycopg.OperationalError, dependency_unavailable)
app.add_exception_handler(psycopg.InterfaceError, dependency_unavailable)
app.add_exception_handler(PoolTimeout, dependency_unavailable)
@app.exception_handler(Exception)
async def unexpected_exception_handler(request: Request, exc: Exception) -> JSONResponse:
log.exception("unexpected error")
return error_response(request, 500, "internal_error", "Internal server error")
# helpers
def require_json_content_type(request: Request) -> None:
content_type = request.headers.get("content-type", "")
if not content_type.lower().startswith("application/json"):
raise ApiError(415, "unsupported_media_type", "Unsupported media type")
def ensure_not_blank(value: str) -> None:
if not value.strip():
raise bad_request()
def storage_of(request: Request) -> Storage:
return request.app.state.storage
def current_user(request: Request) -> User:
"""Только Authorization: Bearer. Basic и X-User-Id здесь не дают доступа."""
token = parse_bearer(request.headers.get("Authorization"))
if token is None:
raise unauthorized()
user = request.app.state.sessions.resolve(token)
if user is None:
raise unauthorized()
request.state.token = token
return user
def encode_cursor(resource_id: UUID, created_at: datetime, item_id: UUID) -> str:
payload = {
"resource_id": str(resource_id),
"created_at": created_at.isoformat(),
"item_id": str(item_id),
}
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
def decode_cursor(cursor: Optional[str], expected_resource_id: UUID) -> Optional[Tuple[datetime, UUID]]:
if cursor is None:
return None
try:
padding = "=" * (-len(cursor) % 4)
raw = base64.urlsafe_b64decode(cursor + padding)
payload = json.loads(raw.decode("utf-8"))
resource_id = UUID(payload["resource_id"])
created_at = datetime.fromisoformat(payload["created_at"])
item_id = UUID(payload["item_id"])
if created_at.tzinfo is None or created_at.utcoffset() is None:
raise ValueError("invalid_cursor")
except (ValueError, KeyError, TypeError, AttributeError, json.JSONDecodeError):
raise bad_request("Invalid cursor")
if resource_id != expected_resource_id:
raise bad_request("Invalid cursor")
return created_at, item_id
# health
@app.get("/health/live", response_model=Dict[str, str])
def liveness() -> Dict[str, str]:
return {"status": "ok"}
@app.get("/health/ready", response_model=Dict[str, str])
def readiness(request: Request) -> Dict[str, str]:
# Критична только PostgreSQL. Redis — кэш с обходом, его отказ не делает
# API неготовым (см. REPORT.md).
try:
storage_of(request).ping()
except (psycopg.Error, PoolTimeout):
raise ApiError(503, "unavailable", "Database is not available")
return {"status": "ok"}
# users
@app.post("/api/v1/users", response_model=User, status_code=201)
def register_user(request: Request, data: UserCreate) -> User:
require_json_content_type(request)
ensure_not_blank(data.display_name)
ensure_not_blank(data.password)
password_hash = hash_password(data.password)
try:
return storage_of(request).create_user(data.username, data.display_name, password_hash)
except UsernameTaken:
raise ApiError(409, "conflict", "Username already exists")
@app.get("/api/v1/users/me", response_model=User)
def get_current_user(user: User = Depends(current_user)) -> User:
return user
# sessions
async def require_empty_body(request: Request) -> None:
"""Вход — только заголовок Authorization: Basic, без тела (контракт).
Любые байты в теле (JSON или нет) — 400. Проверка выполняется до
дорогой проверки пароля и до создания сессии.
"""
if await request.body():
raise bad_request("Request body is not allowed")
@app.post("/api/v1/auth/sessions", response_model=Session, status_code=201,
dependencies=[Depends(require_empty_body)])
def create_session(request: Request) -> Session:
credentials = parse_basic(request.headers.get("Authorization"))
if credentials is None:
raise unauthorized(BASIC_CHALLENGE)
username, password = credentials
found = storage_of(request).get_credentials(username)
user, password_hash = found if found else (None, None)
# verify_password выполняется и для несуществующего username (с хешем-пустышкой).
if not verify_password(password_hash, password) or user is None:
raise unauthorized(BASIC_CHALLENGE)
token, expires_at = request.app.state.sessions.create(user)
return Session(token=token, token_type="Bearer", expires_at=expires_at, user=user)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def delete_current_session(request: Request, user: User = Depends(current_user)) -> Response:
if not request.app.state.sessions.revoke(request.state.token):
raise unauthorized()
return Response(status_code=204)
# chats
@app.post("/api/v1/chats", response_model=Chat, status_code=201)
def create_chat(request: Request, data: ChatCreate, user: User = Depends(current_user)) -> Chat:
require_json_content_type(request)
ensure_not_blank(data.title)
if len(data.member_ids) != len(set(data.member_ids)):
raise bad_request("Duplicate member ids")
if user.id not in data.member_ids:
raise bad_request("Caller must be a chat member")
try:
return storage_of(request).create_chat(data.title, data.member_ids)
except UnknownMember:
raise bad_request("Unknown member")
@app.get("/api/v1/chats", response_model=ChatPage)
def list_chats(
request: Request,
user: User = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
) -> ChatPage:
after = decode_cursor(cursor, user.id)
items, has_more = storage_of(request).list_user_chats(user.id, limit, after)
next_cursor = None
if has_more and items:
next_cursor = encode_cursor(user.id, items[-1].created_at, items[-1].id)
return ChatPage(items=items, next_cursor=next_cursor)
@app.get("/api/v1/chats/{chat_id}", response_model=Chat)
def get_chat(request: Request, chat_id: UUID, user: User = Depends(current_user)) -> Chat:
chat = storage_of(request).get_chat_for_member(chat_id, user.id)
if chat is None:
raise not_found()
return chat
# messages
@app.post("/api/v1/chats/{chat_id}/messages", response_model=Message, status_code=201)
def create_message(
request: Request,
chat_id: UUID,
data: MessageCreate,
user: User = Depends(current_user),
) -> Message:
require_json_content_type(request)
ensure_not_blank(data.text)
message = storage_of(request).create_message(chat_id, user.id, data.text)
if message is None:
raise not_found()
return message
@app.get("/api/v1/chats/{chat_id}/messages", response_model=MessagePage)
def list_messages(
request: Request,
chat_id: UUID,
user: User = Depends(current_user),
limit: int = Query(default=50, ge=1, le=100),
cursor: Optional[str] = Query(default=None, min_length=1),
) -> MessagePage:
after = decode_cursor(cursor, chat_id)
result = storage_of(request).list_messages(chat_id, user.id, limit, after)
if result is None:
raise not_found()
items, has_more = result
next_cursor = None
if has_more and items:
next_cursor = encode_cursor(chat_id, items[-1].created_at, items[-1].id)
return MessagePage(items=items, next_cursor=next_cursor)