feat(cloud-api): compose control plane services

apps/cloud-api/cloud_api/app.py

@@ -2,21 +2,54 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from contextlib import asynccontextmanager
+from dataclasses import dataclass
+from typing import Any
 
 from fastapi import FastAPI
 
 from cloud.auth import create_auth_provider
+from cloud.config import CloudConfig
 from cloud.control_config import (
     CloudControlConfig,
     load_control_config,
     validate_control_config,
 )
 from cloud.database import CloudDatabase
+from cloud.internal_api.api import create_internal_router
+from cloud.plugins import PluginRegistry
+from cloud.pool import DevicePool
+from cloud.scheduler import TaskScheduler
+from cloud.sdk.api import create_cloud_router
 
 
 DatabaseFactory = Callable[[CloudControlConfig], CloudDatabase]
 
 
+class _RepositoryProxy:
+    def __init__(self) -> None:
+        self._target: Any | None = None
+
+    def bind(self, target: Any) -> None:
+        self._target = target
+
+    def unbind(self) -> None:
+        self._target = None
+
+    def __getattr__(self, name: str) -> Any:
+        if self._target is None:
+            raise RuntimeError("cloud repository is not available outside app lifespan")
+        return getattr(self._target, name)
+
+
+@dataclass(frozen=True)
+class CloudApplicationServices:
+    repository: _RepositoryProxy
+    pool: DevicePool
+    scheduler: TaskScheduler
+    plugin_registry: PluginRegistry
+    auth_provider: Any
+
+
 def create_app(
     *,
     config: CloudControlConfig | None = None,
@@ -30,19 +63,53 @@ def create_app(
         control_config.credentials,
         allow_insecure_anonymous=control_config.allow_insecure_anonymous,
     )
+    repository = _RepositoryProxy()
+    domain_config = CloudConfig(
+        lease_duration_seconds=control_config.lease_duration_seconds,
+    )
+    pool = DevicePool(repository, domain_config)  # type: ignore[arg-type]
+    scheduler = TaskScheduler(pool, repository, domain_config)  # type: ignore[arg-type]
+    plugin_registry = PluginRegistry(repository)  # type: ignore[arg-type]
+    services = CloudApplicationServices(
+        repository=repository,
+        pool=pool,
+        scheduler=scheduler,
+        plugin_registry=plugin_registry,
+        auth_provider=auth_provider,
+    )
 
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         database = build_database(control_config)
+        repository.bind(database.repository)
         app.state.cloud_config = control_config
         app.state.database = database
-        app.state.auth_provider = auth_provider
+        app.state.cloud_services = services
         try:
             yield
         finally:
-            database.close()
+            try:
+                database.close()
+            finally:
+                repository.unbind()
 
-    return FastAPI(title="Device Cloud API", lifespan=lifespan)
+    app = FastAPI(title="Device Cloud API", lifespan=lifespan)
+    app.include_router(
+        create_cloud_router(
+            pool=pool,
+            scheduler=scheduler,
+            plugin_registry=plugin_registry,
+            auth_provider=auth_provider,
+        )
+    )
+    app.include_router(
+        create_internal_router(
+            pool=pool,
+            auth_provider=auth_provider,
+            lease_duration_seconds=control_config.lease_duration_seconds,
+        )
+    )
+    return app
 
 
 def _default_database_factory(config: CloudControlConfig) -> CloudDatabase: