98 lines
3.6 KiB
Python
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()
|