holado 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

holado_examples/tests/behave/testing_solution/logging.conf

@@ -0,0 +1,102 @@
+[holado]
+level=INFO
+#level=DEBUG
+log_on_console=False
+log_in_file=True
+
+[loggers_levels]
+common=DEBUG
+config=DEBUG
+context=DEBUG
+
+
+# Set HolAdo modules levels
+# In case default level is set to DEBUG to debug KSC testing solution but not HolAdo, level is defined for each HolAdo module (usually: INFO)
+holado=INFO
+holado.common.context=INFO
+holado.common.context.session_context=DEBUG
+holado.common.handlers.object=DEBUG
+holado_ais=INFO
+#holado_ais.ais=DEBUG
+holado_binary=INFO
+holado_context=INFO
+# Note: set DEBUG level in SessionContext in order to analyze a bug in feature context lifecycle resulting randomly to hook errors until end of session
+holado_context.common.context.session_context=DEBUG
+
+#holado_core=INFO
+holado_core=DEBUG
+#holado_core.common.tables.comparators=DEBUG
+holado_core.common.tools=DEBUG
+holado_core.common.tools.comparators=INFO
+#holado_crypto.crypto.transport=DEBUG
+holado_core.scenario=DEBUG
+
+holado_data=INFO
+holado_db=INFO
+holado_db.tools=DEBUG
+holado_docker=INFO
+holado_docker.sdk=DEBUG
+holado_grpc=INFO
+holado_grpc.ipc=DEBUG
+holado_helper=INFO
+holado_json=INFO
+holado_keycloak=INFO
+holado_keycloak.tools=DEBUG
+holado_logging=DEBUG
+#holado_logging.common.logging.log_manager=DEBUG
+holado_multitask=INFO
+holado_multitask.multithreading.threadsmanager=DEBUG
+holado_protobuf=INFO
+holado_protobuf.ipc=DEBUG
+#holado_protobuf.ipc.protobuf.protobuf_converter=TRACE
+#holado_protobuf.ipc.protobuf.protobuf_messages=TRACE
+holado_python=INFO
+holado_rabbitmq=INFO
+holado_rabbitmq.tools=DEBUG
+holado_redis=INFO
+holado_redis.tools=DEBUG
+holado_report=INFO
+holado_rest=INFO
+#holado_rest.api=DEBUG
+holado_s3=INFO
+holado_s3.tools=DEBUG
+#holado_s3.tools.s3.minio_client=DEBUG
+#holado_s3.tools.s3.minio_client.trace=DEBUG
+
+holado_scripting=INFO
+#holado_scripting.common.tools=DEBUG
+#holado_scripting.common.tools.expression_evaluator=INFO
+holado_scripting.common.tools.expression_evaluator=DEBUG
+#holado_scripting.common.tools.expression_evaluator=TRACE
+#holado_scripting.common.tools.variable_manager=DEBUG
+#holado_scripting.common.tools.variable_manager=TRACE
+#holado_scripting.interpreter=TRACE
+#holado_scripting.interpreter.functions=DEBUG
+
+holado_sftp=INFO
+holado_sftp.tools=DEBUG
+holado_swagger=INFO
+holado_system=INFO
+holado_system.system.global_system=DEBUG
+#holado_test=INFO
+holado_test=DEBUG
+
+# UI modules are not operational yet
+holado_ui=ERROR
+holado_ui_mss=ERROR
+holado_ui_selenium=ERROR
+holado_ui_selenium_angular=ERROR
+holado_ui_selenium_html=ERROR
+
+holado_value=DEBUG
+#holado_value.common.tables.converters.value_table_converter=TRACE
+holado_ws=ERROR
+
+
+# External libraries
+chardet=WARNING
+docker=INFO
+grpc_requests=DEBUG
+pika=WARN
+psycopg=INFO
+urllib3=INFO

holado_examples/tests/behave/testing_solution/requirements.txt

@@ -0,0 +1,5 @@
+# HolAdo framework
+holado[db]
+
+
+

holado_examples/tests/behave/testing_solution/run_test.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+DIR="$(dirname "${BASH_SOURCE[0]}")"
+cd ${DIR}
+
+behave --no-source --no-skipped --no-logcapture "$@"
+

holado_examples/tests/behave/testing_solution/run_test_nonreg.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+DIR="$(dirname "${BASH_SOURCE[0]}")"
+
+${DIR}/run_test.sh -i NonReg -t ~draft -t ~need_update -t ~ScenarioStatus=Draft -t ~ScenarioStatus=NeedUpdate "$@"
+

holado_examples/tests/behave/testing_solution/src/common/tools/path_manager.py

