Files
mtusi2026lab3-fork/app/main.py
T
2026-11-02 20:05:33 +03:00

121 lines
4.6 KiB
Python

"""Сборка приложения FastAPI: зависимости, миграции, обработчики ошибок."""
import asyncio
import uuid
from contextlib import asynccontextmanager
from typing import Optional
from fastapi import FastAPI, Request
from fastapi.exceptions import RequestValidationError
from sqlalchemy.exc import InterfaceError, OperationalError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
from starlette.exceptions import HTTPException as StarletteHTTPException
from .cache import create_cache
from .config import Settings
from .db import create_engine, create_sessionmaker
from .errors import ApiError, error_response
from .logging_setup import get_logger, setup_logging
from .middleware import RequestContextMiddleware
from .migrate import check_schema
from .routes import api, router
DB_UNAVAILABLE = (
OperationalError,
InterfaceError,
PoolTimeoutError,
OSError,
asyncio.TimeoutError,
)
def create_app(settings: Optional[Settings] = None) -> FastAPI:
"""Создать приложение FastAPI с заданными настройками."""
settings = settings or Settings.from_env()
setup_logging(settings.log_level)
@asynccontextmanager
async def lifespan(app: FastAPI):
"""Старт: кэш, движок, проверка версии схемы. Остановка: закрыть соединения."""
get_logger().info(
"config env=%s pool=%d+%d ttl=%ds store=%s cache=%s",
settings.env,
settings.db_pool_size,
settings.db_max_overflow,
settings.session_ttl_seconds,
settings.session_store,
"redis" if settings.cache_url else "off",
)
app.state.cache = create_cache(settings)
engine = create_engine(settings)
app.state.engine = engine
app.state.sessionmaker = create_sessionmaker(engine)
try:
await check_schema(engine)
app.state.ready = True
get_logger().info("startup: приложение готово")
yield
finally:
app.state.ready = False
await app.state.cache.close()
await engine.dispose()
get_logger().info("shutdown: соединения с БД закрыты")
app = FastAPI(title="Messenger API", version="1.3.0", lifespan=lifespan)
app.state.settings = settings
app.state.ready = False
app.router.redirect_slashes = False
app.state.instance_id = uuid.uuid4().hex
app.add_middleware(RequestContextMiddleware, instance_id=app.state.instance_id)
@app.exception_handler(ApiError)
async def handle_api_error(request: Request, exc: ApiError):
"""ApiError -> ответ в общем формате."""
return error_response(
request.state.request_id, exc.status, exc.code, exc.message, exc.headers
)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
"""404 и 405 -> ответ в общем формате."""
if exc.status_code == 404:
return error_response(
request.state.request_id, 404, "not_found", "Объект не найден"
)
headers = dict(exc.headers) if exc.headers else None
return error_response(
request.state.request_id,
exc.status_code,
"invalid_request",
"Запрос не поддерживается",
headers,
)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
"""Ошибки разбора параметров -> 400."""
return error_response(
request.state.request_id,
400,
"invalid_request",
"Неверные параметры запроса",
)
async def handle_db_unavailable(request: Request, exc: Exception):
"""Недоступная БД или пул -> 503 без деталей."""
get_logger().error(
"db_unavailable request_id=%s type=%s",
request.state.request_id,
type(exc).__name__,
)
return error_response(
request.state.request_id, 503, "unavailable", "Сервис временно недоступен"
)
for error_type in DB_UNAVAILABLE:
app.add_exception_handler(error_type, handle_db_unavailable)
app.include_router(router)
app.include_router(api)
return app