holado 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

holado_logging/__init__.py

@@ -14,23 +14,20 @@
 
 
 
-def configure(initialize_logging=True, log_level=None):
+def configure(use_holado_logger=True, logging_config_file_path=None, log_level=None, log_on_console=False, log_in_file=True):
     from holado_logging.common.logging.log_config import LogConfig
-    if log_level is None:
-        import logging
-        log_level = logging.INFO
-        
-    LogConfig.configure(initialize_logging=initialize_logging, log_level=log_level)
+    LogConfig.configure(use_holado_logger=use_holado_logger, config_file_path=logging_config_file_path, log_level=log_level, log_on_console=log_on_console, log_in_file=log_in_file)
     
 def dependencies():
     return None
 
-def register():
+def initialize_and_register():
     from holado.common.context.session_context import SessionContext
     from holado_logging.common.logging.log_manager import LogManager
     
     log_manager = LogManager()
-    log_manager.initialize(log_on_console=True)
+    log_manager.configure()
+    log_manager.initialize()
     
     SessionContext.instance().services.register_service_instance("log_manager", log_manager, SessionContext.instance(), 
                                                                  raise_if_service_exist=False, raise_if_object_exist=False)

holado_logging/common/logging/holado_logger.py

@@ -15,7 +15,7 @@ import logging
 
 logger = logging.getLogger(__name__)
 
-#TODO EKL: rename HoladoLogger
+
 class HALogger(logging.Logger):
     default_message_size_limit = None
     
@@ -56,7 +56,7 @@ class HALogger(logging.Logger):
     #     logger.print(f"Change logger {self} level to {level}")
     #     logging.Logger.setLevel(self, level)
     
-class TestRootLogger(HALogger):
+class HARootLogger(HALogger):
     """
     Implementation is a copy of logging.RootLogger
     """

holado_logging/common/logging/log_config.py

@@ -20,36 +20,61 @@ import logging
 class LogConfig(object):
     TLogger = None
     TManager = None
+    config_file_path = None
     default_level = logging.INFO
+    log_on_console=False
+    log_in_file=True
+    __is_configured = False
     
     @classmethod
-    def configure(cls, initialize_logging=True, log_level=None):
+    def configure(cls, use_holado_logger=True, config_file_path=None, log_level=None, log_on_console=False, log_in_file=True):
+        if cls.__is_configured:
+            logging.warning(f"Logging was already configured, it is not possible to configure it twice. This new configuration is skipped.")
+            return
+        
         # HolAdo needs at least to add logging level TRACE and PRINT
         cls.add_logging_level_trace()
         cls.add_logging_level_print()
         
+        cls.config_file_path = config_file_path
+        if config_file_path:
+            import configparser
+            config = configparser.ConfigParser()
+            config.read(config_file_path)
+            log_level = config.get("holado", "level")
+            log_on_console = config.get("holado", "log_on_console")
+            log_in_file = config.get("holado", "log_in_file")
+        
         if log_level:
             if isinstance(log_level, str):
-                cls.default_level = logging._nameToLevel[log_level]
-            else:
-                cls.default_level = log_level
+                log_level = logging._nameToLevel[log_level]
+            cls.default_level = log_level
+        if log_on_console:
+            if isinstance(log_on_console, str):
+                log_on_console = True if log_on_console == "True" else False
+            cls.log_on_console = log_on_console
+        if log_in_file:
+            if isinstance(log_in_file, str):
+                log_in_file = True if log_in_file == "True" else False
+            cls.log_in_file = log_in_file
+        
+        if use_holado_logger:
+            cls.__set_holado_loggers()
         
-        if initialize_logging:
-            from holado_logging.common.logging.holado_logger import HALogger
-            
-            HALogger.default_message_size_limit = 10000
-            cls.TLogger = HALogger
-            cls.TManager = logging.Manager
-            
-            # Configure logging
-            cls.configure_logging()
+        cls.__is_configured = True
     
     @classmethod
