extracted common containers interface

Author: Andrei Neagu

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

@@ -1,36 +1,19 @@
 # pylint: disable=too-many-arguments
 
 import logging
-from asyncio import Lock
-from typing import Annotated, Any, Final
+from typing import Any
 
-from aiodocker import DockerError
-from common_library.json_serialization import json_loads
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, HTTPException
 from fastapi import Path as PathParam
 from fastapi import Query, Request, status
 from models_library.api_schemas_directorv2.dynamic_services import ContainersComposeSpec
 from models_library.api_schemas_dynamic_sidecar.containers import (
-    ActivityInfo,
     ActivityInfoOrNone,
 )
-from pydantic import TypeAdapter, ValidationError
-from servicelib.container_utils import (
-    ContainerExecCommandFailedError,
-    ContainerExecContainerNotFoundError,
-    ContainerExecTimeoutError,
-    run_command_in_container,
-)
 from servicelib.fastapi.requests_decorators import cancel_on_disconnect
 
-from ...core.docker_utils import docker_client
-from ...core.settings import ApplicationSettings
-from ...core.validation import parse_compose_spec
-from ...models.shared_store import SharedStore
 from ...services import containers
-from ._dependencies import get_container_restart_lock, get_settings, get_shared_store
-
-_INACTIVE_FOR_LONG_TIME: Final[int] = 2**63 - 1
+from ...services.containers import ContainerIsMissingError
 
 _logger = logging.getLogger(__name__)
 