@@ -0,0 +1,40 @@
+
+import logging
+import os
+from holado_core.common.tools.path_manager import PathManager
+
+logger = logging.getLogger(__name__)
+
+
+class TSPathManager(PathManager):
+
+    def __init__(self):
+        super().__init__()
+        
+    def initialize(self):
+        pass
+    
+    def __get_root_path(self):
+        here = os.path.abspath(os.path.dirname(__file__))
+        return os.path.join(here, "..", "..", "..")
+        
+    def get_reports_path(self, name=None):
+        if os.getenv('TESTING_SOLUTION_REPORTS_PATH') is not None:
+            reports_root = os.getenv('TESTING_SOLUTION_REPORTS_PATH')
+        elif os.getenv('TEST_OUTPUT_BASEDIR') is not None:
+            reports_root = os.path.join(os.getenv('TEST_OUTPUT_BASEDIR'), "reports")
+        else:
+            reports_root = super().get_reports_path()
+
+        if name is not None:
+            return os.path.join(reports_root, name)
+        else:
+            return reports_root
+
+    def get_static_files_path(self, name=None):
+        root_path = self.__get_root_path()
+        res = os.path.normpath(os.path.join(root_path, "resources", "static_files"))
+        if name is not None:
+            res = os.path.join(res, name)
+        return res
+    

holado_examples/tests/behave/testing_solution/src/config/config_manager.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from holado_test.behave.behave import execute_steps
+
+logger = logging.getLogger(__name__)
+
+
+class TSConfigManager:
+
+    def __init__(self):
+        self.__func_path_manager = None
+        
+    def initialize(self, func_path_manager):
+        self.__func_path_manager = func_path_manager
+    
+    @property
+    def __path_manager(self):
+        return self.__func_path_manager()
+    
+    def configure_system_with_default_settings(self):
+        # Remove possible side effects of previous execution 
+        execute_steps(u"""
+            # Given ensure XXX
+            """)
+    
+
+
+
+

holado_examples/tests/behave/testing_solution/src/context/session_context.py

@@ -0,0 +1,45 @@
+from builtins import super
+from holado.common.context.session_context import SessionContext
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class TSSessionContext(SessionContext):
+    
+    def __init__(self):
+        super().__init__("TSSession")
+        
+    def configure(self, session_kwargs=None):
+        logger.info("Configuring TSSessionContext")
+        
+        super().configure(session_kwargs)
+        
+        # Override default registered modules
+         
+        from common.tools.path_manager import TSPathManager
+        self.services.register_service_type("path_manager", TSPathManager,
+                            lambda m: m.initialize(),
+                            raise_if_exist=False )
+        
+        
+        # Register new modules
+        
+        from config.config_manager import TSConfigManager
+        self.services.register_service_type("config_manager", TSConfigManager,
+                            lambda m: m.initialize(lambda: self.path_manager) )
+        
+        
+    def initialize(self, session_kwargs=None):
+        if session_kwargs is None:
+            session_kwargs = {}
+        raise_if_not_exist = session_kwargs.get("raise_if_not_exist", True)
+        
+        # Call default initialization
+        super().initialize(session_kwargs)
+        
+        # Initialize testing solution
+        
+        
+        
+        

holado_examples/tests/behave/testing_solution/steps/config_steps.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+import logging
+from holado_test.behave.behave import *  # @UnusedWildImport
+from holado.common.context.session_context import SessionContext
+from config.config_manager import TSConfigManager
+
+
+logger = logging.getLogger(__name__)
+
+
+def __get_config_manager() -> TSConfigManager:
+    return SessionContext.instance().config_manager
+
+
+@Given(r"ensure system is configured with default settings")
+def step_impl(context):
+    __get_config_manager().configure_system_with_default_settings()
+
+
+

holado_examples/tests/behave/testing_solution/steps/public_steps.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+
+from test_holado.steps.public_steps import *
+
+# Note: following lines are commented since, with this example files architecture, these steps are automatically found and imported by behave
+# from steps.config_steps import *
+
+
+

holado_multitask/multithreading/functionthreaded.py

