Function lifespan

src/web/app.py:56–146

(app: FastAPI)

    @asynccontextmanager
    async def lifespan(app: FastAPI):
        import asyncio

        from ..core.auto_registration import (
            AutoRegistrationCoordinator,
            register_auto_registration_coordinator,
        )
        from ..core.db_logs import cleanup_database_logs
        from ..database.init_db import initialize_database
        from .auto_quick_refresh_scheduler import auto_quick_refresh_scheduler
        from .routes.registration import run_auto_registration_batch, recover_interrupted_registration_tasks

        try:
            initialize_database()
        except Exception as exc:
            logger.warning("Database init failed: %s", exc)

        loop = asyncio.get_running_loop()
        task_manager.set_loop(loop)

        recovered_registration_tasks = await asyncio.to_thread(recover_interrupted_registration_tasks)
        if recovered_registration_tasks.get("running_recovered") or recovered_registration_tasks.get("pending_recovered"):
            logger.warning(
                "Recovered interrupted registration tasks on startup: running=%s pending=%s",
                recovered_registration_tasks.get("running_recovered", 0),
                recovered_registration_tasks.get("pending_recovered", 0),
            )

        global auto_registration_coordinator
        auto_registration_coordinator = AutoRegistrationCoordinator(
            trigger_callback=run_auto_registration_batch,
        )
        register_auto_registration_coordinator(auto_registration_coordinator)
        auto_registration_coordinator.start()

        async def run_log_cleanup_once() -> None:
            try:
                result = await asyncio.to_thread(cleanup_database_logs)
                logger.info(
                    "Log cleanup done: deleted=%s remaining=%s",
                    result.get("deleted_total", 0),
                    result.get("remaining", 0),
                )
            except Exception as exc:
                logger.warning("Log cleanup failed: %s", exc)

        async def periodic_log_cleanup() -> None:
            while True:
                try:
                    await asyncio.sleep(3600)
                    await run_log_cleanup_once()
                except asyncio.CancelledError:
                    break
                except Exception as exc:
                    logger.warning("Periodic log cleanup failed: %s", exc)

        await run_log_cleanup_once()
        app.state.log_cleanup_task = asyncio.create_task(periodic_log_cleanup())