forked from mtusi2026/mtusi2026lab4
107 lines
4.5 KiB
Python
107 lines
4.5 KiB
Python
import asyncio
|
|
import logging
|
|
import uuid
|
|
from contextlib import asynccontextmanager, suppress
|
|
|
|
from fastapi import FastAPI, HTTPException, Request
|
|
from fastapi.exceptions import RequestValidationError
|
|
from fastapi.responses import JSONResponse
|
|
from pathlib import Path
|
|
from sqlalchemy import text
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
|
|
from app.api.auth import router as auth_router
|
|
from app.api.users import router as users_router
|
|
from app.api.chats import router as chats_router
|
|
from app.api.messages import router as messages_router
|
|
from app.api.attachments import router as attachments_router
|
|
from app.core.config import settings
|
|
from app.db.session import engine
|
|
from app.services.object_storage import client as s3_client
|
|
from app.services.attachment_cleanup import cleanup_expired_uploads
|
|
|
|
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s %(message)s")
|
|
logger = logging.getLogger(__name__)
|
|
async def attachment_cleanup_loop():
|
|
while True:
|
|
try:
|
|
# Synchronous boto3/SQLAlchemy I/O must not block the event loop.
|
|
await asyncio.to_thread(cleanup_expired_uploads)
|
|
except Exception:
|
|
logger.exception("Attachment cleanup worker iteration failed")
|
|
await asyncio.sleep(settings.attachment_cleanup_interval_seconds)
|
|
|
|
|
|
@asynccontextmanager
|
|
async def lifespan(app: FastAPI):
|
|
logger.info("Application startup instance_id=%s", settings.instance_id)
|
|
cleanup_task = asyncio.create_task(attachment_cleanup_loop())
|
|
try:
|
|
yield
|
|
finally:
|
|
cleanup_task.cancel()
|
|
with suppress(asyncio.CancelledError):
|
|
await cleanup_task
|
|
engine.dispose()
|
|
logger.info("Application shutdown instance_id=%s", settings.instance_id)
|
|
|
|
app = FastAPI(title=settings.app_name, version="1.4.0", lifespan=lifespan)
|
|
app.include_router(users_router)
|
|
app.include_router(auth_router)
|
|
app.include_router(chats_router)
|
|
app.include_router(messages_router)
|
|
app.include_router(attachments_router)
|
|
|
|
@app.middleware("http")
|
|
async def response_headers(request: Request, call_next):
|
|
request_id = str(uuid.uuid4())
|
|
request.state.request_id = request_id
|
|
try:
|
|
response = await call_next(request)
|
|
except Exception:
|
|
logger.exception("Unhandled request error; request_id=%s", request_id)
|
|
response = JSONResponse(status_code=500, content={"error": {"code": "internal_error", "message": "Unexpected error", "request_id": request_id}})
|
|
response.headers["X-Request-Id"] = request_id
|
|
response.headers["X-Instance-Id"] = settings.instance_id
|
|
response.headers["X-Content-Type-Options"] = "nosniff"
|
|
return response
|
|
|
|
@app.exception_handler(HTTPException)
|
|
async def http_exception_handler(request: Request, exc: HTTPException):
|
|
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
|
code = {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"}.get(exc.status_code, "internal_error")
|
|
headers = dict(exc.headers or {})
|
|
headers["X-Request-Id"] = request_id
|
|
headers["X-Instance-Id"] = settings.instance_id
|
|
return JSONResponse(status_code=exc.status_code, content={"error": {"code": code, "message": exc.detail if isinstance(exc.detail, str) else "Request failed", "request_id": request_id}}, headers=headers)
|
|
|
|
@app.exception_handler(RequestValidationError)
|
|
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
|
request_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
|
return JSONResponse(status_code=400, content={"error": {"code": "invalid_request", "message": "Validation error", "request_id": request_id}}, headers={"X-Request-Id": request_id, "X-Instance-Id": settings.instance_id})
|
|
|
|
@app.get("/health/live")
|
|
def liveness():
|
|
return {"status": "ok"}
|
|
|
|
DRAIN_FILE = Path("/tmp/api-draining")
|
|
@app.get("/health/ready")
|
|
def readiness():
|
|
if DRAIN_FILE.exists():
|
|
raise HTTPException(
|
|
status_code=503,
|
|
detail="Instance is draining",
|
|
)
|
|
|
|
try:
|
|
with engine.connect() as connection:
|
|
connection.execute(text("SELECT 1"))
|
|
s3_client().head_bucket(Bucket=settings.s3_bucket)
|
|
return {"status": "ok"}
|
|
except Exception:
|
|
logger.exception("PostgreSQL or S3 readiness check failed")
|
|
raise HTTPException(
|
|
status_code=503,
|
|
detail="Required storage unavailable",
|
|
) from None
|