-    def configure_logging(cls):
-        #TODO EKL: make loggers configuration optional
-        # Configure loggers
-        from holado_logging.common.logging.holado_logger import TestRootLogger
-        logging.root = TestRootLogger(cls.default_level)
+    def __set_holado_loggers(cls):
+        from holado_logging.common.logging.holado_logger import HALogger
+        
+        # Configure loggers to use
+        HALogger.default_message_size_limit = 10000
+        cls.TLogger = HALogger
+        cls.TManager = logging.Manager
+        
+        # Set loggers in logging
+        from holado_logging.common.logging.holado_logger import HARootLogger
+        logging.root = HARootLogger(cls.default_level)
         logging.Logger.root = logging.root
         logging.Logger.manager = cls.TManager(cls.TLogger.root)
         

holado_logging/common/logging/log_manager.py

@@ -63,28 +63,28 @@ class LogManager(object):
                 self.format = '%(asctime)s | %(process)-5d-%(thread)-5d | %(levelname)5s | %(module)35s | %(message)s'
                 self.style = '%'
         
-    def initialize(self, log_on_console=True):
+    def configure(self):
+        self.__config_file_path = LogConfig.config_file_path
+        
+        if self.__config_file_path:
+            config = configparser.ConfigParser()
+            config.read(self.__config_file_path)
+            
+            if config.has_section("loggers_levels"):
+                self.__loggers_levels = config.items(section="loggers_levels")
+    
+    def initialize(self):
         """
         Initialize log manager.
         If log_on_console is True, logs are published on console until a new configuration by calling method set_config
         """
-        if log_on_console:
+        handlers = []
+        if LogConfig.log_on_console:
             self.on_console = True
             self.__console_handler = self.__new_console_handler()
-            logging.basicConfig(format=self.format, style=self.style, level=LogConfig.default_level, handlers=[self.__console_handler])
-        else:
-            logging.basicConfig(format=self.format, style=self.style, level=LogConfig.default_level, handlers=[])
-        
-    def set_config_file_path(self, file_path, update_default_level=True):
-        self.__config_file_path = file_path
+            handlers.append(self.__console_handler)
         
-        config = configparser.ConfigParser()
-        config.read(self.__config_file_path)
-        if update_default_level:
-            LogConfig.default_level = config.get("logger_root", "level")
-        
-        if config.has_section("loggers_levels"):
-            self.__loggers_levels = config.items(section="loggers_levels")
+        logging.basicConfig(format=self.format, style=self.style, level=LogConfig.default_level, handlers=handlers)
     
     def has_log_file(self, file_name):
         with self.__files_lock:
@@ -154,8 +154,7 @@ class LogManager(object):
         # Update log destination to files
         with self.__files_lock:
             # Remove old log files
-            # if self.__root_file_name:
-            #     self.remove_root_file_handler(do_reset=True)
+            # Note: root file is not removed if it is configured
             for file_name in list(self.__file_handlers.keys()):
                 if file_name not in self.__file_names:
                     self.remove_file_handler(file_name, do_remove_log_file=False)
@@ -166,7 +165,6 @@ class LogManager(object):
             for file_name in self.__file_names:
                 if file_name not in list(self.__file_handlers.keys()):
                     self.add_file_handler(file_name)
-                
         
         # level
         if logger_.getEffectiveLevel() != LogConfig.default_level:
@@ -176,7 +174,10 @@ class LogManager(object):
         for name, level in self.__loggers_levels:
             if not name.startswith("#"):
                 logging.getLogger(name).setLevel(level)
-                
+        
+        # WARNING: For local debug only
+        # logging.getLogger("holado_logging.common.logging.log_manager").setLevel(logging.DEBUG)
+        
     def set_level(self, log_level, do_set_config=True):
         from holado_core.common.exceptions.technical_exception import TechnicalException
         

holado_multitask/multitasking/multitask_manager.py

@@ -187,7 +187,7 @@ class MultitaskManager(object):
     
     def prepare_thread(self, name, update_parent=True):
         """
-        Create a process context and return a unique name based to given name
+        Create a thread context and return a unique name based to given name
         """
         with self.__thread_lock:
             res = name

holado_multitask/multithreading/thread.py

@@ -21,6 +21,7 @@ from holado_python.standard_library.typing import Typing
 from holado.common.handlers.undefined import undefined_argument, default_context
 from holado_core.common.exceptions.technical_exception import TimeoutTechnicalException
 from holado_core.common.exceptions.functional_exception import FunctionalException
+from holado_python.common.tools.datetime import DateTime, FORMAT_DATETIME_ISO
 
 logger = logging.getLogger(__name__)
 
