renamed

Author: Andrei Neagu

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

@@ -14,7 +14,7 @@
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def pull_user_services_docker_images_task(
+async def pull_container_images(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -23,17 +23,15 @@ async def pull_user_services_docker_images_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python(
-            "pull_user_services_docker_images_task"
-        ),
+        TypeAdapter(RPCMethodName).validate_python("pull_container_images"),
         lrt_namespace=lrt_namespace,
     )
     assert isinstance(result, TaskId)  # nosec
     return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def create_service_containers_task(
+async def create_containers(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -43,7 +41,7 @@ async def create_service_containers_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("create_service_containers_task"),
+        TypeAdapter(RPCMethodName).validate_python("create_containers"),
         lrt_namespace=lrt_namespace,
         containers_create=containers_create,
     )
@@ -52,7 +50,7 @@ async def create_service_containers_task(
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def runs_docker_compose_down_task(
+async def down_containers(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -61,15 +59,15 @@ async def runs_docker_compose_down_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("runs_docker_compose_down_task"),
+        TypeAdapter(RPCMethodName).validate_python("down_containers"),
         lrt_namespace=lrt_namespace,
     )
     assert isinstance(result, TaskId)  # nosec
     return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def state_restore_task(
+async def restore_cotnainers_state(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -78,15 +76,15 @@ async def state_restore_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("state_restore_task"),
+        TypeAdapter(RPCMethodName).validate_python("restore_cotnainers_state"),
         lrt_namespace=lrt_namespace,
     )
     assert isinstance(result, TaskId)  # nosec
     return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def state_save_task(
+async def save_containers_state(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -95,15 +93,15 @@ async def state_save_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("state_save_task"),
+        TypeAdapter(RPCMethodName).validate_python("save_containers_state"),
         lrt_namespace=lrt_namespace,
     )
     assert isinstance(result, TaskId)  # nosec
     return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def ports_inputs_pull_task(
+async def pull_container_port_inputs(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -113,7 +111,7 @@ async def ports_inputs_pull_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("ports_inputs_pull_task"),
+        TypeAdapter(RPCMethodName).validate_python("pull_container_port_inputs"),
         lrt_namespace=lrt_namespace,
         port_keys=port_keys,
     )
@@ -141,7 +139,7 @@ async def ports_outputs_pull_task(
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def ports_outputs_push_task(
+async def push_container_port_outputs(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -150,15 +148,15 @@ async def ports_outputs_push_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("ports_outputs_push_task"),
+        TypeAdapter(RPCMethodName).validate_python("push_container_port_outputs"),
         lrt_namespace=lrt_namespace,
     )
     assert isinstance(result, TaskId)  # nosec
     return result
 
 
 @log_decorator(_logger, level=logging.DEBUG)
-async def containers_restart_task(
+async def restart_containers(
     rabbitmq_rpc_client: RabbitMQRPCClient,
     *,
     node_id: NodeID,
@@ -167,7 +165,7 @@ async def containers_restart_task(
     rpc_namespace = get_rpc_namespace(node_id)
     result = await rabbitmq_rpc_client.request(
         rpc_namespace,
-        TypeAdapter(RPCMethodName).validate_python("containers_restart_task"),
+        TypeAdapter(RPCMethodName).validate_python("restart_containers"),
         lrt_namespace=lrt_namespace,
     )
     assert isinstance(result, TaskId)  # nosec

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

@@ -20,14 +20,14 @@
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def pull_user_servcices_docker_images(
+async def pull_container_images(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.pull_user_services_docker_images(
+    return await containers_long_running_tasks.pull_container_images(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace
     )
 
@@ -48,15 +48,15 @@ async def pull_user_servcices_docker_images(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def create_service_containers_task(  # pylint: disable=too-many-arguments
+async def create_containers(  # pylint: disable=too-many-arguments
     request: Request,
     containers_create: ContainersCreate,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.create_service_containers_task(
+    return await containers_long_running_tasks.create_containers(
         long_running_manager.rpc_client,
         long_running_manager.lrt_namespace,
         containers_create,
@@ -70,14 +70,14 @@ async def create_service_containers_task(  # pylint: disable=too-many-arguments
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def runs_docker_compose_down_task(
+async def down_containers(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.runs_docker_compose_down_task(
+    return await containers_long_running_tasks.down_containers(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace
     )
 
@@ -89,14 +89,14 @@ async def runs_docker_compose_down_task(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def state_restore_task(
+async def restore_cotnainers_state(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.state_restore_task(
+    return await containers_long_running_tasks.restore_cotnainers_state(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace
     )
 
@@ -108,14 +108,14 @@ async def state_restore_task(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def state_save_task(
+async def save_containers_state(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.state_save_task(
+    return await containers_long_running_tasks.save_containers_state(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace
     )
 
@@ -127,15 +127,15 @@ async def state_save_task(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def ports_inputs_pull_task(
+async def pull_container_port_inputs(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
     port_keys: list[str] | None = None,
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.ports_inputs_pull_task(
+    return await containers_long_running_tasks.pull_container_port_inputs(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace, port_keys
     )
 
@@ -147,15 +147,15 @@ async def ports_inputs_pull_task(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def ports_outputs_pull_task(
+async def pull_container_port_outputs(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
     port_keys: list[str] | None = None,
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.ports_outputs_pull_task(
+    return await containers_long_running_tasks.pull_container_port_outputs(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace, port_keys
     )
 
@@ -167,14 +167,14 @@ async def ports_outputs_pull_task(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def ports_outputs_push_task(
+async def push_container_port_outputs(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.ports_outputs_push_task(
+    return await containers_long_running_tasks.push_container_port_outputs(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace
     )
 
@@ -186,13 +186,13 @@ async def ports_outputs_push_task(
     response_model=TaskId,
 )
 @cancel_on_disconnect
-async def containers_restart_task(
+async def restart_containers(
     request: Request,
     long_running_manager: Annotated[
         FastAPILongRunningManager, Depends(get_long_running_manager)
     ],
 ) -> TaskId:
     _ = request
-    return await containers_long_running_tasks.containers_restart_task(
+    return await containers_long_running_tasks.restart_containers(
         long_running_manager.rpc_client, long_running_manager.lrt_namespace
     )