holado 0.6.2__tar.gz → 0.6.3__tar.gz

{holado-0.6.2 → holado-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: holado
-Version: 0.6.2
+Version: 0.6.3
 Summary: HolAdo framework
 Project-URL: Homepage, https://gitlab.com/holado_framework/python
 Project-URL: Issues, https://gitlab.com/holado_framework/python/-/issues

holado-0.6.3/packaging/VERSION

@@ -0,0 +1 @@
+0.6.3

{holado-0.6.2 → holado-0.6.3}/src/holado/common/handlers/object.py

@@ -62,9 +62,20 @@ class DeleteableObject(Object):
         
         self.__on_delete_funcs = []
         self.__on_delete_gc_collect = False
+        self.__is_deleteable = True
+    
+    @property
+    def _is_deleteable(self):
+        return self.__is_deleteable
+    
+    @_is_deleteable.setter
+    def _is_deleteable(self, is_deleteable):
+        self.__is_deleteable = is_deleteable
     
     def __del__(self):
         try:
+            if not self._is_deleteable:
+                return
             if self.object_state in [ObjectStates.Deleting, ObjectStates.Deleted]:
                 return
             
@@ -83,7 +94,8 @@ class DeleteableObject(Object):
                 self.__delete()
             else:
                 from holado_multitask.multithreading.functionthreaded import FunctionThreaded
-                func = FunctionThreaded(self.__delete, name=f"delete object '{self.name}'", register_thread=False)
+                func = FunctionThreaded(self.__delete, name=f"delete object '{self.name}'", register_thread=False, do_log=False)
+                func._is_deleteable = False      # Deactivate deletion mechanism of DeleteableObject to avoid an infinite loop
                 func.start()
                 func.join(timeout=30, raise_if_still_alive=False)   # timeout of 30s to limit deadlock impact ; raise to False since exceptions are omitted in gc collect context
         except AttributeError as exc:
@@ -124,6 +136,8 @@ class DeleteableObject(Object):
         from holado_core.common.tools.tools import Tools
         from holado_python.standard_library.typing import Typing
         
+        if not self._is_deleteable:
+            return
         if self.object_state in [ObjectStates.Deleting, ObjectStates.Deleted]:
             return False
         

{holado-0.6.2 → holado-0.6.3}/src/holado_docker/sdk/docker/docker_client.py

@@ -43,10 +43,10 @@ class DockerClient(object):
     def client(self):
         return self.__client
     
-    def has_container(self, name, in_list=True, reset_if_removed=True):
+    def has_container(self, name, in_list=True, all_=False, reset_if_removed=True):
         # Note: Even if name exists in __containers, it is possible that the container has been removed
         if in_list:
-            c = self.__get_container_from_list(name)
+            c = self.__get_container_from_list(name, all_=all_)
             res = c is not None
             
             if reset_if_removed and not res and name in self.__containers:
@@ -60,7 +60,7 @@ class DockerClient(object):
                 res = False
         return res
     
-    def get_container(self, name, reset_if_removed=True):
+    def get_container(self, name, all_=False, reset_if_removed=True):
         # Reset container if removed
         if reset_if_removed and name in self.__containers:
             if self.__containers[name].status == "removed":
@@ -68,16 +68,16 @@ class DockerClient(object):
         
         # Get container from list if needed
         if name not in self.__containers:
-            c = self.__get_container_from_list(name)
+            c = self.__get_container_from_list(name, all_=all_)
             if c:
                 self.__containers[name] = DockerContainer(self, c)
         
         return self.__containers.get(name)
     
-    def update_containers(self, reset_if_removed=True):
+    def update_containers(self, all_=False, sparse=False, reset_if_removed=True):
         # Add new containers
         updated_names = set()
-        for c in self.__client.containers.list(all=True, sparse=True, ignore_removed=True):
+        for c in self.__client.containers.list(all=all_, sparse=sparse, ignore_removed=True):
             try:
                 c_name = c.name
             except docker.errors.NotFound:
@@ -92,21 +92,24 @@ class DockerClient(object):
             for name in set(self.__containers.keys()).difference(updated_names):
                 del self.__containers[name]
     
-    def get_all_container_names(self):
-        res = []
-        for c in self.__client.containers.list(all=True, sparse=True, ignore_removed=True):
-            try:
-                c_name = c.name
-            except docker.errors.NotFound:
-                # Container 'c' doesn't exist anymore
-                continue
-            
-            res.append(c_name)
+    def get_container_names(self, in_list=True, all_=False, sparse=False):
+        if in_list:
+            res = []
+            for c in self.__client.containers.list(all=all_, sparse=sparse, ignore_removed=True):
+                try:
+                    c_name = c.name
+                except docker.errors.NotFound:
+                    # Container 'c' doesn't exist anymore
+                    continue
+                
+                res.append(c_name)
+        else:
+            res = list(self.__containers.keys())
         return res
     
-    def __get_container_from_list(self, name):
+    def __get_container_from_list(self, name, all_=False):
         res = None
-        for c in self.__client.containers.list(all=True, ignore_removed=True):
+        for c in self.__client.containers.list(all=all_, ignore_removed=True):
             try:
                 c_name = c.name
             except docker.errors.NotFound:
@@ -205,7 +208,7 @@ class DockerClient(object):
     def start_container(self, name, wait_running=True, **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 ''}")
-        container = self.get_container(name)
+        container = self.get_container(name, all_=True)
         if not container:
             raise FunctionalException("Container of name '{}' doesn't exist")
         
@@ -245,13 +248,14 @@ class DockerClient(object):
     def remove_container(self, name):
         if Tools.do_log(logger, logging.DEBUG):
             logger.debug(f"Removing docker container of name '{name}'")
-        if not self.has_container(name):
+        if not self.has_container(name, in_list=True, all_=True):
             raise FunctionalException(f"Container of name '{name}' doesn't exist")
         
-        del self.__containers[name]
+        if name in self.__containers:
+            del self.__containers[name]
         self.client.api.remove_container(name)
         
-        if self.has_container(name):
+        if self.has_container(name, in_list=True, all_=True):
             raise FunctionalException(f"Failed to remove container of name '{name}'")
         else:
             if Tools.do_log(logger, logging.DEBUG):

{holado-0.6.2 → holado-0.6.3}/src/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-0.6.2/packaging/VERSION

@@ -1 +0,0 @@
-0.6.2