@@ -35,7 +36,8 @@ class Thread(threading.Thread):
             default_wait_timeout = Config.timeout_seconds * 1000
             
         self.__name = name
-        self.__unique_name = SessionContext.instance().multitask_manager.prepare_thread(name)
+        # Note: if SessionContext doesn't have an instance (like during session context reset), use name+now as unique name
+        self.__unique_name = SessionContext.instance().multitask_manager.prepare_thread(name) if SessionContext.has_instance() else f"{name}_{DateTime.datetime_2_str(DateTime.now(), FORMAT_DATETIME_ISO)}"
         self.__default_wait_timeout = default_wait_timeout
         self.__delay_before_run_sec = delay_before_run_sec
 
@@ -48,7 +50,8 @@ class Thread(threading.Thread):
         self._is_idle.set()
         
         # Register thread
-        if register_thread:
+        # Note: Do not register thread if session context doesn't have an instance (like during session context reset)
+        if register_thread and SessionContext.has_instance():
             # Registered name has to be unique
             SessionContext.instance().threads_manager.register_thread(self.__unique_name, self, scope=register_scope)
         
@@ -74,13 +77,14 @@ class Thread(threading.Thread):
         
     def _set_ident(self):
         super()._set_ident()
-        if not MultitaskManager.has_thread_native_id():
+        if not MultitaskManager.has_thread_native_id() and SessionContext.has_instance():
             SessionContext.instance().multitask_manager.set_thread_uid(self.__unique_name, MultitaskManager.get_thread_uid(thread=self))
         
     if MultitaskManager.has_thread_native_id():
         def _set_native_id(self):
             super()._set_native_id()
-            SessionContext.instance().multitask_manager.set_thread_uid(self.__unique_name, MultitaskManager.get_thread_uid(thread=self))
+            if SessionContext.has_instance():
+                SessionContext.instance().multitask_manager.set_thread_uid(self.__unique_name, MultitaskManager.get_thread_uid(thread=self))
         
     def join(self, timeout=undefined_argument, raise_if_still_alive=True):
         """

holado_test/behave/independant_runner.py

@@ -14,6 +14,7 @@
 import logging
 from behave.runner import Runner
 from behave.parser import parse_feature
+from holado.holado_config import Config
 
 
 logger = logging.getLogger(__name__)
@@ -55,12 +56,9 @@ class IndependantRunner(Runner):
         feature_text = \
             """
             Feature: Fake
-            
                 Scenario: Fake
-                    # Wait 7 days
-                    Given DELAY = ${7 * 24 * 3600}
-                    When wait DELAY seconds
-            """
+                    When wait {runner_session_timeout} seconds
+            """.format(runner_session_timeout=Config.session_timeout_seconds)
         feature = parse_feature(feature_text)
         
         return super().run_model([feature])

holado_test/scenario/step_tools.py

@@ -426,6 +426,8 @@ class StepTools(object):
         new_type = {'pattern':pattern, 'function':func}
         if type_name in cls.__registered_types:
             logger.warning(f"Overriding step parameter type '{type_name}': {cls.__registered_types[type_name]['pattern']} -> {new_type['pattern']}")
+            import traceback
+            logging.warning("".join(traceback.format_list(traceback.extract_stack())))
         cls.__registered_types[type_name] = new_type
         if Tools.do_log(logger, logging.TRACE):  # @UndefinedVariable
             logger.trace(f"Registered step parameter type '{type_name}'")

test_holado/environment.py

@@ -31,7 +31,7 @@ import holado
 #    - log_on_console is True for initialization phase, it will be set to False when root log file will be defined
 #    - logging config file
 from test_holado.test_holado_session_context import TestHoladoSessionContext
-holado.initialize(TSessionContext=TestHoladoSessionContext, logging_config_file=os.path.join(here, 'logging.conf'), log_level=logging.INFO, log_on_console=True)
+holado.initialize(TSessionContext=TestHoladoSessionContext, logging_config_file_path=os.path.join(here, 'logging.conf'), log_level=logging.INFO, log_on_console=True)
 
 
 

test_holado/logging.conf

@@ -1,7 +1,9 @@
-[logger_root]
+[holado]
 #level=INFO
 level=DEBUG
 #level=TRACE
+log_on_console=False
+log_in_file=True
 
 [loggers_levels]
 holado=INFO