finished adding RPC interface

Author: Andrei Neagu

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

@@ -1,6 +1,8 @@
 import logging
+from typing import Any
 
 from models_library.api_schemas_directorv2.dynamic_services import ContainersComposeSpec
+from models_library.api_schemas_dynamic_sidecar.containers import ActivityInfoOrNone
 from models_library.projects_nodes_io import NodeID
 from models_library.rabbitmq_basic_types import RPCMethodName
 from pydantic import TypeAdapter
@@ -26,3 +28,60 @@ async def create_compose_spec(
         containers_compose_spec=containers_compose_spec,
     )
     assert result is None  # nosec
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def containers_docker_inspect(
+    rabbitmq_rpc_client: RabbitMQRPCClient,
+    *,
+    node_id: NodeID,
+    only_status: bool,
+) -> dict[str, Any]:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("containers_docker_inspect"),
+        only_status=only_status,
+    )
+    assert isinstance(result, dict)  # nosec
+    return result
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def get_containers_activity(
+    rabbitmq_rpc_client: RabbitMQRPCClient, *, node_id: NodeID
+) -> ActivityInfoOrNone:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("get_containers_activity"),
+    )
+    return TypeAdapter(ActivityInfoOrNone).validate_python(result) if result else None
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def get_containers_name(
+    rabbitmq_rpc_client: RabbitMQRPCClient, *, node_id: NodeID, filters: str
+) -> str:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("get_containers_name"),
+        filters=filters,
+    )
+    assert isinstance(result, str)
+    return result
+
+
+@log_decorator(_logger, level=logging.DEBUG)
+async def inspect_container(
+    rabbitmq_rpc_client: RabbitMQRPCClient, *, node_id: NodeID, container_id: str
+) -> dict[str, Any]:
+    rpc_namespace = get_rpc_namespace(node_id)
+    result = await rabbitmq_rpc_client.request(
+        rpc_namespace,
+        TypeAdapter(RPCMethodName).validate_python("inspect_container"),
+        container_id=container_id,
+    )
+    assert isinstance(result, dict)
+    return result

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

@@ -13,7 +13,12 @@
 from servicelib.fastapi.requests_decorators import cancel_on_disconnect
 
 from ...services import containers
-from ...services.containers import ContainerIsMissingError
+from ...services.containers import (
+    ContainerIsMissingError,
+    ContainerNotFoundError,
+    InvalidFilterFormatError,
+    MissingDockerComposeDownSpecError,
+)
 
 _logger = logging.getLogger(__name__)
 
@@ -29,15 +34,15 @@
     },
 )
 @cancel_on_disconnect
