Enhancement in datasources plugins handling

- now datasources are handled in LeObject child classes
- plugins module now have a method to retrieve a plugin module

lodel/leapi/leobject.py

 
 import importlib
 
+from lodel.plugin import Plugins
+from lodel import logger
+from lodel.settings import Settings
+from lodel.settings.utils import SettingsError
+
 class LeApiErrors(Exception):
     ##@brief Instanciate a new exceptions handling multiple exceptions
     # @param msg str : Exception message
         except KeyError:
             raise NameError("No field named '%s' in %s" % ( fieldname,
                                                             cls.__name__))
+    
+    ##@brief Replace the _datasource attribute value by a datasource instance
+    #
+    # This method is used once at dyncode load to replace the datasource string
+    # by a datasource instance to avoid doing this operation for each query
+    @classmethod
+    def _init_datasource(cls):
+        expt_msg = "In LeAPI class '%s' " % cls.__name__
+        if cls._datasource not in Settings.datasources._fields:
+            expt_msg += "Unknow or unconfigured datasource %s"
+            expt_msg %= (cls._datasource, cls.__name__)
+            raise SettingsError(expt_msg)
+
+        ds_identifier = getattr(Settings.datasources, cls._datasource)
+        try:
+            ds_identifier = getattr(ds_identifier, 'identifier')
+        except NameError:
+            expt_msg += "Datasource %s is missconfigured, missing identifier."
+            expt_msg %= cls._datasource
+            raise SettingsError(expt_msg)
+
+        ds_plugin, ds_name = ds_identifier.split('.')
+        #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
+            raise SettingsError(expt_msg)
+
+        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
+            raise SettingsError(expt_msg)
+
+        ds_conf = getattr(ds_conf, ds_name)
+        #Checks that the datasource plugin exists
+        ds_plugin_module = Plugins.plugin_module(ds_plugin)
+        try:
+            cls._datasource = getattr(ds_plugin_module, "Datasource")
+        except AttributeError as e:
+            raise e
+            expt_msg += "The datasource plugin %s seems to be invalid. Error raised when trying to import Datasource"
+            expt_msg %= ds_identifier
+            raise SettingsError(expt_msg)
+        logger.debug("Datasource initialized for LeObject %s" % cls.__name__)
 
     ##@brief Read only access to all datas
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance

lodel/plugin/plugins.py

 
 import os.path
 
+import importlib
 from importlib.machinery import SourceFileLoader, SourcelessFileLoader
+import plugins
 
 ## @package lodel.plugins Lodel2 plugins management
 #
 ##@brief The package in wich we will load plugins modules
 VIRTUAL_PACKAGE_NAME = 'lodel.plugins_pkg'
 CONFSPEC_FILENAME = 'confspec.py'
-MAIN_FILENAME = 'main.py'
+MAIN_FILENAME = '__init__.py'
 CONFSPEC_VARNAME = 'CONFSPEC'
 
 class PluginError(Exception):
     # @param plugin_name str : The plugin name
     @classmethod
     def load_plugin(cls, plugin_name):
+        cls.plugin_module(plugin_name)
+    
+    ##@brief Load a plugin module and return it
+    #@return the plugin module
+    @classmethod
+    def plugin_module(cls, plugin_name):
         cls.started()
         plugin_path = cls.plugin_path(plugin_name)
         plugin_module = '%s.%s' % ( VIRTUAL_PACKAGE_NAME,
                                     plugin_name)
-        main_module = plugin_module + '.main'
+        main_module = plugin_module
         main_source = plugin_path + MAIN_FILENAME
         try:
             loader = SourceFileLoader(main_module, main_source)
-            main_module = loader.load_module()
-        except ImportError:
+            module = loader.load_module()
+            return module
+        except ImportError as e:
+            raise e
             raise PluginError("Failed to load plugin '%s'. It seems that the plugin name is not valid" % plugin_name)
-        
+
+
     ##@brief Bootstrap the Plugins class
     @classmethod
     def bootstrap(cls):

plugins/dummy_datasource/__init__.py

+from .main import DummyDatasource as Datasource

plugins/dummy_datasource/confspec.py

 from lodel.settings.validator import SettingValidator
 
 CONFSPEC = {
-    'lodel2.datasource.dummy.*' : {
+    'lodel2.datasource.dummy_datasource.*' : {
         'dummy': (  None,
                     SettingValidator('dummy'))}
 }

plugins/dummy_datasource/main.py

+#-*- coding:utf-8 -*-
+
+class DummyDatasource(object):
+    
+    def __init__(self, *conn_args, **conn_kwargs):
+        self.conn_args = conn_args
+        self.conn_kwargs = conn_kwargs
+
+    ## @brief returns a selection of documents from the datasource
+    # @param target_cls Emclass
+    # @param field_list list
+    # @param filters list : List of filters
+    # @param rel_filters list : List of relational filters
+    # @param order list : List of column to order. ex: order = [('title', 'ASC'),]
+    # @param group list : List of tupple representing the column to group together. ex: group = [('title', 'ASC'),]
+    # @param limit int : Number of records to be returned
+    # @param offset int: used with limit to choose the start record
+    # @param instanciate bool : If true, the records are returned as instances, else they are returned as dict
+    # @return list
+    def select(self, target_cls, field_list, filters, rel_filters=None, order=None, group=None, limit=None, offset=0,
+               instanciate=True):
+        pass
+
+    ## @brief Deletes one record defined by its uid
+    # @param target_cls Emclass : class of the record to delete
+    # @param uid dict|list : a dictionary of fields and values composing the unique identifier of the record or a list of several dictionaries
+    # @return int : number of deleted records
+    def delete(self, target_cls, uid):
+        pass
+
+    ## @brief updates one or a list of records
+    # @param target_cls Emclass : class of the object to insert
+    # @param uids list : list of uids to update
+    # @param datas dict : datas to update (new values)
+    # @return int : Number of updated records
+    def update(self, target_cls, uids, **datas):
+        pass
+
+    ## @brief Inserts a record in a given collection
+    # @param target_cls Emclass : class of the object to insert
+    # @param datas dict : datas to insert
+    # @return bool
+    def insert(self, target_cls, **datas):
+        pass
+
+    ## @brief Inserts a list of records in a given collection
+    # @param target_cls Emclass : class of the objects inserted
+    # @param datas_list
+    # @return list : list of the inserted records' ids
+    def insert_multi(self, target_cls, datas_list):
+        pass