✨ Adds RPC interface for containers routes

packages/service-library/src/servicelib/rabbitmq/rpc_interfaces/dynamic_sidecar/container_extensions.py

@@ -0,0 +1,84 @@
+import logging
+
+from models_library.projects_nodes_io import NodeID
+from models_library.rabbitmq_basic_types import RPCMethodName
+from models_library.services import ServiceOutput
+from pydantic import TypeAdapter
+
+from ....logging_utils import log_decorator
+from ... import RabbitMQRPCClient
+from ._utils import get_rpc_namespace
+
+_logger = logging.getLogger(__name__)
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def toggle_ports_io(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    node_id: NodeID,
+    enable_outputs: bool,
+    enable_inputs: bool
+) -> None:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("toggle_ports_io"),
+        enable_outputs=enable_outputs,
+        enable_inputs=enable_inputs,
+    )
+    assert result is None  # nosec
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def create_output_dirs(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    node_id: NodeID,
+    outputs_labels: dict[str, ServiceOutput]
+) -> None:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("create_output_dirs"),
+        outputs_labels=outputs_labels,
+    )
+    assert result is None  # nosec
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def attach_container_to_network(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    node_id: NodeID,
+    container_id: str,
+    network_id: str,
+    network_aliases: list[str]
+) -> None:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("attach_container_to_network"),
+        container_id=container_id,
+        network_id=network_id,
+        network_aliases=network_aliases,
+    )
+    assert result is None  # nosec
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def detach_container_from_network(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    node_id: NodeID,
+    container_id: str,
+    network_id: str
+) -> None:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("detach_container_from_network"),
+        container_id=container_id,
+        network_id=network_id,
+    )
+    assert result is None  # nosec

services/dynamic-sidecar/src/simcore_service_dynamic_sidecar/api/rest/_dependencies.py

@@ -1,7 +1,5 @@
-""" Free functions to inject dependencies in routes handlers
-"""
+"""Free functions to inject dependencies in routes handlers"""
 
-from asyncio import Lock
 from typing import Annotated, cast
 
 from fastapi import Depends, FastAPI, Request
@@ -10,84 +8,37 @@
 from servicelib.rabbitmq._client_rpc import RabbitMQRPCClient
 
 from ...core import rabbitmq
-from ...core.settings import ApplicationSettings
 from ...models.schemas.application_health import ApplicationHealth
-from ...models.shared_store import SharedStore
-from ...modules.inputs import InputsState
-from ...modules.mounted_fs import MountedVolumes
-from ...modules.outputs import OutputsContext, OutputsManager
 from ...modules.prometheus_metrics import UserServicesMetrics
 
 
 def get_application(request: Request) -> FastAPI:
     return cast(FastAPI, request.app)
 
 
-def get_app_state(request: Request) -> State:
+def _get_app_state(request: Request) -> State:
     return cast(State, request.app.state)
 
 
 def get_application_health(
-    app_state: Annotated[State, Depends(get_app_state)]
+    app_state: Annotated[State, Depends(_get_app_state)],
 ) -> ApplicationHealth:
     return cast(ApplicationHealth, app_state.application_health)
 
 
-def get_settings(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> ApplicationSettings:
-    return cast(ApplicationSettings, app_state.settings)
-
-
-def get_shared_store(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> SharedStore:
-    return cast(SharedStore, app_state.shared_store)
-
-
-def get_mounted_volumes(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> MountedVolumes:
-    return cast(MountedVolumes, app_state.mounted_volumes)
-
-
-def get_container_restart_lock(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> Lock:
-    return cast(Lock, app_state.container_restart_lock)
-
-
-def get_outputs_manager(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> OutputsManager:
-    return cast(OutputsManager, app_state.outputs_manager)
-
-
-def get_outputs_context(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> OutputsContext:
-    return cast(OutputsContext, app_state.outputs_context)
-
-
-def get_inputs_state(
-    app_state: Annotated[State, Depends(get_app_state)]
-) -> InputsState:
-    return cast(InputsState, app_state.inputs_state)
-
-
 def get_user_services_metrics(
-    app_state: Annotated[State, Depends(get_app_state)]
+    app_state: Annotated[State, Depends(_get_app_state)],
 ) -> UserServicesMetrics:
     return cast(UserServicesMetrics, app_state.user_service_metrics)
 
 
 def get_rabbitmq_client(
-    app: Annotated[FastAPI, Depends(get_application)]
+    app: Annotated[FastAPI, Depends(get_application)],
 ) -> RabbitMQClient:
     return rabbitmq.get_rabbitmq_client(app)
 
 
 def get_rabbitmq_rpc_server(
-    app: Annotated[FastAPI, Depends(get_application)]
+    app: Annotated[FastAPI, Depends(get_application)],
 ) -> RabbitMQRPCClient:
     return rabbitmq.get_rabbitmq_rpc_server(app)