@@ -29,7 +29,7 @@ class FunctionThreaded(ctt.InterruptableThread):
     Execute in a thread given function with given arguments
     '''
     
-    def __init__(self, target, args=None, kwargs=None, name=None, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None):
+    def __init__(self, target, args=None, kwargs=None, name=None, default_wait_timeout=None, register_thread=True, register_scope=default_context, delay_before_run_sec=None, do_log=True):
         super().__init__(name if name is not None else f"FunctionThreaded({repr(target)})", default_wait_timeout=default_wait_timeout, register_thread=register_thread, register_scope=register_scope, delay_before_run_sec=delay_before_run_sec)
         
         if args is None:
@@ -46,6 +46,7 @@ class FunctionThreaded(ctt.InterruptableThread):
         self.__interrupt_function = None
         
         self.__callback_function = None
+        self.__do_log = do_log
 
     @property
     def error(self):
@@ -87,7 +88,8 @@ class FunctionThreaded(ctt.InterruptableThread):
             try:
                 time.sleep(self.delay_before_run_seconds)
             except Exception as exc:
-                logger.exception(f"[Thread '{self.name}'] Exception while waiting delay before run (delay: {self.delay_before_run_seconds} ; type: {Typing.get_object_class_fullname(self.delay_before_run_seconds)})")
+                if self.__do_log:
+                    logger.exception(f"[Thread '{self.name}'] Exception while waiting delay before run (delay: {self.delay_before_run_seconds} ; type: {Typing.get_object_class_fullname(self.delay_before_run_seconds)})")
             
         if self.is_interrupted:
             return
@@ -96,7 +98,8 @@ class FunctionThreaded(ctt.InterruptableThread):
 #             logging.debug("+++++++++ Launching function [{}({})]".format(repr(self._target), repr(self._args)))
             self.__result = self._function.run()
         except Exception as exc:
-            logger.exception(f"[Thread '{self.name}'] Exception catched during threaded function [{self._function.represent()}]")
+            if self.__do_log:
+                logger.exception(f"[Thread '{self.name}'] Exception catched during threaded function [{self._function.represent()}]")
             self.__error = exc
         
         if self.is_interrupted:
@@ -107,10 +110,13 @@ class FunctionThreaded(ctt.InterruptableThread):
                 self.__callback_function.run(self.result, self.error)
         except Exception as exc:
             msg = "Exception catched while calling callback function:\n    callback_function: {}\n    result: [{}]\n    error: [{}]".format(repr(self.__callback_function), Tools.truncate_text(repr(self.result)), repr(self.error))
-            logger.exception(msg)
+            if self.__do_log:
+                logger.exception(msg)
             raise FunctionalException(msg) from exc
         
-        logger.info(f"[Thread '{self.name}'] Thread has finished")
+        if self.__do_log:
+            # logger.info(f"[Thread '{self.name}'] Thread has finished")
+            logger.info(f"[Thread '{self.name}'] Thread has finished (func: {self._function})")
 
     def throw_if_error(self):
         if self.error:

holado_rest/api/rest/rest_client.py

@@ -68,13 +68,19 @@ class RestClient(object):
         self.__kwargs.update(ssl_kwargs)
         
     def response_result(self, response, status_ok=200):
-        if "application/json" in response.headers['Content-Type']:
-            res = response.json()
-        elif response.headers['Content-Type'].startswith('text'):
-            res = response.text
+        # Get result
+        if response.status_code == 204:
+            # 204 == "No Content" => return None
+            res = None
         else:
-            res = response.content
+            if "application/json" in response.headers['Content-Type'] and len(response.content) > 0:
+                res = response.json()
+            elif response.headers['Content-Type'].startswith('text'):
+                res = response.text
+            else:
+                res = response.content
         
+        # Verify status
         is_ok = isinstance(status_ok, list) and response.status_code in status_ok or response.status_code == status_ok
         if not is_ok:
             raise FunctionalException(f"[{self.name}] Request failed with status {response.status_code} (expected success status: {status_ok}) on error: {res}")
@@ -94,6 +100,8 @@ class RestClient(object):
         
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"[{self.name}] {method} on url '{url}' => {res}")
+        if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
+            logger.trace(f"[{self.name}] {method} on url '{url}' => {Tools.represent_object(res, 4)}")
         return res
         
     def delete(self, path, data=None, **kwargs):

holado_docker/tools/docker_controller/server/grpc/proto/generated/docker_controler_pb2.py

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# NO CHECKED-IN PROTOBUF GENCODE
-# source: docker_controler.proto
-# Protobuf Python Version: 5.28.1
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import runtime_version as _runtime_version
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-_runtime_version.ValidateProtobufRuntimeVersion(
-    _runtime_version.Domain.PUBLIC,
-    5,
-    28,
-    1,
-    '',
-    'docker_controler.proto'
-)
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x16\x64ocker_controler.proto\x12\x10\x64ocker_controler\"\x1d\n\x1bGetAllContainerNamesRequest\"7\n\x1cGetAllContainerNamesResponse\x12\x17\n\x0f\x63ontainer_names\x18\x01 \x03(\t\"%\n\x15StartContainerRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"2\n\x16StartContainerResponse\x12\x18\n\x10\x63ontainer_status\x18\x01 \x01(\t\"$\n\x14StopContainerRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"1\n\x15StopContainerResponse\x12\x18\n\x10\x63ontainer_status\x18\x01 \x01(\t\"\'\n\x17RestartContainerRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"4\n\x18RestartContainerResponse\x12\x18\n\x10\x63ontainer_status\x18\x01 \x01(\t2\xc9\x03\n\x16\x44ockerControlerService\x12w\n\x14GetAllContainerNames\x12-.docker_controler.GetAllContainerNamesRequest\x1a..docker_controler.GetAllContainerNamesResponse\"\x00\x12\x65\n\x0eStartContainer\x12\'.docker_controler.StartContainerRequest\x1a(.docker_controler.StartContainerResponse\"\x00\x12\x62\n\rStopContainer\x12&.docker_controler.StopContainerRequest\x1a\'.docker_controler.StopContainerResponse\"\x00\x12k\n\x10RestartContainer\x12).docker_controler.RestartContainerRequest\x1a*.docker_controler.RestartContainerResponse\"\x00\x62\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'docker_controler_pb2', _globals)
-if not _descriptor._USE_C_DESCRIPTORS:
-  DESCRIPTOR._loaded_options = None
-  _globals['_GETALLCONTAINERNAMESREQUEST']._serialized_start=44
-  _globals['_GETALLCONTAINERNAMESREQUEST']._serialized_end=73
-  _globals['_GETALLCONTAINERNAMESRESPONSE']._serialized_start=75
-  _globals['_GETALLCONTAINERNAMESRESPONSE']._serialized_end=130
-  _globals['_STARTCONTAINERREQUEST']._serialized_start=132
-  _globals['_STARTCONTAINERREQUEST']._serialized_end=169
-  _globals['_STARTCONTAINERRESPONSE']._serialized_start=171
-  _globals['_STARTCONTAINERRESPONSE']._serialized_end=221
-  _globals['_STOPCONTAINERREQUEST']._serialized_start=223
-  _globals['_STOPCONTAINERREQUEST']._serialized_end=259
-  _globals['_STOPCONTAINERRESPONSE']._serialized_start=261
-  _globals['_STOPCONTAINERRESPONSE']._serialized_end=310
-  _globals['_RESTARTCONTAINERREQUEST']._serialized_start=312
-  _globals['_RESTARTCONTAINERREQUEST']._serialized_end=351
-  _globals['_RESTARTCONTAINERRESPONSE']._serialized_start=353
-  _globals['_RESTARTCONTAINERRESPONSE']._serialized_end=405
-  _globals['_DOCKERCONTROLERSERVICE']._serialized_start=408
-  _globals['_DOCKERCONTROLERSERVICE']._serialized_end=865
-# @@protoc_insertion_point(module_scope)

holado_docker/tools/docker_controller/server/grpc/proto/generated/docker_controler_pb2_grpc.py

@@ -1,233 +0,0 @@
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-"""Client and server classes corresponding to protobuf-defined services."""
-import grpc
-import warnings
-
-import docker_controler_pb2 as docker__controler__pb2
-
-GRPC_GENERATED_VERSION = '1.68.1'
-GRPC_VERSION = grpc.__version__
-_version_not_supported = False
-
-try:
-    from grpc._utilities import first_version_is_lower
-    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
-except ImportError:
-    _version_not_supported = True
-
-if _version_not_supported:
-    raise RuntimeError(
-        f'The grpc package installed is at version {GRPC_VERSION},'
-        + f' but the generated code in docker_controler_pb2_grpc.py depends on'
-        + f' grpcio>={GRPC_GENERATED_VERSION}.'
-        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
-        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
-    )
-
-
-class DockerControlerServiceStub(object):
-    """DockerControlerService represents the querying service provided by docker controler.
-    """
-
-    def __init__(self, channel):
-        """Constructor.
-
-        Args:
-            channel: A grpc.Channel.
-        """
-        self.GetAllContainerNames = channel.unary_unary(
-                '/docker_controler.DockerControlerService/GetAllContainerNames',
-                request_serializer=docker__controler__pb2.GetAllContainerNamesRequest.SerializeToString,
-                response_deserializer=docker__controler__pb2.GetAllContainerNamesResponse.FromString,
-                _registered_method=True)
-        self.StartContainer = channel.unary_unary(
-                '/docker_controler.DockerControlerService/StartContainer',
-                request_serializer=docker__controler__pb2.StartContainerRequest.SerializeToString,
-                response_deserializer=docker__controler__pb2.StartContainerResponse.FromString,
-                _registered_method=True)
-        self.StopContainer = channel.unary_unary(
-                '/docker_controler.DockerControlerService/StopContainer',
-                request_serializer=docker__controler__pb2.StopContainerRequest.SerializeToString,
-                response_deserializer=docker__controler__pb2.StopContainerResponse.FromString,
-                _registered_method=True)
-        self.RestartContainer = channel.unary_unary(
-                '/docker_controler.DockerControlerService/RestartContainer',
-                request_serializer=docker__controler__pb2.RestartContainerRequest.SerializeToString,
-                response_deserializer=docker__controler__pb2.RestartContainerResponse.FromString,
-                _registered_method=True)
-
-
-class DockerControlerServiceServicer(object):
-    """DockerControlerService represents the querying service provided by docker controler.
-    """
-
-    def GetAllContainerNames(self, request, context):
-        """Get all container names.
-        """
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-    def StartContainer(self, request, context):
-        """Start a container.
-        """
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-    def StopContainer(self, request, context):
-        """Stop a container.
-        """
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-    def RestartContainer(self, request, context):
-        """Restart a container.
-        """
-        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
-        context.set_details('Method not implemented!')
-        raise NotImplementedError('Method not implemented!')
-
-
-def add_DockerControlerServiceServicer_to_server(servicer, server):
-    rpc_method_handlers = {
-            'GetAllContainerNames': grpc.unary_unary_rpc_method_handler(
-                    servicer.GetAllContainerNames,
-                    request_deserializer=docker__controler__pb2.GetAllContainerNamesRequest.FromString,
-                    response_serializer=docker__controler__pb2.GetAllContainerNamesResponse.SerializeToString,
-            ),
-            'StartContainer': grpc.unary_unary_rpc_method_handler(
-                    servicer.StartContainer,
-                    request_deserializer=docker__controler__pb2.StartContainerRequest.FromString,
-                    response_serializer=docker__controler__pb2.StartContainerResponse.SerializeToString,
-            ),
-            'StopContainer': grpc.unary_unary_rpc_method_handler(
-                    servicer.StopContainer,
-                    request_deserializer=docker__controler__pb2.StopContainerRequest.FromString,
-                    response_serializer=docker__controler__pb2.StopContainerResponse.SerializeToString,
-            ),
-            'RestartContainer': grpc.unary_unary_rpc_method_handler(
-                    servicer.RestartContainer,
-                    request_deserializer=docker__controler__pb2.RestartContainerRequest.FromString,
-                    response_serializer=docker__controler__pb2.RestartContainerResponse.SerializeToString,
-            ),
-    }
-    generic_handler = grpc.method_handlers_generic_handler(
-            'docker_controler.DockerControlerService', rpc_method_handlers)
-    server.add_generic_rpc_handlers((generic_handler,))
-    server.add_registered_method_handlers('docker_controler.DockerControlerService', rpc_method_handlers)
-
-
- # This class is part of an EXPERIMENTAL API.
-class DockerControlerService(object):
-    """DockerControlerService represents the querying service provided by docker controler.
-    """
-
-    @staticmethod
-    def GetAllContainerNames(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_unary(
-            request,
-            target,
-            '/docker_controler.DockerControlerService/GetAllContainerNames',
-            docker__controler__pb2.GetAllContainerNamesRequest.SerializeToString,
-            docker__controler__pb2.GetAllContainerNamesResponse.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)
-
-    @staticmethod
-    def StartContainer(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_unary(
-            request,
-            target,
-            '/docker_controler.DockerControlerService/StartContainer',
-            docker__controler__pb2.StartContainerRequest.SerializeToString,
-            docker__controler__pb2.StartContainerResponse.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)
-
-    @staticmethod
-    def StopContainer(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_unary(
-            request,
-            target,
-            '/docker_controler.DockerControlerService/StopContainer',
-            docker__controler__pb2.StopContainerRequest.SerializeToString,
-            docker__controler__pb2.StopContainerResponse.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)
-
-    @staticmethod
-    def RestartContainer(request,
-            target,
-            options=(),
-            channel_credentials=None,
-            call_credentials=None,
-            insecure=False,
-            compression=None,
-            wait_for_ready=None,
-            timeout=None,
-            metadata=None):
-        return grpc.experimental.unary_unary(
-            request,
-            target,
-            '/docker_controler.DockerControlerService/RestartContainer',
-            docker__controler__pb2.RestartContainerRequest.SerializeToString,
-            docker__controler__pb2.RestartContainerResponse.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True)