Files
mtusi2026lab4/app/main.py
T

294 lines
9.8 KiB
Python

"""HTTP API. Every response carries X-Request-Id and X-Instance-Id."""
import asyncio
import base64
import contextvars
import json
import logging
import uuid
from contextlib import asynccontextmanager
import asyncpg
from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse, Response
from starlette.datastructures import MutableHeaders
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.config import load_settings
from app.db import close, connect, migrate
from app.errors import ApiError, unauthorized
from app import logic
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
logger = logging.getLogger("messenger")
settings = load_settings()
request_id_var: contextvars.ContextVar[str] = contextvars.ContextVar("request_id", default="")
_ERROR_CODES = {
400: "invalid_request",
401: "unauthorized",
404: "not_found",
409: "conflict",
413: "payload_too_large",
415: "unsupported_media_type",
429: "rate_limited",
503: "unavailable",
}
def _error_body(status: int, code: str, message: str) -> dict:
return {"error": {"code": code, "message": message, "request_id": request_id_var.get() or "error"}}
def _error_response(status: int, code: str, message: str, headers: dict | None = None) -> JSONResponse:
response = JSONResponse(status_code=status, content=_error_body(status, code, message))
for key, value in (headers or {}).items():
response.headers[key] = value
return response
class ContextMiddleware:
def __init__(self, app):
self.app = app
async def __call__(self, scope, receive, send):
if scope["type"] != "http":
await self.app(scope, receive, send)
return
request_id = str(uuid.uuid4())
token = request_id_var.set(request_id)
started = False
async def send_wrapper(message):
nonlocal started
if message["type"] == "http.response.start":
started = True
headers = MutableHeaders(raw=message["headers"])
headers["X-Request-Id"] = request_id
headers["X-Instance-Id"] = settings.instance_id
await send(message)
try:
await self.app(scope, receive, send_wrapper)
except Exception:
logger.exception("unhandled ASGI error")
if not started:
body = json.dumps(_error_body(500, "internal_error", "Внутренняя ошибка")).encode("utf-8")
await send(
{
"type": "http.response.start",
"status": 500,
"headers": [
(b"content-type", b"application/json"),
(b"x-request-id", request_id.encode("ascii")),
(b"x-instance-id", settings.instance_id.encode("utf-8")),
],
}
)
await send({"type": "http.response.body", "body": body})
finally:
request_id_var.reset(token)
@asynccontextmanager
async def lifespan(_app: FastAPI):
delay = 1
for attempt in range(30):
try:
await connect(settings)
await migrate(settings)
logger.info("instance %s ready to serve", settings.instance_id)
break
except Exception:
logger.exception("startup attempt %s failed", attempt + 1)
await asyncio.sleep(delay)
delay = min(delay * 2, 5)
else:
raise RuntimeError("database startup failed")
try:
yield
finally:
await close()
app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None, openapi_url=None, redirect_slashes=False)
app.add_middleware(ContextMiddleware)
@app.exception_handler(ApiError)
async def handle_api_error(_request: Request, exc: ApiError):
return _error_response(exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(StarletteHTTPException)
async def handle_http(_request: Request, exc: StarletteHTTPException):
status = exc.status_code if exc.status_code in _ERROR_CODES else 500
return _error_response(status, _ERROR_CODES.get(status, "internal_error"), "Запрос отклонён")
@app.exception_handler(asyncpg.PostgresConnectionError)
async def handle_db_down(_request: Request, exc: asyncpg.PostgresConnectionError):
logger.exception("database connection failed")
return _error_response(503, "unavailable", "База данных недоступна")
@app.exception_handler(Exception)
async def handle_unexpected(_request: Request, exc: Exception):
logger.exception("unhandled error")
return _error_response(500, "internal_error", "Внутренняя ошибка")
def _bearer(request: Request) -> str:
header = request.headers.get("authorization", "")
if not header.lower().startswith("bearer "):
raise unauthorized("bearer")
token = header.split(" ", 1)[1].strip()
if not token:
raise unauthorized("bearer")
return token
def _basic(request: Request) -> tuple[str, str]:
header = request.headers.get("authorization", "")
if not header.lower().startswith("basic "):
raise unauthorized("basic")
encoded = header.split(" ", 1)[1].strip()
try:
decoded = base64.b64decode(encoded).decode("utf-8")
except (ValueError, UnicodeError) as exc:
raise unauthorized("basic") from exc
if ":" not in decoded:
raise unauthorized("basic")
username, password = decoded.split(":", 1)
return username, password
async def _current_user(request: Request) -> dict:
return await logic.authenticate(_bearer(request))
async def _json_object(request: Request) -> dict:
media = (request.headers.get("content-type") or "").split(";", 1)[0].strip().lower()
if media != "application/json":
raise ApiError(400, "invalid_request", "Ожидается application/json")
raw = bytearray()
async for chunk in request.stream():
if len(raw) + len(chunk) > 65536:
raise ApiError(413, "payload_too_large", "Тело запроса слишком большое")
raw.extend(chunk)
try:
data = json.loads(bytes(raw) if raw else b"")
except (json.JSONDecodeError, UnicodeError) as exc:
raise ApiError(400, "invalid_request", "Некорректный JSON") from exc
if not isinstance(data, dict):
raise ApiError(400, "invalid_request", "Ожидается JSON-объект")
return data
@app.get("/health/live")
async def live():
return {"status": "ok"}
@app.get("/health/ready")
async def ready():
await logic.ready(settings)
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
async def register(request: Request):
return await logic.register_user(await _json_object(request))
@app.post("/api/v1/auth/sessions", status_code=201)
async def login(request: Request):
username, password = _basic(request)
return await logic.create_session(username, password, settings)
@app.delete("/api/v1/auth/sessions/current", status_code=204)
async def logout(request: Request):
token = _bearer(request)
await logic.authenticate(token)
await logic.revoke_session(token)
return Response(status_code=204)
@app.get("/api/v1/users/me")
async def me(request: Request):
return await _current_user(request)
@app.post("/api/v1/chats", status_code=201)
async def create_chat(request: Request):
user = await _current_user(request)
return await logic.create_chat(user["id"], await _json_object(request))
@app.get("/api/v1/chats")
async def list_chats(request: Request):
user = await _current_user(request)
limit = logic.parse_limit(request.query_params.get("limit"))
return await logic.list_chats(user["id"], limit, request.query_params.get("cursor"))
@app.get("/api/v1/chats/{chat_id}")
async def get_chat(chat_id: str, request: Request):
user = await _current_user(request)
return await logic.get_chat(user["id"], chat_id)
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
async def create_message(chat_id: str, request: Request):
user = await _current_user(request)
body = await _json_object(request)
return await logic.create_message(
user["id"],
chat_id,
body,
request.headers.get("idempotency-key"),
settings,
)
@app.get("/api/v1/chats/{chat_id}/messages")
async def list_messages(chat_id: str, request: Request):
user = await _current_user(request)
limit = logic.parse_limit(request.query_params.get("limit"))
return await logic.list_messages(user["id"], chat_id, limit, request.query_params.get("cursor"))
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=201)
async def upload(chat_id: str, request: Request):
user = await _current_user(request)
payload = await logic.upload_attachment(
user["id"],
chat_id,
request.query_params.get("filename"),
request.headers.get("content-type"),
request.headers.get("content-length"),
request.stream(),
settings,
)
return JSONResponse(status_code=201, content=payload)
@app.get("/api/v1/attachments/{attachment_id}")
async def attachment_meta(attachment_id: str, request: Request):
user = await _current_user(request)
return await logic.get_attachment(user["id"], attachment_id)
@app.get("/api/v1/attachments/{attachment_id}/content")
async def attachment_content(attachment_id: str, request: Request):
user = await _current_user(request)
data, media = await logic.download_attachment(
user["id"],
attachment_id,
request.query_params.get("variant"),
settings,
)
return Response(content=data, media_type=media, headers={"Content-Length": str(len(data))})