Files
mtusi2026lab3/src/app/main.py
T

98 lines
3.6 KiB
Python

import asyncio
import logging
from contextlib import asynccontextmanager
from fastapi import FastAPI
from fastapi.exceptions import RequestValidationError
from redis.exceptions import RedisError
from sqlalchemy.exc import InterfaceError, OperationalError, ProgrammingError
from sqlalchemy.exc import TimeoutError as SATimeout
from starlette.exceptions import HTTPException
from app.api import api_router
from app.api.health import router as health_router
from app.config import load_settings
from app.db import build_engine, build_session_factory, is_dependency_error
from app.errors import AppError, handle_app_error, handle_dependency, handle_http_error, handle_validation_error
from app.migrate import apply_migrations, wait_for_database, wait_for_schema
from app.middleware import request_context
from app.runtime import configure
from app.security import init_security
from app.sessions import build_redis
logger = logging.getLogger("app")
async def open_stores(engine, redis, settings) -> None:
await wait_for_database(engine)
for attempt in range(40):
try:
await redis.ping()
break
except Exception as exc:
if not is_dependency_error(exc):
logger.error("redis probe failed type=%s", type(exc).__name__)
raise SystemExit("redis probe failed") from None
logger.warning("redis not ready type=%s attempt=%s", type(exc).__name__, attempt + 1)
if attempt == 39:
raise SystemExit("redis is not ready") from None
await asyncio.sleep(0.5)
if settings.run_migrations:
try:
applied = await apply_migrations(engine, settings.migrations_dir)
logger.info("migrations newly_applied=%s", applied)
except ProgrammingError as exc:
sqlstate = getattr(getattr(exc, "orig", None), "sqlstate", "")
logger.error("migration rejected type=%s sqlstate=%s", type(exc).__name__, sqlstate)
raise SystemExit("migration failed") from None
else:
await wait_for_schema(engine, settings.migrations_dir)
@asynccontextmanager
async def lifespan(app: FastAPI):
settings = load_settings()
init_security()
engine = build_engine(settings)
redis = build_redis(settings)
app.state.engine = engine
app.state.redis = redis
app.state.settings = settings
app.state.instance_id = settings.instance_id
app.state.accepting = False
try:
await open_stores(engine, redis, settings)
configure(build_session_factory(engine), redis, settings)
app.state.accepting = True
logger.info(
"ready env=%s instance_id=%s session_ttl_seconds=%s db_pool=%s",
settings.env,
settings.instance_id,
settings.session_ttl_seconds,
settings.db_pool_size,
)
yield
finally:
app.state.accepting = False
logger.info("shutdown: new requests are no longer accepted")
await redis.aclose()
await engine.dispose()
def create_app() -> FastAPI:
app = FastAPI(title="MTUSI Messenger", version="1.3.0", lifespan=lifespan)
app.state.instance_id = "starting"
app.state.accepting = False
app.add_exception_handler(AppError, handle_app_error)
app.add_exception_handler(RequestValidationError, handle_validation_error)
app.add_exception_handler(HTTPException, handle_http_error)
for cls in (OperationalError, InterfaceError, SATimeout, RedisError):
app.add_exception_handler(cls, handle_dependency)
app.middleware("http")(request_context)
app.include_router(health_router)
app.include_router(api_router)
return app
app = create_app()