@@ -77,8 +60,6 @@ async def store_compose_spec(
 @cancel_on_disconnect
 async def containers_docker_inspect(
     request: Request,
-    shared_store: Annotated[SharedStore, Depends(get_shared_store)],
-    container_restart_lock: Annotated[Lock, Depends(get_container_restart_lock)],
     only_status: bool = Query(  # noqa: FBT001
         default=False, description="if True only show the status of the container"
     ),
@@ -88,92 +69,18 @@ async def containers_docker_inspect(
     the status of the containers is returned
     """
     _ = request
-
-    def _format_result(container_inspect: dict[str, Any]) -> dict[str, Any]:
-        if only_status:
-            container_state = container_inspect.get("State", {})
-
-            # pending is another fake state use to share more information with the frontend
-            return {
-                "Status": container_state.get("Status", "pending"),
-                "Error": container_state.get("Error", ""),
-            }
-
-        return container_inspect
-
-    async with container_restart_lock, docker_client() as docker:
-        container_names = shared_store.container_names
-
-        results = {}
-
-        for container in container_names:
-            container_instance = await docker.containers.get(container)
-            container_inspect = await container_instance.show()
-            results[container] = _format_result(container_inspect)
-
-        return results
+    return await containers.containers_docker_inspect(
+        app=request.app, only_status=only_status
+    )
 
 
 @router.get(
     "/containers/activity",
 )
 @cancel_on_disconnect
-async def get_containers_activity(
-    request: Request,
-    settings: Annotated[ApplicationSettings, Depends(get_settings)],
-    shared_store: Annotated[SharedStore, Depends(get_shared_store)],
-) -> ActivityInfoOrNone:
+async def get_containers_activity(request: Request) -> ActivityInfoOrNone:
     _ = request
-    inactivity_command = settings.DY_SIDECAR_CALLBACKS_MAPPING.inactivity
-    if inactivity_command is None:
-        return None
-
-    container_name = inactivity_command.service
-
-    try:
-        inactivity_response = await run_command_in_container(
-            shared_store.original_to_container_names[inactivity_command.service],
-            command=inactivity_command.command,
-            timeout=inactivity_command.timeout,
-        )
-    except (
-        ContainerExecContainerNotFoundError,
-        ContainerExecCommandFailedError,
-        ContainerExecTimeoutError,
-        DockerError,
-    ):
-        _logger.warning(
-            "Could not run inactivity command '%s' in container '%s'",
-            inactivity_command.command,
-            container_name,
-            exc_info=True,
-        )
-        return ActivityInfo(seconds_inactive=_INACTIVE_FOR_LONG_TIME)
-
-    try:
-        return TypeAdapter(ActivityInfo).validate_json(inactivity_response)
-    except ValidationError:
-        _logger.warning(
-            "Could not parse command result '%s' as '%s'",
-            inactivity_response,
-            ActivityInfo.__name__,
-            exc_info=True,
-        )
-
-    return ActivityInfo(seconds_inactive=_INACTIVE_FOR_LONG_TIME)
-
-
-# Some of the operations and sub-resources on containers are implemented as long-running tasks.
-# Handlers for these operations can be found in:
-#
-# POST /containers                       : SEE containers_long_running_tasks::create_service_containers_task
-# POST /containers:down                  : SEE containers_long_running_tasks::runs_docker_compose_down_task
-# POST /containers/state:restore         : SEE containers_long_running_tasks::state_restore_task
-# POST /containers/state:save            : SEE containers_long_running_tasks::state_save_task
-# POST /containers/ports/inputs:pull     : SEE containers_long_running_tasks::ports_inputs_pull_task
-# POST /containers/ports/outputs:pull    : SEE containers_long_running_tasks::ports_outputs_pull_task
-# POST /containers/ports/outputs:push    : SEE containers_long_running_tasks::ports_outputs_push_task
-#
+    return await containers.get_containers_activity(app=request.app)
 
 
 @router.get(
@@ -190,7 +97,6 @@ async def get_containers_activity(
 @cancel_on_disconnect
 async def get_containers_name(
     request: Request,
-    shared_store: Annotated[SharedStore, Depends(get_shared_store)],
     filters: str = Query(
         ...,
         description=(
@@ -211,43 +117,7 @@ async def get_containers_name(
     """
     _ = request
 
-    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}",
-        )
-    network_name: str | None = filters_dict.get("network", None)
-    exclude: str | None = filters_dict.get("exclude", None)
-
-    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",
-        )
-
-    compose_spec = parse_compose_spec(stored_compose_content)
-
-    container_name = None
-
-    spec_services = compose_spec["services"]
-    for service in spec_services:
-        service_content = spec_services[service]
-        if network_name in service_content.get("networks", {}):
-            if exclude is not None and exclude in service_content["container_name"]:
-                # removing this container from results
-                continue
-            container_name = service_content["container_name"]
-            break
-
-    if container_name is None:
-        raise HTTPException(
-            status.HTTP_404_NOT_FOUND,
-            detail=f"No container found for network={network_name}",
-        )
-
-    return f"{container_name}"
+    return await containers.get_containers_name(app=request.app, filters=filters)
 
 
 @router.get(
@@ -259,16 +129,14 @@ async def get_containers_name(
 )
 @cancel_on_disconnect
 async def inspect_container(
-    request: Request,
-    shared_store: Annotated[SharedStore, Depends(get_shared_store)],
-    container_id: str = PathParam(..., alias="id"),
+    request: Request, container_id: str = PathParam(..., alias="id")
 ) -> dict[str, Any]:
     """Returns information about the container, like docker inspect command"""
     _ = request
 
-    _raise_if_container_is_missing(container_id, shared_store.container_names)
-
-    async with docker_client() as docker:
-        container_instance = await docker.containers.get(container_id)
-        inspect_result: dict[str, Any] = await container_instance.show()
-        return inspect_result
+    try:
+        return await containers.inspect_container(
+            app=request.app, container_id=container_id
+        )
+    except ContainerIsMissingError as e:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail=f"{e}") from e

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

@@ -14,4 +14,6 @@ async def create_compose_spec(
     *,
     containers_compose_spec: ContainersComposeSpec,
 ) -> None:
-    await containers.create_compose_spec(app, containers_compose_spec)
+    await containers.create_compose_spec(
+        app, containers_compose_spec=containers_compose_spec
+    )