bakery-ia/services/orchestrator/app/main.py

# ================================================================
# services/orchestrator/app/main.py
# ================================================================
"""
Orchestrator Service - FastAPI Application
Automated orchestration of forecasting, production, and procurement workflows
"""

from fastapi import FastAPI, Request
from sqlalchemy import text
from app.core.config import settings
from app.core.database import database_manager
from shared.service_base import StandardFastAPIService


class OrchestratorService(StandardFastAPIService):
    """Orchestrator Service with standardized setup"""

    expected_migration_version = "00001"

    async def verify_migrations(self):
        """Verify database schema matches the latest migrations"""
        try:
            async with self.database_manager.get_session() as session:
                result = await session.execute(text("SELECT version_num FROM alembic_version"))
                version = result.scalar()
                if version != self.expected_migration_version:
                    self.logger.error(f"Migration version mismatch: expected {self.expected_migration_version}, got {version}")
                    raise RuntimeError(f"Migration version mismatch: expected {self.expected_migration_version}, got {version}")
                self.logger.info(f"Migration verification successful: {version}")
        except Exception as e:
            self.logger.error(f"Migration verification failed: {e}")
            raise

    def __init__(self):
        # Define expected database tables for health checks
        orchestrator_expected_tables = [
            'orchestration_runs'
        ]

        super().__init__(
            service_name="orchestrator-service",
            app_name=settings.APP_NAME,
            description=settings.DESCRIPTION,
            version=settings.VERSION,
            api_prefix="",  # Empty because RouteBuilder already includes /api/v1
            database_manager=database_manager,
            expected_tables=orchestrator_expected_tables
        )

    async def on_startup(self, app: FastAPI):
        """Custom startup logic for orchestrator service"""
        self.logger.info("Orchestrator Service starting up...")

        # Initialize orchestrator scheduler service
        from app.services.orchestrator_service import OrchestratorSchedulerService
        scheduler_service = OrchestratorSchedulerService(settings)
        await scheduler_service.start()
        app.state.scheduler_service = scheduler_service
        self.logger.info("Orchestrator scheduler service started")

    async def on_shutdown(self, app: FastAPI):
        """Custom shutdown logic for orchestrator service"""
        self.logger.info("Orchestrator Service shutting down...")

        # Stop scheduler service
        if hasattr(app.state, 'scheduler_service'):
            await app.state.scheduler_service.stop()
            self.logger.info("Orchestrator scheduler service stopped")

    def get_service_features(self):
        """Return orchestrator-specific features"""
        return [
            "automated_orchestration",
            "forecasting_integration",
            "production_scheduling",
            "procurement_planning",
            "notification_dispatch",
            "leader_election",
            "retry_mechanism",
            "circuit_breaker"
        ]


# Create service instance
service = OrchestratorService()

# Create FastAPI app with standardized setup
app = service.create_app()

# Setup standard endpoints (health, readiness, metrics)
service.setup_standard_endpoints()

# Include routers
# BUSINESS: Orchestration operations
from app.api.orchestration import router as orchestration_router
from app.api.dashboard import router as dashboard_router
from app.api.enterprise_dashboard import router as enterprise_dashboard_router
from app.api.internal import router as internal_router
service.add_router(orchestration_router)
service.add_router(dashboard_router)
service.add_router(enterprise_dashboard_router)
service.add_router(internal_router)

# Add enterprise dashboard service to dependencies
from app.services.enterprise_dashboard_service import EnterpriseDashboardService
from shared.clients import (
    get_tenant_client,
    get_forecast_client,
    get_production_client,
    get_sales_client,
    get_inventory_client,
    get_procurement_client,
    get_distribution_client
)

def get_enterprise_dashboard_service() -> EnterpriseDashboardService:
    tenant_client = get_tenant_client(settings)
    forecast_client = get_forecast_client(settings)
    production_client = get_production_client(settings)
    sales_client = get_sales_client(settings)
    inventory_client = get_inventory_client(settings)
    distribution_client = get_distribution_client(settings)
    procurement_client = get_procurement_client(settings)

    return EnterpriseDashboardService(
        tenant_client=tenant_client,
        forecast_client=forecast_client,
        production_client=production_client,
        sales_client=sales_client,
        inventory_client=inventory_client,
        distribution_client=distribution_client,
        procurement_client=procurement_client
    )

# INTERNAL: Service-to-service endpoints
from app.api import internal_demo
service.add_router(internal_demo.router)


@app.middleware("http")
async def logging_middleware(request: Request, call_next):
    """Add request logging middleware"""
    import time

    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time

    service.logger.info("HTTP request processed",
                method=request.method,
                url=str(request.url),
                status_code=response.status_code,
                process_time=round(process_time, 4))

    return response


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(
        "main:app",
        host="0.0.0.0",
        port=8000,
        reload=settings.DEBUG
    )