holado 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

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_python/standard_library/hashlib.py

@@ -37,6 +37,34 @@ class HashTools(object):
             res = prefix + res
         
         return res
+    
+    @classmethod
+    def hash(cls, algorithm_name, content, hash_size=None, **hash_kwargs):
+        hash_obj = hashlib.new(algorithm_name, **hash_kwargs)
+        cls._update_hash(hash_obj, content)
+        res = hash_obj.digest()
+        
+        # Truncate result size if needed
+        if hash_size is not None:
+            if not isinstance(hash_size, int):
+                raise TechnicalException(f"Parameter size must be an integer")
+            res = res[:hash_size]
+        
+        return res
+    
+    @classmethod
+    def hexhash(cls, algorithm_name, content, hex_size=None, **hash_kwargs):
+        hash_obj = hashlib.new(algorithm_name, **hash_kwargs)
+        cls._update_hash(hash_obj, content)
+        res = hash_obj.hexdigest()
+        
+        # Truncate result size if needed
+        if hex_size is not None:
+            if not isinstance(hex_size, int):
+                raise TechnicalException(f"Parameter hex_size must be an integer")
+            res = res[:hex_size]
+        
+        return res
         
     @classmethod
     def hexmd5(cls, content):

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)