import logging from collections.abc import AsyncGenerator from contextlib import asynccontextmanager import uvicorn from fastapi import Depends, FastAPI from app.core.config import Settings from app.core.database import create_db_engine, create_session_factory from app.core.instance import InstanceIdMiddleware, resolve_instance_id from app.core.lifecycle import GracefulServer, Lifecycle from app.core.redis import create_redis_client from app.core.request_capacity import acquire_request_slot, create_request_capacity from app.core.request_id import RequestIdMiddleware from app.endpoints.auth import router as auth_router from app.endpoints.attachments import router as attachments_router from app.endpoints.chats import router as chats_router from app.endpoints.health import router as health_router from app.endpoints.messages import router as messages_router from app.endpoints.users import router as users_router from app.errors.handlers import register_exception_handlers from app.storage.s3 import create_s3_storage def configure_logging(settings: Settings) -> None: logging.basicConfig( level=settings.log_level, format="%(asctime)s %(levelname)s %(name)s %(message)s", ) def create_app(settings: Settings | None = None) -> FastAPI: settings = settings or Settings() # type: ignore configure_logging(settings) engine = create_db_engine(settings) redis = create_redis_client(settings) s3 = create_s3_storage(settings.s3) if settings.s3_enabled else None @asynccontextmanager async def lifespan(_: FastAPI) -> AsyncGenerator[None]: yield if s3 is not None: await s3.aclose() await redis.aclose() await engine.dispose() application = FastAPI(title="Messenger", version="1.5.0", lifespan=lifespan) application.state.settings = settings application.state.engine = engine application.state.session_factory = create_session_factory(engine) application.state.redis = redis application.state.s3 = s3 application.state.upload_capacity = create_request_capacity( settings.s3.max_concurrent_uploads ) application.state.request_capacity = create_request_capacity(settings.max_in_flight) application.state.instance_id = resolve_instance_id(settings.instance_id) application.state.lifecycle = Lifecycle() application.add_middleware(RequestIdMiddleware) application.add_middleware( InstanceIdMiddleware, instance_id=application.state.instance_id ) register_exception_handlers(application) limited = [Depends(acquire_request_slot)] application.include_router(health_router) application.include_router(users_router, dependencies=limited) application.include_router(auth_router, dependencies=limited) application.include_router(chats_router, dependencies=limited) application.include_router(messages_router, dependencies=limited) application.include_router(attachments_router, dependencies=limited) return application def main() -> None: settings = Settings() # type: ignore application = create_app(settings) config = uvicorn.Config( application, host=settings.app_host, port=settings.app_port, log_level=settings.log_level.lower(), timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds, ) GracefulServer( config, application.state.lifecycle, settings.shutdown_drain_seconds ).run() if __name__ == "__main__": main()