rakuten-api/app/trading/main.py

"""交易服务入口：FastAPI 应用创建与生命周期管理

与抓取服务（app/scraping/main.py）分成两个进程运行，理由不是「要不要登录」
这一条，而是运行特性根本不同：

- 抓取无状态、可重试、可多开实例；这里的写操作**不可逆**，重复提交就是重复下单。
- 登录态 cookie 全局唯一，订单监控是常驻轮询；多开实例会让同一个账号被多个
  进程并发操作，也会让轮询重复触发。
- 抓取被限速最多是慢，账号被风控是封号；两者不该共用出口 IP 与请求节奏。

因此本服务只能单实例运行（或按账号分片），扩容靠抓取服务那一侧。

worker 启动条件：RAKUTEN_ORDER_GATEWAY_URL 非空。留空时本服务只跑登录态接口，
不构造任何 worker 子组件（本地 DB / 证据目录 / 出站客户端都不创建）。
"""
from __future__ import annotations

import asyncio
import logging
from contextlib import asynccontextmanager

from fastapi import FastAPI

from app.shared.api import register_exception_handlers
from app.shared.config import get_settings
from app.shared.logging_setup import configure_logging
from app.shared.telemetry import instrument_app, setup_telemetry, shutdown_telemetry
from app.trading.api.routes.auth import router as auth_router
from app.trading.api.routes.health import router as health_router
from app.trading.container import TradingContainer
from app.trading.services.auth_session import AuthSession

logger = logging.getLogger(__name__)


def build_container() -> TradingContainer:
    """构建交易服务容器：登录态会话始终构造，worker 仅在配置了网关 URL 时构造"""
    settings = get_settings()
    container = TradingContainer(settings=settings, auth_session=AuthSession(settings))

    if settings.order_gateway_url:
        # 延迟 import：未配置网关 URL 时不加载 worker 模块（也就不会拉起 aiosqlite 等）
        from app.trading.worker.client import GatewayClient
        from app.trading.worker.evidence import EvidenceStore
        from app.trading.worker.local_db import LocalDB
        from app.trading.worker.runner import WorkerRunner
        from app.trading.worker.site_interact import SiteInteractor

        client = GatewayClient(
            settings.order_gateway_url,
            settings.bearer_token,
            timeout=max(60.0, settings.lease_max_wait_seconds + 10),
        )
        local_db = LocalDB(settings.trading_db_path_resolved)
        evidence = EvidenceStore(settings.evidence_path)
        site = SiteInteractor(auth_session=container.auth_session, settings=settings)
        runner = WorkerRunner(
            settings=settings,
            gateway_client=client,
            local_db=local_db,
            evidence=evidence,
            site=site,
        )
        container.worker_client = client
        container.worker_local_db = local_db
        container.worker_evidence = evidence
        container.worker_site = site
        container.worker_runner = runner

    return container


@asynccontextmanager
async def lifespan(app: FastAPI):
    """应用生命周期管理：登录态会话 + 可选 worker"""
    container = build_container()
    app.state.container = container

    configure_logging(container.settings)
    # 与抓取侧同样：必须在创建 httpx 客户端之前 setup。
    setup_telemetry(container.settings, service_name="rakuten-trading")
    logger.info(
        "交易服务启动：%s:%s",
        container.settings.trading_host,
        container.settings.trading_port,
    )
    logger.info("当前环境：%s", container.settings.app_env)

    await container.auth_session.start()

    worker_task: asyncio.Task | None = None
    if container.worker_runner is not None:
        # 顺序：先开本地 DB 与 SiteInteractor（worker 写证据/发请求前要先就绪），再起后台任务
        assert container.worker_local_db is not None
        assert container.worker_client is not None
        assert container.worker_site is not None
        await container.worker_local_db.start()
        await container.worker_site.start()  # type: ignore[union-attr]
        worker_task = asyncio.create_task(
            container.worker_runner.run(), name="trading-worker"
        )
        logger.info(
            "下单 worker 已启动：worker_id=%s gateway=%s",
            container.settings.worker_id_effective,
            container.settings.order_gateway_url,
        )
    else:
        logger.info(
            "未配置 RAKUTEN_ORDER_GATEWAY_URL，下单 worker 不启动（仅登录态接口）"
        )

    try:
        yield
    finally:
        if worker_task is not None:
            container.worker_runner.stop()  # type: ignore[union-attr]
            worker_task.cancel()
            try:
                await worker_task
            except asyncio.CancelledError:
                pass
        if container.worker_site is not None:
            await container.worker_site.close()  # type: ignore[union-attr]
        if container.worker_local_db is not None:
            await container.worker_local_db.close()
        if container.worker_client is not None:
            await container.worker_client.aclose()
        await container.auth_session.close()
        shutdown_telemetry()


def create_app() -> FastAPI:
    """创建 FastAPI 应用实例，注册路由和异常处理器"""
    app = FastAPI(title="Rakuten Trading Service", lifespan=lifespan)
    app.include_router(health_router)
    app.include_router(auth_router)
    register_exception_handlers(app)
    instrument_app(app)
    return app


app = create_app()


if __name__ == "__main__":
    import uvicorn

    settings = get_settings()
    configure_logging(settings)
    uvicorn.run(
        "app.trading.main:app",
        host=settings.trading_host,
        port=settings.trading_port,
        log_config=None,
        timeout_keep_alive=120,
        # 单进程：登录态与后续的订单监控都不能有第二份
        workers=1,
    )