Various bugfix & enhancement

Better checks for datasources initialisation
The dyncode were not bootstraped by bootstrap.site_load() function

lodel/bootstrap.py

     LodelContext.expose_modules(globals(), {
         'lodel.plugins.multisite.loader_utils': ['FAST_APP_EXPOSAL_CACHE']})
     FAST_APP_EXPOSAL_CACHE[ctx_name] = app
+    #Switching back in handled site context in order to bootsrap it's 
+    #dyncode
+    LodelContext.set(ctx_name)
+    dyncode_bootstraping()
     #a dirty & quick attempt to fix context unwanted exite via
     #hooks
     for name in ( 'Plugin', 'LodelHook', 'logger', 'core_hooks',

lodel/exceptions.py

 class LodelFatalError(Exception):
     pass
 
+class LodelFatalErrors(LodelFatalError, LodelExceptions):
+    pass
+
 ##@brief Designed to be a catched exception.
 #
 #@note Designed to be raised in DataHandler

lodel/leapi/lefactory.py

 # @brief Given an EmField returns the data_handler constructor suitable for dynamic code
 # @param a EmField instance
 # @return a string
-
-
 def data_handler_constructor(emfield):
     #dh_module_name = DataHandler.module_name(emfield.data_handler_name)+'.DataHandler'
     get_handler_class_instr = 'DataField.from_name(%s)' % repr(emfield.data_handler_name)
 # @brief Return a python repr of option values
 # @param A value of any type which represents option
 # @return a string
-
-
 def forge_optval(optval):
     if isinstance(optval, dict):
         return '{' + (', '.join(['%s: %s' % (repr(name), forge_optval(val)) for name, val in optval.items()])) + '}'
 
     if isinstance(optval, (set, list, tuple)):
         return '[' + (', '.join([forge_optval(val) for val in optval])) + ']'
-
-    if isinstance(optval, EmField):
+    
+    ##@todo better class test & name retrieval possible using inspect or type
+    if hasattr(optval, '__class__'):
+        cls_name = optval.__class__.__name__
+    else:
+        cls_name = optval.__name__
+
+    if cls_name == 'EmField':
         return "{leobject}.data_handler({fieldname})".format(
             leobject=LeObject.name2objname(optval._emclass.uid),
             fieldname=repr(optval.uid)
         )
-    if isinstance(optval, EmClass):
+    elif cls_name == 'EmClass':
         return LeObject.name2objname(optval.uid)
 
     return repr(optval)

lodel/leapi/leobject.py

                                'LeApiQueryErrors'],
     'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
                                 'LodelScriptError', 'DatasourcePluginError'],
-    'lodel.exceptions': ['LodelFatalError'],
+    'lodel.exceptions': ['LodelFatalError', 'LodelFatalErrors'],
     'lodel.plugin.hooks': ['LodelHook'],
     'lodel.plugin': ['Plugin', 'DatasourcePlugin'],
     'lodel.leapi.datahandlers.base_classes': ['DatasConstructor', 'Reference']})
             rw_ds = ro_ds = cls._datasource_name
         else:
             ro_ds, rw_ds = cls._datasource_name
+        errors = []
         # Read only datasource initialisation
-        cls._ro_datasource = DatasourcePlugin.init_datasource(ro_ds, True)
-        if cls._ro_datasource is None:
-            log_msg = "No read only datasource set for LeObject %s"
-            log_msg %= cls.__name__
-            logger.error(log_msg)
-        else:
-            log_msg = "Read only datasource '%s' initialized for LeObject %s"
-            log_msg %= (ro_ds, cls.__name__)
-            logger.debug(log_msg)
+        try:
+            cls._ro_datasource = DatasourcePlugin.init_datasource(ro_ds, True)
+            if cls._ro_datasource is not None:
+                log_msg = "Read only datasource '%s' initialized for LeObject %s"
+                log_msg %= (ro_ds, cls.__name__)
+                logger.debug(log_msg)
+        except LodelFatalError as e:
+            errors.append(e)
+            
         # Read write datasource initialisation
-        cls._rw_datasource = DatasourcePlugin.init_datasource(rw_ds, False)
-        if cls._ro_datasource is None:
-            log_msg = "No read/write datasource set for LeObject %s"
-            log_msg %= cls.__name__
-            logger.error(log_msg)
-        else:
-            log_msg = "Read/write datasource '%s' initialized for LeObject %s"
-            log_msg %= (ro_ds, cls.__name__)
-            logger.debug(log_msg)
+        try:
+            cls._rw_datasource = DatasourcePlugin.init_datasource(rw_ds, False)
+            if cls._ro_datasource is not None:
+                log_msg = "Read/write datasource '%s' initialized for LeObject %s"
+                log_msg %= (ro_ds, cls.__name__)
+                logger.debug(log_msg)
+        except LodelFatalError as e:
+            errors.append(e)
+        
+        if len(errors) > 0:
+            raise LodelFatalErrors(msg = 'Unable to instanciate datasources \
+for LeObject %s' % cls.__name__, exceptions = errors)
+            
 
     # @brief Return the uid of the current LeObject instance
     #@return the uid value

lodel/plugin/datasource_plugin.py

 from lodel.context import LodelContext
 LodelContext.expose_modules(globals(), {
     'lodel.plugin.plugins': ['Plugin'],
+    'lodel.plugin.hooks': ['LodelHook'],
     'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
-        'LodelScriptError', 'DatasourcePluginError'],
+    'LodelScriptError', 'DatasourcePluginError'],
     'lodel.validator.validator': ['Validator'],
     'lodel.exceptions': ['LodelException', 'LodelExceptions',
-        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+    'LodelFatalError', 'DataNoneValid', 'FieldValidationError'],
+})
 
 _glob_typename = 'datasource'
 
         plugin_name, ds_identifier = cls.plugin_name(ds_name, ro)
         ds_conf = cls._get_ds_connection_conf(ds_identifier, plugin_name)
         ds_cls = cls.get_datasource(plugin_name)
-        return ds_cls(**ds_conf)
+        res = ds_cls(**ds_conf)
+        if res is None:
+            raise LodelFatalError("Unable to instanciate a datasource from \
+name : '%s'" % ds_name)
+        return res
     
     ##@brief Return an initialized MigrationHandler instance
     #@param ds_name str : The datasource name

lodel/validator/validator.py

 
     @LodelHook('lodel2_dyncode_bootstraped')
     def emfield_conf_check(hookname, caller, payload):
-        import leapi_dyncode as dyncode  # <-- dirty & quick
+        LodelContext.expose_dyncode(globals(), 'dyncode')
         classnames = {cls.__name__.lower(): cls for cls in dyncode.dynclasses}
         if value[0].lower() not in classnames:
             msg = "Following dynamic class do not exists in current EM : %s"