Fixing settings & logger

globconf.d/loggers.ini

-[lodel2.logging.default]
+[lodel2.logging.stderr]
+level = INFO
+context = False
+
+[lodel2.logging.logfile]
 level = DEBUG
 context = True
-filename = -
+filename = /tmp/lodel2.log
+maxbytes = 4096
+backupcount = 1

lodel/logger.py

 
 # Setting options from Lodel.settings.Settings.logging
 def __init_from_settings():
-    # Disabled, because the custom format raises error (enable to give the _ preffixed arguments to logger resulting into a KeyError exception )
+    # capture warning disabled, because the custom format raises error (unable
+    # to give the _ preffixed arguments to logger resulting into a KeyError
+    # exception )
     #logging.captureWarnings(True) # Log warnings
 
     logger.setLevel(logging.DEBUG)
-    for name, logging_opt in Settings.logging.items():
-        add_handler(name, logging_opt)
+    for name in Settings.logging._fields:
+        add_handler(name, getattr(Settings.logging, name))
+    
 
 ##@brief Add an handler, identified by a name, to a given logger 
 #
     logger = logging.getLogger()
     if name in handlers:
         raise KeyError("A handler named '%s' allready exists")
-
-    if 'filename' in logging_opt:
-        maxBytes = (1024 * 10) if 'maxBytes' not in logging_opt else logging_opt['maxBytes']
-        backupCount = 10 if 'backupCount' not in logging_opt else logging_opt['backupCount']
+    
+    logging_opt = logging_opt._asdict()
+    if 'filename' in logging_opt and logging_opt['filename'] is not None:
+        maxBytes = (1024 * 10) if 'maxbytes' not in logging_opt else logging_opt['maxbytes']
+        backupCount = 10 if 'backupcount' not in logging_opt else logging_opt['backupcount']
 
         handler = logging.handlers.RotatingFileHandler(
                                         logging_opt['filename'],
     extra = {
         '_pathname': os.path.relpath(
                                         caller[0],
-                                        start=Settings.lodel2_lib_path
+                                        start=Settings.lib_path
         ), # os.path.relpath add another small overhead
         '_lineno': caller[1],
         '_funcName': caller[2],

lodel/plugin/plugins.py

         path = None
         for cur_path in cls._plugin_directories:
             plugin_path = os.path.join(cur_path, plugin_name)+'/'
-            print(plugin_path)
             if os.path.isdir(plugin_path):
                 return plugin_path
         raise NameError("No plugin named '%s'" % plugin_name)

lodel/settings/__init__.py

 # </pre>
 #
 
+
+import warnings
 from lodel.settings.settings import Settings as SettingsHandler
 
-##@brief Bootstraped instance
-settings = SettingsHandler.bootstrap()
-if settings is not None:
-    ##@brief Exposed variable that represents configurations values in a
-    # namedtuple tree
-    Settings = settings.confs
+settings = SettingsHandler.instance
+
+if settings is None:
+    Settings = None
+else:
+    Settings = settings.confs.lodel2
+

lodel/settings/settings.py

 import configparser
 import copy
 import warnings
+import types # for dynamic bindings
 from collections import namedtuple
 
 from lodel.plugin.plugins import Plugins, PluginError
 
                                                 major = sys.version_info.major,
                                                 minor = sys.version_info.minor)
+
 ##@brief Handles configuration load etc.
 #
 # To see howto bootstrap Settings and use it in lodel instance see 
     ##@brief Should be called only by the boostrap classmethod
     # @param conf_file str : Path to the global lodel2 configuration file
     # @param conf_dir str : Path to the conf directory
-    def __init__(self, conf_file = '/etc/lodel2/lodel2.conf', conf_dir = 'conf.d'):
+    def __init__(self, conf_file, conf_dir):
         self.__confs = dict()
         self.__conf_dir = conf_dir
         self.__load_bootstrap_conf(conf_file)
     ##@brief This method handlers Settings instance bootstraping
     def __bootstrap(self):
         lodel2_specs = LODEL2_CONF_SPECS
+        for section in lodel2_specs:
+            if section.lower() != section:
+                raise SettingsError("Only lower case are allowed in section name (thank's ConfigParser...)")
+            for kname in lodel2_specs[section]:
+                if kname.lower() != kname:
+                    raise SettingsError("Only lower case are allowed in section name (thank's ConfigParser...)")
+                
+                
         plugins_opt_specs = lodel2_specs['lodel2']['plugins']
 
         # Init the settings loader
         res = copy.copy(specs.pop())
         for spec in specs:
             for section in spec:
+                if section.lower() != section:
+                    raise SettingsError("Only lower case are allowed in section name (thank's ConfigParser...)")
                 if section not in res:
                     res[section] = dict()
                 for kname in spec[section]:
+                    if kname.lower() != kname:
+                        raise SettingsError("Only lower case are allowed in section name (thank's ConfigParser...)")
                     if kname in res[section]:
                         raise SettingsError("Duplicated key '%s' in section '%s'" % (kname, section))
-                    res[section][kname] = copy.copy(spec[section][kname])
+                    res[section.lower()][kname] = copy.copy(spec[section][kname])
         return res
     
     ##@brief Populate the Settings instance with options values fecthed with the loader from merged specs
             for section in loader.getsection(preffix, 'default'): #WARNING : hardcoded default section
                 specs[section] = copy.copy(specs[vsec])
             del(specs[vsec])
-        # Fetching valuds for sections
+        # Fetching values for sections
         for section in specs:
             for kname in specs[section]:
-                validator = specs[section][kname][0]
-                default = specs[section][kname][1]
+                validator = specs[section][kname][1]
+                default = specs[section][kname][0]
                 if section not in self.__confs:
                     self.__confs[section] = dict()
                 self.__confs[section][kname] = loader.getoption(section, kname, validator, default)
                     raise SettingsError("Duplicated key for '%s.%s'" % (section_name, kname))
                 cur[kname] = kval
 
-        path = [ ('root', self.__confs) ]
-        visited = list()
+        path = [ ('root', section_tree) ]
+        visited = set()
         
         curname = 'root'
-        nodename = 'Root'
-        cur = self.__confs
+        nodename = 'Lodel2Settings'
+        cur = section_tree
         while True:
-            visited.append(cur)
+            visited.add(nodename)
             left = [    (kname, cur[kname])
                         for kname in cur
-                        if cur[kname] not in visited and isinstance(cur[kname], dict)
+                        if nodename+'.'+kname.title() not in visited and isinstance(cur[kname], dict)
                     ]
             if len(left) == 0:
                 name, leaf = path.pop()
                 else:
                     path[-1][1][name] = self.__tree2namedtuple(leaf,typename)
                 nodename = '.'.join(nodename.split('.')[:-1])
+                cur = path[-1][1]
             else:
                 curname, cur = left[0]
                 path.append( (curname, cur) )

lodel/settings/settings_loader.py

                             conf[sect][param] = config[sect][param]
                             if sect != 'DEFAULT': self.__conf_sv[sect + ':' + param]=f_ini
                         else:
-                            print(conf)
                             raise SettingsError("Key attribute already defined : %s " % sect + '.' + param + ' dans ' + f_ini + ' et ' + self.__conf_sv[sect + ':' + param])                        
                 else:
                     opts={}

lodel/settings/validator.py

 # @note to get a list of registered default validators just run
 # <pre>$ python scripts/settings_validator.py</pre>
 
+##@brief Exception class that should be raised when a validation fails
 class SettingsValidationError(Exception):
     pass
 
     if not isinstance(value, str):
         raise SettingsValidationError("A string was expected but got '%s' " % value)
     if value == '-':
-        return sys.stderr
+        return None
     return value
 
 ##@brief Boolean value validator callback
 def boolean_val(value):
-    if not (value is True) and not (value is False):
+    if value.strip().lower() == 'true' or value.strip() == '1':
+        value = True
+    elif value.strip().lower() == 'false' or value.strip() == '0':
+        value = False
+    else:
         raise SettingsValidationError("A boolean was expected but got '%s' " % value)
     return bool(value)
 
     valids = ['DEBUG', 'INFO', 'SECURITY', 'ERROR', 'CRITICAL']
     if value.upper() not in valids:
         raise SettingsValidationError("The value '%s' is not a valid loglevel")
+    return value.upper()
 
 #
 #   Default validators registration
                         SettingValidator('bool')),
         'filename': (   None,
                         SettingValidator('errfile', none_is_valid = True)),
-        'backupCount': (    None,
+        'backupcount': (    None,
                             SettingValidator('int', none_is_valid = True)),
-        'maxBytes': (   None,
+        'maxbytes': (   None,
                         SettingValidator('int', none_is_valid = True)),
     }
 }

tests/loader_utils.py

 # This file should be imported in every tests files
 #
 
+import imp
+import lodel.settings
 from lodel.settings.settings import Settings
 Settings.bootstrap(conf_file = 'settings_local.ini', conf_dir = 'globconf.d')
+
+imp.reload(lodel.settings)