-async def store_compose_spec(
+async def create_compose_spec(
     request: Request, containers_compose_spec: ContainersComposeSpec
 ):
     """
     Validates and stores the docker compose spec for the user services.
     """
     _ = request
 
-    return await containers.create_compose_spec(
+    await containers.create_compose_spec(
         app=request.app, containers_compose_spec=containers_compose_spec
     )
 
@@ -108,7 +113,12 @@ async def get_containers_name(
     """
     _ = request
 
-    return await containers.get_containers_name(app=request.app, filters=filters)
+    try:
+        return await containers.get_containers_name(app=request.app, filters=filters)
+    except InvalidFilterFormatError as e:
+        raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, detail=f"{e}") from e
+    except (MissingDockerComposeDownSpecError, ContainerNotFoundError) as e:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"{e}") from e
 
 
 @router.get(

services/dynamic-sidecar/src/simcore_service_dynamic_sidecar/api/rpc/_containers.py

@@ -1,5 +1,10 @@
+from typing import Any
+
 from fastapi import FastAPI
 from models_library.api_schemas_directorv2.dynamic_services import ContainersComposeSpec
+from models_library.api_schemas_dynamic_sidecar.containers import (
+    ActivityInfoOrNone,
+)
 from servicelib.rabbitmq import RPCRouter
 
 from ...core.validation import InvalidComposeSpecError
@@ -17,3 +22,25 @@ async def create_compose_spec(
     await containers.create_compose_spec(
         app, containers_compose_spec=containers_compose_spec
     )
+
+
+@router.expose()
+async def containers_docker_inspect(
+    app: FastAPI, *, only_status: bool
+) -> dict[str, Any]:
+    return await containers.containers_docker_inspect(app, only_status=only_status)
+
+
+@router.expose()
+async def get_containers_activity(app: FastAPI) -> ActivityInfoOrNone:
+    return await containers.get_containers_activity(app=app)
+
+
+@router.expose()
+async def get_containers_name(app: FastAPI, *, filters: str) -> str | dict[str, Any]:
+    return await containers.get_containers_name(app=app, filters=filters)
+
+
+@router.expose()
+async def inspect_container(app: FastAPI, *, container_id: str) -> dict[str, Any]:
+    return await containers.inspect_container(app=app, container_id=container_id)

services/dynamic-sidecar/src/simcore_service_dynamic_sidecar/services/containers.py

@@ -5,7 +5,7 @@
 from aiodocker import DockerError
 from common_library.errors_classes import OsparcErrorMixin
 from common_library.json_serialization import json_loads
-from fastapi import FastAPI, HTTPException, status
+from fastapi import FastAPI
 from models_library.api_schemas_directorv2.dynamic_services import ContainersComposeSpec
 from models_library.api_schemas_dynamic_sidecar.containers import (
     ActivityInfo,
@@ -38,7 +38,7 @@ async def create_compose_spec(
     app: FastAPI,
     *,
     containers_compose_spec: ContainersComposeSpec,
-):
+) -> None:
     settings: ApplicationSettings = app.state.settings
     shared_store: SharedStore = app.state.shared_store
     mounted_volumes: MountedVolumes = app.state.mounted_volumes
@@ -140,6 +140,24 @@ async def get_containers_activity(app: FastAPI) -> ActivityInfoOrNone:
     return ActivityInfo(seconds_inactive=_INACTIVE_FOR_LONG_TIME)
 
 
+class BaseGetNameError(OsparcErrorMixin, RuntimeError):
+    pass
+
+
+class InvalidFilterFormatError(BaseGetNameError):
+    msg_template: str = "Provided filters, could not parsed {filters}"
+
+
+class MissingDockerComposeDownSpecError(BaseGetNameError):
+    msg_template: str = "No spec for docker compose down was found"
+
+
+class ContainerNotFoundError(BaseGetNameError):
+    msg_template: str = (
+        "No container found for network={network_name} and exclude={exclude}"
+    )
+
+
 async def get_containers_name(app: FastAPI, *, filters: str) -> str | dict[str, Any]:
     """
     Searches for the container's name given the network
@@ -155,19 +173,13 @@ async def get_containers_name(app: FastAPI, *, filters: str) -> str | dict[str,
 
     filters_dict: dict[str, str] = json_loads(filters)
     if not isinstance(filters_dict, dict):
-        raise HTTPException(
-            status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=f"Provided filters, could not parsed {filters_dict}",
-        )
+        raise InvalidFilterFormatError(filters=filters_dict)
     network_name: str | None = filters_dict.get("network")
     exclude: str | None = filters_dict.get("exclude")
 
     stored_compose_content = shared_store.compose_spec
     if stored_compose_content is None:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND,
-            detail="No spec for docker compose down was found",
-        )
+        raise MissingDockerComposeDownSpecError
 
     compose_spec = parse_compose_spec(stored_compose_content)
 
@@ -184,10 +196,7 @@ async def get_containers_name(app: FastAPI, *, filters: str) -> str | dict[str,
             break
 
     if container_name is None:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND,
-            detail=f"No container found for network={network_name}",
-        )
+        raise ContainerNotFoundError(network_name=network_name, exclude=exclude)
 
     return f"{container_name}"