Continue to split _init_datasource method of LeObject

lodel/leapi/leobject.py

     #@param ds_name str : The name of the datasource to instanciate
     #@param ro bool : if true initialise the _ro_datasource attribute else
     #initialise _rw_datasource attribute
+    #@throw SettingsError if an error occurs
     @classmethod
     def _init_datasource(cls, ds_name, ro):
-        ds_plugin, ds_name = cls._get_ds_plugin_name(ds_name, ro)
-        #Checks that the datasource is configured
-        if ds_plugin not in Settings.datasource._fields:
-            expt_msg += "Unknown or unconfigured datasource plugin %s"
-            expt_msg %= ds_plugin
+        expt_msg = "In LeAPI class '%s' " % cls.__name__
+        if ds_name not in Settings.datasources._fields:
+            #Checking that datasource exists
+            expt_msg += "Unknow or unconfigured datasource %s"
+            expt_msg %= (ds_name, cls.__name__)
             raise SettingsError(expt_msg)
-        # fetching datasource configuration
-        ds_conf = getattr(Settings.datasource, ds_plugin)
-        if ds_name not in ds_conf._fields:
-            expt_msg += "Unknown or unconfigured datasource instance %s"
-            expt_msg %= ds_identifier
+        try:
+            #fetching plugin name
+            ds_plugin_name, ds_name = cls._get_ds_plugin_name(ds_name, ro)
+        except NameError:
+            expt_msg += "Datasource %s is missconfigured, missing identifier."
+            expt_msg %= ds_name
+            raise SettingsError(expt_msg)
+        except RuntimeError:
+            expt_msg += "Error in datasource %s configuration. Trying to use \
+a read only as a read&write datasource"
+            expt_msg %= ds_name
+            raise SettingsError(expt_msg)
+        
+        try:
+            ds_conf = cls._get_ds_connection_conf(ds_name, ds_plugin_name)
+        except NameError as e:
+            expt_msg += str(e)
             raise SettingsError(expt_msg)
-
-        ds_conf = getattr(ds_conf, ds_name)
         #Checks that the datasource plugin exists
-        ds_plugin_module = Plugin.get(ds_plugin).loader_module()
+        ds_plugin_module = Plugin.get(ds_plugin_name).loader_module()
         try:
             datasource_class = getattr(ds_plugin_module, "Datasource")
         except AttributeError as e:
 raised when trying to import Datasource"
             expt_msg %= ds_identifier
             raise SettingsError(expt_msg)
-        ds_conf_old = ds_conf
-        ds_conf = dict()
-        for k in ds_conf_old._fields:
-            ds_conf[k] = getattr(ds_conf_old, k)
 
         return datasource_class(**ds_conf)
 
+    ##@brief Try to fetch a datasource configuration
+    #@param ds_name str : datasource name
+    #@param ds_plugin_name : datasource plugin name
+    #@return a dict containing datasource initialisation options
+    #@throw NameError if a datasource plugin or instance cannot be found
+    @staticmethod
+    def _get_ds_connection_conf(ds_name,ds_plugin_name):
+        if ds_plugin_name not in Settings.datasource._fields:
+            msg = "Unknown or unconfigured datasource plugin %s"
+            msg %= ds_plugin
+            raise NameError(msg)
+        ds_conf = getattr(Settings.datasource, ds_plugin_name)
+        if ds_name not in ds_conf._fields:
+            msg = "Unknown or unconfigured datasource instance %s"
+            msg %= ds_identifier
+            raise NameError(msg)
+        ds_conf = getattr(ds_conf, ds_name)
+        return {k: getattr(ds_conf,k) for k in ds_conf._fields }
+
     ##@brief fetch datasource plugin name
+    #@param ds_name str : datasource name
+    #@param ro bool : if true consider the datasource as read only
     #@return a tuple(DATASOURCE_PLUGIN_NAME, DATASOURCE_CONNECTION_NAME)
-    @classmethod
-    def _get_ds_plugin_name(cls, ds_name, ro):
-        expt_msg = "In LeAPI class '%s' " % cls.__name__
+    #@throw NameError if datasource identifier not found
+    #@throw RuntimeError if datasource is read_only but ro flag was false
+    @staticmethod
+    def _get_ds_plugin_name(ds_name, ro):
         datasource_orig_name = ds_name
-        if ds_name not in Settings.datasources._fields:
-            expt_msg += "Unknow or unconfigured datasource %s"
-            expt_msg %= (ds_name, cls.__name__)
-            raise SettingsError(expt_msg)
         # fetching connection identifier given datasource name
         ds_identifier = getattr(Settings.datasources, ds_name)
         read_only = getattr(ds_identifier, 'read_only')
         try:
             ds_identifier = getattr(ds_identifier, 'identifier')
-        except NameError:
-            expt_msg += "Datasource %s is missconfigured, missing identifier."
-            expt_msg %= ds_name
-            raise SettingsError(expt_msg)
+        except NameError as e:
+            raise e
         if read_only and not ro:
-            expt_msg += "Error in datasource %s configuration. Trying to use \
-a read only as a read&write datasource"
-            expt_msg %= ds_name
-            raise SettingsError(expt_msg)
+            raise RuntimeError()
         return ds_identifier.split('.')
     
     ##@brief Return the uid of the current LeObject instance