Files
mtusi2026lab6-fork/app/main.py
T
2026-11-22 19:55:50 +03:00

103 lines
3.8 KiB
Python

import asyncio
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.core.telemetry import HttpTelemetryMiddleware, Telemetry
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()
await asyncio.to_thread(telemetry.shutdown)
application = FastAPI(title="Messenger", version="1.6.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)
telemetry = Telemetry("messenger-api", application.state.instance_id)
telemetry.observe_pool(engine.pool)
application.state.telemetry = telemetry
application.state.lifecycle = Lifecycle()
application.add_middleware(RequestIdMiddleware)
application.add_middleware(
InstanceIdMiddleware, instance_id=application.state.instance_id
)
application.add_middleware(HttpTelemetryMiddleware, telemetry=telemetry)
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(),
access_log=False,
timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds,
)
GracefulServer(
config, application.state.lifecycle, settings.shutdown_drain_seconds
).run()
if __name__ == "__main__":
main()