Files
mtusi2026lab6/app/main.py

121 lines
4.4 KiB
Python

"""Сборка FastAPI приложения и подключение обязательных хранилищ."""
from __future__ import annotations
from contextlib import asynccontextmanager
from fastapi import FastAPI
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
from sqlalchemy import text
from .api import errors
from .api.deps import Services
from .api.middleware import RequestContext
from .api.routers import attachments, auth, chats, health, messages, users
from .config import load_settings
from .db import RedisSessionStore, create_engine, create_redis, create_session_factory
from .observability import get_metrics, initialize_observability
from .observability.logging import safe_extra
from .repositories import AttachmentRepository, ChatRepository, MessageRepository, UserRepository
from .services.attachments import AttachmentService
from .services.chats import ChatService
from .services.messages import MessageService
from .services.users import UserService
from .storage import S3Storage
import logging
logger = logging.getLogger('app')
DESCRIPTION = 'PostgreSQL хранит задания, RabbitMQ доставляет их worker, S3 хранит изображения.'
def create_app() -> FastAPI:
telemetry = initialize_observability('messenger-api')
get_metrics()
@asynccontextmanager
async def lifespan(application: FastAPI):
application.state.ready = False
settings = load_settings()
engine = create_engine(settings.database_url)
SQLAlchemyInstrumentor().instrument(engine=engine.sync_engine)
redis = create_redis(settings.redis_url)
storage = S3Storage(
endpoint=settings.s3_endpoint,
access_key=settings.s3_access_key_id,
secret_key=settings.s3_secret_access_key,
bucket=settings.s3_bucket,
region=settings.s3_region,
)
try:
async with engine.connect() as connection:
await connection.execute(text('SELECT 1'))
session_store = RedisSessionStore(redis, settings.session_ttl_seconds)
await session_store.ping()
await storage.ping()
session_factory = create_session_factory(engine)
user_repository = UserRepository(session_factory)
chat_repository = ChatRepository(session_factory)
message_repository = MessageRepository(session_factory)
attachment_repository = AttachmentRepository(session_factory)
application.state.services = Services(
attachments=AttachmentService(
attachment_repository,
storage,
settings.max_upload_bytes,
settings.max_image_pixels,
settings.job_max_attempts,
),
users=UserService(user_repository),
chats=ChatService(chat_repository),
messages=MessageService(message_repository),
sessions=session_store,
)
application.state.engine = engine
application.state.redis = redis
application.state.storage = storage
application.state.ready = True
logger.info(
'application started',
extra=safe_extra(
'api.startup', storage='postgres+s3', redis_sessions=True,
async_attachments=True,
),
)
yield
finally:
application.state.ready = False
await redis.aclose()
await engine.dispose()
logger.info('application stopped', extra=safe_extra('api.shutdown'))
telemetry.shutdown()
api = FastAPI(
title='MTUSI Messenger. LR 6',
version='1.6.0',
description=DESCRIPTION,
lifespan=lifespan,
)
api.router.redirect_slashes = False
api.state.ready = False
api.add_middleware(RequestContext)
errors.install(api)
for router in (
health.router,
users.router,
auth.router,
chats.router,
messages.router,
attachments.router,
):
api.include_router(router)
FastAPIInstrumentor.instrument_app(
api,
excluded_urls='/health/live,/health/ready',
)
return api
app = create_app()