holado 0.13.4__tar.gz → 0.13.13.dev6__tar.gz

{holado-0.13.4 → holado-0.13.13.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.13.4
+Version: 0.13.13.dev6
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues
@@ -40,6 +40,7 @@ Requires-Dist: minio; extra == 'all'
 Requires-Dist: moto; extra == 'all'
 Requires-Dist: paramiko<4.0.0; extra == 'all'
 Requires-Dist: pika; extra == 'all'
+Requires-Dist: prettytable; extra == 'all'
 Requires-Dist: protobuf; extra == 'all'
 Requires-Dist: psycopg; extra == 'all'
 Requires-Dist: psycopg-binary; extra == 'all'
@@ -60,9 +61,7 @@ Requires-Dist: psycopg; extra == 'db-postgresql'
 Requires-Dist: psycopg-binary; extra == 'db-postgresql'
 Provides-Extra: docker
 Requires-Dist: docker; extra == 'docker'
-Provides-Extra: docker-tools
-Requires-Dist: connexion[flask,swagger-ui,uvicorn]; extra == 'docker-tools'
-Requires-Dist: docker; extra == 'docker-tools'
+Requires-Dist: prettytable; extra == 'docker'
 Provides-Extra: grpc
 Requires-Dist: google; extra == 'grpc'
 Requires-Dist: google-api-core; extra == 'grpc'

holado-0.13.13.dev6/packaging/VERSION

@@ -0,0 +1 @@
+0.13.13.dev6

{holado-0.13.4 → holado-0.13.13.dev6}/pyproject.toml

@@ -37,14 +37,13 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-all = ["holado[ais]", "holado[api-connexion]", "holado[db-postgresql]", "holado[docker]", "holado[docker-tools]", 
+all = ["holado[ais]", "holado[api-connexion]", "holado[db-postgresql]", "holado[docker]", 
        "holado[helper_debug]", "holado[protobuf]", "holado[grpc]", "holado[rabbitmq]", "holado[redis]", 
        "holado[s3]", "holado[sftp]", "holado[ssl]", "holado[ws-zeep]", "holado[yaml]" ]
 ais = ["pyais"]
 api-connexion = ["connexion[flask,swagger-ui,uvicorn]"]
 db-postgresql = ["psycopg", "psycopg_binary"]
-docker = ["docker"]
-docker-tools = ["holado[docker]", "holado[api-connexion]"]
+docker = ["docker", "prettytable"]
 helper_debug = ["pympler"]
 grpc = ["holado[protobuf]", "grpc_requests", "grpcio", "grpcio-reflection", "grpcio-tools"]
 protobuf = ["google", "google-api-core", "protobuf"]

holado-0.13.13.dev6/src/holado_docker/sdk/docker/container_logs.py

@@ -0,0 +1,378 @@
+
+#################################################
+# HolAdo (Holistic Automation do)
+#
+# (C) Copyright 2021-2025 by Eric Klumpp
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+# The Software is provided “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the Software.
+#################################################
+
+import logging
+from holado_core.common.exceptions.technical_exception import TechnicalException
+from holado.common.handlers.object import DeleteableObject
+from holado_multitask.multithreading.functionthreaded import FunctionThreaded
+from holado_python.common.tools.datetime import DateTime
+import json
+from holado_json.filesystem.stream_json_file import StreamJSONFile
+import re
+from holado.common.context.session_context import SessionContext
+import os
+from datetime import datetime
+import copy
+from holado_system.system.filesystem.file import File
+from holado.common.handlers.undefined import is_undefined, default_value
+
+logger = logging.getLogger(__name__)
+
+
+def _get_timestamps_field_name(input_field_name):
+    if input_field_name is None:
+        return None
+    elif is_undefined(input_field_name):
+        return 'time'
+    else:
+        return input_field_name
+
+def _get_include_others_name(input_include_others_name):
+    if input_include_others_name is None:
+        return None
+    elif is_undefined(input_include_others_name):
+        return '[others]'
+    else:
+        return input_include_others_name
+
+
+class DockerContainerLogsFollower(DeleteableObject):
+    """Generic follower of logs of a container
+    """
+    def __init__(self, docker_container):
+        super.__init__(self, docker_container.container.name)
+        self.__docker_container = docker_container
+        self.__logs = []
+        self.__logs_stream = None
+    
+    def _delete_object(self):
+        self.close()
+    
+    def close(self):
+        if self.__logs_stream is not None:
+            self.__logs_stream.close()
+            self.__thread.join()
+            
+            self.__logs_stream = None
+            self.__thread = None
+    
+    def follow_logs(self, stdout=True, stderr=True, tail='all', since=None):
+        """Follow logs from Docker Engine
+        """
+        if isinstance(since, str):
+            since = DateTime.str_2_datetime(since)
+        
+        if self.__logs_stream is not None:
+            raise TechnicalException(f"Logs of container '{self.name}' are already followed")
+        self.__logs_stream = self.__docker_container.container.logs(stdout=stdout, stderr=stderr, tail=tail, since=since, stream=True, timestamps=True)
+        
+        self.__thread = FunctionThreaded(self.__read_stream, name=f"follow logs of container '{self.__docker_container.container.name}'", register_thread=False)
+        self.__thread.interrupt_function = self.__logs_stream.close
+        self.__thread.start()
+    
+    def __read_stream(self):
+        for log in self.__logs_stream:
+            self.__logs.append( (log['time'], log['steam'] == 'stdout', self.__docker_container._get_log_from_log_bytes(log['log'])) )
+    
+    def reset(self):
+        self.__logs.clear()
+    
+    def get_logs(self, stdout=True, stderr=True, timestamps=False, tail='all', since=None, until=None):
+        if since is not None and isinstance(since, datetime):
+            since = DateTime.datetime_2_str(since)
+        if until is not None and isinstance(until, datetime):
+            until = DateTime.datetime_2_str(until)
+        
+        res = []
+        for log in self.__logs:
+            if log[1] and not stdout or not log[1] and not stderr:
+                continue
+            if since is not None and log[0] < since:
+                continue
+            if until is not None and log[0] >= until:
+                continue
+            
+            if timestamps:
+                res.append( (log[0], log[2]) )
+            else:
+                res.append(log[2])
+        
+        if tail != 'all':
+            if not isinstance(tail, int) or tail < 0:
+                raise TechnicalException(f"Argument 'tail' can be 'all' or a positive integer")
+            res = res[-tail:]
+        
+        return res
+
+
+
+
+class DockerContainerLogsFormatter(object):
+    """Base class for formatters of container logs.
+    """
+    def __init__(self, include_patterns=None, exclude_patterns=None, include_others_name=default_value):
+        """ Constructor
+        @param include_patterns: patterns of log fields to include
+        @param exclude_patterns: patterns of log fields to exclude
+        @param include_others_name: if defined, all fields not included and not excluded are grouped in this field name (used only if include_patterns is defined)
+        """
+        self.__include_patterns = {p if isinstance(p, re.Pattern) else re.compile(p):pinfo for p, pinfo in include_patterns.items()} if include_patterns is not None else None
+        self.__exclude_patterns = [ep if isinstance(ep, re.Pattern) else re.compile(ep) for ep in exclude_patterns] if exclude_patterns is not None else None
+        self.__include_others_name = include_others_name
+    
+    def _filter_json_log_fields(self, log_dict):
+        if self.__include_patterns is None and self.__exclude_patterns is None:
+            # No filters are defined
+            return log_dict
+        
+        res = {}
+        log = copy.copy(log_dict)
+        
+        # Manage included fields and remove them from source copy
+        if self.__include_patterns is not None:
+            for pat, pat_info in self.__include_patterns.items():
+                for key in list(log.keys()):
+                    if pat.match(key):
+                        name = pat_info['replace'] if 'replace' in pat_info else key
+                        res[name] = log.pop(key)
+        
+        # Manage excluded fields and remove them from source copy
+        if self.__exclude_patterns is not None:
+            for pat in self.__exclude_patterns:
+                for key in list(log.keys()):
+                    if pat.match(key):
+                        del log[key]
+        
+        # Manage remaining fields of source copy
+        if log:
+            if self.__include_patterns is not None:
+                if self.__include_others_name is not None:
+                    # Include remaining fields in surrounding field self.__include_others_name
+                    res[self.__include_others_name] = log
+            else:
+                # Remaining fields are the result
+                res = log
+        
+        return res
+    
+    def format_logs(self, logs, with_timestamps=False):
+        raise NotImplementedError()
+
+class JsonDockerContainerLogsFormatter(DockerContainerLogsFormatter):
+    """Formatter of container logs in JSON format.
+    """
+    def __init__(self, timestamps_field_name=default_value, include_patterns=None, exclude_patterns=None, include_others_name=None):
+        """ Constructor
+        @param timestamps_field_name: field name of timestamps if they are added to logs
+        @param include_patterns: patterns of log fields to include
+        @param exclude_patterns: patterns of log fields to exclude
+        @param include_others_name: if defined, all fields not included and not excluded are grouped in this field name (used only if include_patterns is defined)
+        """
+        super().__init__(include_patterns, exclude_patterns, include_others_name)
+        self.__timestamps_field_name = _get_timestamps_field_name(timestamps_field_name)
+    
+    def format_logs(self, logs, with_timestamps=False):
+        if with_timestamps and self.__timestamps_field_name is None:
+            raise TechnicalException("Timestamps field name must defined to include docker timestamps")
+        
+        res = []
+        
+        for log in logs:
+            ts = None
+            if with_timestamps:
+                ts, log = log[0], log[1]
+            
+            res_log = {}
+            
+            # Begin by timestamp so that it is the first dict element
+            if ts is not None:
+                res_log[self.__timestamps_field_name] = ts
+            
+            # Add log as JSON format
+            try:
+                log_dict = json.loads(log)
+            except:
+                # In some circumstances (ex: container is in panic), logs can be in another format even if configured in json format
+                log_dict = {'log':log}
+            res_log.update(self._filter_json_log_fields(log_dict))
+            
+            res.append(res_log)
+        
+        return res
+
+
+
+
+class DockerContainerLogsSaver(object):
+    """Base class for savers of docker container logs.
+    """
+    def __init__(self, formatter):
+        """ Constructor
+        @param formatter: logs formatter
+        """
+        self.__formatter = formatter
+    
+    def get_logs(self, docker_container, stdout=True, stderr=True, timestamps=True, tail='all', since=None, until=None):
+        return docker_container.get_logs(stdout=stdout, stderr=stderr, timestamps=timestamps, tail=tail, since=since, until=until, formatter=self.__formatter)
+        
+    def save_logs(self, docker_container, file_path, stdout=True, stderr=True, timestamps=True, tail='all', since=None, until=None):
+        """ Save logs of a container.
+        @return: number of logs saved
+        """
+        raise NotImplementedError()
+
+class JsonDockerContainerLogsSaver(DockerContainerLogsSaver):
+    """Saver of docker container logs in a stream JSON file.
+    """
+    def __init__(self, timestamps_field_name=default_value, include_patterns=None, exclude_patterns=None, include_others_name=default_value, formatter=None, **dumps_kwargs):
+        """ Constructor
+        @param timestamps_field_name: field name of timestamps if they are added to logs
+        @param include_patterns: patterns of log fields to include
+        @param exclude_patterns: patterns of log fields to exclude
+        @param include_others_name: if defined, all fields not included and not excluded are grouped in this field name (used only if include_patterns is defined)
+        @param formatter: formatter to use (if defined, previous fields are omitted)
+        @param dumps_kwargs: all additional kwargs are used as json.dumps additional parameters
+        """
+        if formatter is None:
+            formatter = JsonDockerContainerLogsFormatter(timestamps_field_name=timestamps_field_name, include_patterns=include_patterns, exclude_patterns=exclude_patterns, include_others_name=include_others_name)
+        super().__init__(formatter=formatter)
+        self.__dumps_kwargs = dumps_kwargs
+        
+    def save_logs(self, docker_container, file_path, stdout=True, stderr=True, timestamps=True, tail='all', since=None, until=None):
+        res = None
+        SessionContext.instance().path_manager.makedirs(file_path)
+        
+        logs = self.get_logs(docker_container, stdout=stdout, stderr=stderr, timestamps=timestamps, tail=tail, since=since, until=until)
+        if logs:
+            with StreamJSONFile(file_path, mode='wt') as fout:
+                fout.write_elements_json_object_list(logs, **self.__dumps_kwargs)
+            res = len(logs)
+            logger.info(f"Saved {res} logs for container '{docker_container.container.name}' in file '{file_path}'")
+        
+        return res
+
+class PrettyTableDockerContainerLogsSaver(DockerContainerLogsSaver):
+    """Saver of docker container logs in a pretty table file.
+    """
+    def __init__(self, timestamps_field_name=default_value, include_patterns=None, exclude_patterns=None, include_others_name=default_value, formatter=None, **dumps_kwargs):
+        """ Constructor
+        @param timestamps_field_name: field name of timestamps if they are added to logs
+        @param include_patterns: patterns of log fields to include
+        @param exclude_patterns: patterns of log fields to exclude
+        @param include_others_name: if defined, all fields not included and not excluded are grouped in this field name (used only if include_patterns is defined)
+        @param formatter: formatter to use (if defined, previous fields are omitted)
+        @param dumps_kwargs: all additional kwargs are used as json.dumps additional parameters
+        """
+        if formatter is None:
+            formatter = JsonDockerContainerLogsFormatter(timestamps_field_name=timestamps_field_name, include_patterns=include_patterns, exclude_patterns=exclude_patterns, include_others_name=include_others_name)
+        super().__init__(formatter=formatter)
+        
+        self.__timestamps_field_name = _get_timestamps_field_name(timestamps_field_name)
+        self.__include_patterns = {p if isinstance(p, re.Pattern) else re.compile(p):pinfo for p, pinfo in include_patterns.items()} if include_patterns is not None else None
+        self.__dumps_kwargs = dumps_kwargs
+        
+    def __define_field_names(self, logs):
+        res = []
+        
+        # Get all field names from logs
+        names = list(set().union(*logs))
+        
+        # Sort by included fields
+        if self.__timestamps_field_name and self.__timestamps_field_name in names:
+            res.append(self.__timestamps_field_name)
+            names.remove(self.__timestamps_field_name)
+        if self.__include_patterns:
+            for ip in self.__include_patterns:
+                i = 0
+                while i < len(names):
+                    if ip.match(names[i]):
+                        res.append(names.pop(i))
+                    else:
+                        i += 1
+        
+        # Add remaining names in alphabetical order
+        if names:
+            res.extend(sorted(names))
+        
+        return res
+    
+    def __get_log_row(self, field_names, log):
+        res = []
+        
+        for name in field_names:
+            if name in log:
+                res.append(log[name])
+            else:
+                res.append('')
+        
+        return res
+    
+    def save_logs(self, docker_container, file_path, stdout=True, stderr=True, timestamps=True, tail='all', since=None, until=None):
+        import prettytable
+        from prettytable.prettytable import PrettyTable, TableStyle
+        
+        res = None
+        SessionContext.instance().path_manager.makedirs(file_path)
+        
+        logs = self.get_logs(docker_container, stdout=stdout, stderr=stderr, timestamps=timestamps, tail=tail, since=since, until=until)
+        
+        if logs:
+            # Build table
+            table = PrettyTable()
+            table.field_names = self.__define_field_names(logs)
+            for log in logs:
+                table.add_row(self.__get_log_row(table.field_names, log))
+            
+            # Output table as string
+            table.set_style(TableStyle.ORGMODE)
+            table.align = 'l'
+            table.hrules = prettytable.NONE
+            table_str = table.get_string()
+            
+            with File(file_path, mode='wt') as fout:
+                fout.write(table_str)
+                fout.write('\n')
+            
+            res = len(logs)
+            logger.info(f"Saved {res} logs for container '{docker_container.container.name}' in file '{file_path}'")
+        
+        return res
+
+
+
+class DockerContainersLogsSaver():
+    """Saver of logs for a group of containers
+    """
+    def __init__(self, docker_client, container_logs_saver=PrettyTableDockerContainerLogsSaver(), include_patterns=None, exclude_patterns=None):
+        self.__docker_client = docker_client
+        self.__container_logs_saver = container_logs_saver
+        self.__include_patterns = [ip if isinstance(ip, re.Pattern) else re.compile(ip) for ip in include_patterns] if include_patterns is not None else None
+        self.__exclude_patterns = [ep if isinstance(ep, re.Pattern) else re.compile(ep) for ep in exclude_patterns] if exclude_patterns is not None else None
+        
+    def save_containers_logs(self, destination_path, stdout=True, stderr=True, timestamps=True, tail='all', since=None, until=None):
+        """ Save containers logs
+        @return: number of containers for which logs have been saved
+        """
+        res = 0
+        
+        names = self.__docker_client.get_container_names(in_list=True, all_=True, sparse=True, include_patterns=self.__include_patterns, exclude_patterns=self.__exclude_patterns)
+        for name in names:
+            container = self.__docker_client.get_container(name, all_=True, reset_if_removed=False)
+            file_path = os.path.join(destination_path, f"{name}.log")
+            nb_logs = self.__container_logs_saver.save_logs(container, file_path, stdout=stdout, stderr=stderr, timestamps=timestamps, tail=tail, since=since, until=until)
+            
+            if nb_logs is not None:
+                res += 1
+        
+        return res
+

{holado-0.13.4 → holado-0.13.13.dev6}/src/holado_docker/sdk/docker/docker_client.py

@@ -12,7 +12,6 @@
 #################################################
 
 from holado_core.common.exceptions.functional_exception import FunctionalException
-import time
 import logging
 from holado_core.common.exceptions.technical_exception import TechnicalException
 from holado.common.handlers.object import DeleteableObject
@@ -20,6 +19,8 @@ from holado_core.common.tools.tools import Tools
 from holado_docker.sdk.docker.container_logs import DockerContainerLogsFollower
 import re
 from holado_python.common.tools.datetime import DateTime
+from holado.common.handlers.undefined import default_value
+from holado_core.common.handlers.wait import WaitFuncResult
 
 logger = logging.getLogger(__name__)
 
@@ -75,7 +76,7 @@ class DockerClient(object):
             if c:
                 self.__containers[name] = DockerContainer(self, c)
         
-        return self.__containers.get(name)
+        return self.__containers.get(name, None)
     
     def update_containers(self, all_=False, sparse=False, reset_if_removed=True):
         # Add new containers
@@ -173,9 +174,9 @@ class DockerClient(object):
                 break
         return res
     
-    def run_container(self, name, image, remove_existing=False, wait_running=True, auto_stop=True, **kwargs):
+    def run_container(self, name, image, remove_existing=False, wait_started=True, auto_stop=True, **kwargs):
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Running docker container '{name}' with image '{image}' and arguments {kwargs}{', and waiting running status' if wait_running else ''}")
+            logger.debug(f"Running docker container '{name}' with image '{image}' and arguments {kwargs}{', and waiting it is started' if wait_started else ''}")
         
         # Manage remove if already existing
         cont = self.get_container(name)
@@ -198,79 +199,79 @@ class DockerClient(object):
         self.__containers[name] = container
         
         # Manage wait running status
-        if wait_running:
-            for _ in range(100):
-                time.sleep(1)
-                if container.status == "running":
-                    break
-            if container.status != "running":
-                raise TechnicalException("Failed to run container of name '{}' (status: {})".format(name, container.status))
+        if wait_started:
+            try:
+                container.await_started()
+            except:
+                raise TechnicalException(f"Failed to run container of name '{name}' (status: {container.status})")
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Run docker container '{name}' with image '{image}' and arguments {kwargs}{', and wait running status' if wait_running else ''}")
+            logger.debug(f"Run docker container '{name}' with image '{image}' and arguments {kwargs}{', and waited it is started' if wait_started else ''}")
             
         # Set properties
         container.auto_stop = auto_stop
         
         return container
     
-    def restart_container(self, name, wait_running=True, **kwargs):
+    def restart_container(self, name, wait_started=True, timeout=default_value, **kwargs):
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Restarting docker container '{name}' with arguments {kwargs}{', and waiting running status' if wait_running else ''}")
+            logger.debug(f"Restarting docker container '{name}' with arguments {kwargs}{', and waiting it is started' if wait_started else ''}")
         container = self.get_container(name)
         if not container:
             raise FunctionalException("Container of name '{}' doesn't exist")
         
         container.restart(**kwargs)
         
-        if wait_running:
-            for _ in range(120):
-                time.sleep(1)
-                if container.status == "running":
-                    break
-            if container.status != "running":
-                raise TechnicalException("Failed to restart container of name '{}' (status: {})".format(name, container.status))
+        if wait_started:
+            try:
+                container.await_started(timeout=timeout)
+            except:
+                raise TechnicalException(f"Failed to restart container of name '{name}' (status: {container.status})")
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Restarted docker container '{name}' with arguments {kwargs}{', and waited running status' if wait_running else ''}")
+            logger.debug(f"Restarted docker container '{name}' with arguments {kwargs}{', and waited it is started' if wait_started else ''}")
     
-    def start_container(self, name, wait_running=True, **kwargs):
+    def start_container(self, name, wait_started=True, timeout=default_value, **kwargs):
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Starting docker container '{name}' with arguments {kwargs}{', and waiting running status' if wait_running else ''}")
+            logger.debug(f"Starting docker container '{name}' with arguments {kwargs}{', and waiting it is started' if wait_started else ''}")
         container = self.get_container(name, all_=True)
         if not container:
             raise FunctionalException("Container of name '{}' doesn't exist")
         
         container.start(**kwargs)
         
-        if wait_running:
-            for _ in range(120):
-                time.sleep(1)
-                if container.status == "running":
-                    break
-            if container.status != "running":
-                raise TechnicalException("Failed to start container of name '{}' (status: {})".format(name, container.status))
+        if wait_started:
+            try:
+                container.await_started(timeout=timeout)
+            except:
+                raise TechnicalException(f"Failed to start container of name '{name}' (status: {container.status})")
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Started docker container '{name}' with arguments {kwargs}{', and waited running status' if wait_running else ''}")
+            logger.debug(f"Started docker container '{name}' with arguments {kwargs}{', and waited it is started' if wait_started else ''}")
+        
+    def stop_container(self, name, wait_stopped=True, timeout=default_value, stop_kwargs=None, wait_kwargs=None):
+        stop_kwargs = stop_kwargs if stop_kwargs is not None else {}
+        wait_kwargs = wait_kwargs if wait_kwargs is not None else {}
+        if timeout is not default_value:
+            wait_kwargs['timeout'] = timeout
         
-    def stop_container(self, name):
         if Tools.do_log(logger, logging.DEBUG):
-            logger.debug(f"Stopping docker container of name '{name}'")
+            logger.debug(f"Stopping docker container of name '{name}'{', and waiting it is stopped' if wait_stopped else ''}")
         if name not in self.__containers:
             raise FunctionalException("Unknown container of name '{}'".format(name))
         elif self.__containers[name].status != "running":
             raise FunctionalException("Container of name '{}' is not running (status: {})".format(name, self.__containers[name].status))
         
-        self.__containers[name].stop()
-        try:
-            self.__containers[name].wait()
-        except docker.errors.NotFound:
-            # This exception occurs on containers automatically removed on stop
-            pass
+        self.__containers[name].stop(**stop_kwargs)
+        if wait_stopped:
+            try:
+                self.__containers[name].wait(**wait_kwargs)
+            except docker.errors.NotFound:
+                # This exception occurs on containers automatically removed on stop
+                pass
         
-        if self.__containers[name].status == "running":
+        if wait_stopped and self.__containers[name].status == "running":
             raise FunctionalException("Failed to stop container of name '{}' (status: {})".format(name, self.__containers[name].status))
         else:
             if Tools.do_log(logger, logging.DEBUG):
-                logger.debug(f"Stopped docker container of name '{name}'")
+                logger.debug(f"Stopped docker container of name '{name}'{', and waited it is stopped' if wait_stopped else ''}")
         
     def remove_container(self, name):
         if Tools.do_log(logger, logging.DEBUG):
@@ -287,6 +288,15 @@ class DockerClient(object):
         else:
             if Tools.do_log(logger, logging.DEBUG):
                 logger.debug(f"Removed docker container of name '{name}'")
+    
+    def await_container_exists(self, name, timeout=default_value):
+        wait_status = WaitFuncResult(f"wait container '{name}' exists", 
+                                      lambda: self.has_container(name, in_list=True, all_=True, reset_if_removed=False) )
+        wait_status.redo_until(True)
+        if timeout is not default_value:
+            wait_status.with_timeout(timeout)
+        return wait_status.execute()
+    
         
 class DockerContainer(DeleteableObject):
     def __init__(self, docker_client, container):
@@ -319,12 +329,24 @@ class DockerContainer(DeleteableObject):
         
     @property
     def status(self):
+        """ Container status (created, restarting, running, removing, paused, exited, dead, or removed)
+        """
         try:
             self.__container.reload()
         except docker.errors.NotFound:
             return "removed"
         return self.__container.status
         
+    @property
+    def health_status(self):
+        """ Container health status (starting, healthy, unhealthy, or removed).
+        """
+        try:
+            self.__container.reload()
+        except docker.errors.NotFound:
+            return "removed"
+        return self.__container.health
+        
     @property
     def auto_stop(self):
         self.__auto_stop
@@ -352,6 +374,36 @@ class DockerContainer(DeleteableObject):
     def wait(self, **kwargs):
         return self.__container.wait(**kwargs)
     
+    def await_started(self, timeout=default_value):
+        health_status = self.health_status
+        if health_status == "healthy":
+            return
+        elif health_status is not None:
+            return self.await_health_status("healthy", timeout=timeout)
+        else:
+            # Container hasn't healthy mechanism
+            return self.await_status("running", timeout=timeout)
+            #TODO: for containers that haven't healthy mechanism, add a mechanism to customize how health is computed
+    
+    def await_status(self, status, timeout=default_value):
+        wait_status = WaitFuncResult(f"wait container '{self.name}' has status '{status}'", 
+                                      lambda: self.status)
+        wait_status.with_process_in_thread(False) \
+                   .redo_until(status)
+        if timeout is not default_value:
+            wait_status.with_timeout(timeout)
+        return wait_status.execute()
+    
+    def await_health_status(self, status, timeout=default_value):
+        wait_status = WaitFuncResult(f"wait container '{self.name}' has health status '{status}'", 
+                                      lambda: self.health_status)
+        wait_status.with_process_in_thread(False) \
+                   .redo_until(status)
+        if timeout is not default_value:
+            wait_status.with_timeout(timeout)
+        return wait_status.execute()
+    
+    
     
     # Manage logs
     

{holado-0.13.4 → holado-0.13.13.dev6}/src/holado_python/common/tools/datetime.py

@@ -132,7 +132,7 @@ class DateTime(object):
         res = True
         try:
             DateTime.str_2_datetime(dt_str, dt_format)
-        except (dateutil.parser._parser.ParserError, ValueError):
+        except (dateutil.parser._parser.ParserError, ValueError, TypeError):
             res = False
         return res