Not fully tested. Enables separated datasources for read only or read&write access to the DB

lodel/editorial_model/components.py

@@ -47,18 +47,28 @@ class EmComponent(object):
 class EmClass(EmComponent):
     
     ##@brief Instanciate a new EmClass
-    # @param uid str : uniq identifier
-    # @param display_name MlString|str|dict : component display_name
-    # @param abstract bool : set the class as asbtract if True
-    # @param pure_abstract bool : if True the EmClass will not be represented in leapi dyncode
-    # @param parents list: parent EmClass list or uid list
-    # @param help_text MlString|str|dict : help_text
-    # @param datasource str : The datasource name ( see @ref lodel2_datasources )
-    def __init__(self, uid, display_name = None, help_text = None, abstract = False, parents = None, group = None, pure_abstract = False, datasource = 'default'):
+    #@param uid str : uniq identifier
+    #@param display_name MlString|str|dict : component display_name
+    #@param abstract bool : set the class as asbtract if True
+    #@param pure_abstract bool : if True the EmClass will not be represented in
+    #leapi dyncode
+    #@param parents list: parent EmClass list or uid list
+    #@param help_text MlString|str|dict : help_text
+    #@param datasources str|tuple|list : The datasource name ( see 
+    #@ref lodel2_datasources ) or two names (first is read_only datasource the
+    #second is read write)
+    def __init__(
+        self, uid, display_name = None, help_text = None, abstract = False,
+        parents = None, group = None, pure_abstract = False,
+        datasources = 'default'):
+
         super().__init__(uid, display_name, help_text, group)
         self.abstract = bool(abstract)
         self.pure_abstract = bool(pure_abstract)
-        self.__datasource = datasource
+        self.__datasource = datasources
+        if not isinstance(datasources, str) and len(datasources) != 2:
+            raise ValueError("datasources arguement can be a single datasource\
+ name or two names in a tuple or a list")
         if self.pure_abstract:
             self.abtract = True
         if parents is not None:

lodel/leapi/lefactory.py

@@ -115,7 +115,8 @@ class {clsname}({parents}):
     _abstract = {abstract}
     _fields = None
     _uid = {uid_list}
-    _datasource = None
+    _ro_datasource = None
+    _rw_datasource = None
     _datasource_name = {datasource_name}
 
 """.format(
@@ -135,7 +136,7 @@ class {clsname}({parents}):
     bootstrap += "\n"
     for em_class in get_classes(model):
         # Dyncode datasource bootstrap instructions
-        bootstrap += """{classname}._init_datasource()
+        bootstrap += """{classname}._init_datasources()
 """.format(
             classname = LeObject.name2objname(em_class.uid))
     return res, set(imports), bootstrap

lodel/leapi/leobject.py

@@ -76,8 +76,10 @@ class LeObject(object):
     _fields = None
     ##@brief A tuple of fieldname (or a uniq fieldname) representing uid
     _uid = None 
-    ##@brief The datasource name ( see @ref lodel2_datasources )
-    _datasource = None
+    ##@brief Read only datasource ( see @ref lodel2_datasources )
+    _ro_datasource = None
+    ##@breif Read & write datasource ( see @ref lodel2_datasources )
+    _rw_datasource = None
 
     ##@brief Construct an object representing an Editorial component
     # @note Can be considered as EmClass instance
@@ -185,25 +187,57 @@ class LeObject(object):
             raise NameError("No field named '%s' in %s" % ( fieldname,
                                                             cls.__name__))
     
+    ##@brief Initialise both datasources (ro and rw)
+    #
+    #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
+    #@see LeObject::_init_datasource()
+    @classmethod
+    def _init_datasources(cls):
+        if isinstance(cls._datasource_name, str):
+            rw_ds = ro_ds = cls._datasource_name
+        else:
+            ro_ds, rw_ds = cls._datasource_name
+        #Read only datasource initialisation
+        cls._ro_datasource = cls._init_datasource(ro_ds, True)
+        log_msg = "Read only datasource %s initialized for LeObject %s"
+        log_msg %= (ro_ds, cls.__name__)
+        logger.debug(log_msg)
+        #Read write datasource initialisation
+        cls._rw_datasource = cls._init_datasource(rw_ds, False)
+        log_msg = "Read&write only datasource %s initialized for LeObject %s"
+        log_msg %= (rw_ds, cls.__name__)
+        logger.debug(log_msg)
+        
+
     ##@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
+    #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
+    #@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
     @classmethod
-    def _init_datasource(cls):
+    def _init_datasource(cls, ds_name, ro):
         expt_msg = "In LeAPI class '%s' " % cls.__name__
-        datasource_orig_name = cls._datasource_name
-        if cls._datasource_name not in Settings.datasources._fields:
+        datasource_orig_name = ds_name
+        if ds_name not in Settings.datasources._fields:
             expt_msg += "Unknow or unconfigured datasource %s"
-            expt_msg %= (cls._datasource_name, cls.__name__)
+            expt_msg %= (ds_name, cls.__name__)
             raise SettingsError(expt_msg)
         
-        ds_identifier = getattr(Settings.datasources, cls._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 %= cls._datasource_name
+            expt_msg %= ds_name
+            raise SettingsError(expt_msg)
+        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)
 
         ds_plugin, ds_name = ds_identifier.split('.')
@@ -226,7 +260,8 @@ class LeObject(object):
             datasource_class = 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 += "The datasource plugin %s seems to be invalid. Error \
+raised when trying to import Datasource"
             expt_msg %= ds_identifier
             raise SettingsError(expt_msg)
         ds_conf_old = ds_conf
@@ -234,10 +269,7 @@ class LeObject(object):
         for k in ds_conf_old._fields:
             ds_conf[k] = getattr(ds_conf_old, k)
 
-        cls._datasource = datasource_class(**ds_conf)
-        log_msg = "Datasource %s initialized for LeObject %s"
-        log_msg %= (datasource_orig_name, cls.__name__)
-        logger.debug(log_msg)
+        return datasource_class(**ds_conf)
 
     ##@brief Read only access to all datas
     # @note for fancy data accessor use @ref LeObject.g attribute @ref LeObjectValues instance

lodel/leapi/query.py

@@ -49,7 +49,8 @@ class LeQuery(object):
         if not issubclass(target_class, LeObject):
             raise TypeError("target class has to be a child class of LeObject")
         self._target_class = target_class
-        self._datasource = target_class._datasource
+        self._ro_datasource = target_class._ro_datasource
+        self._rw_datasource = target_class._rw_datasource
     
     ##@brief Execute a query and return the result
     # @param **datas
@@ -67,7 +68,7 @@ class LeQuery(object):
         LodelHook.call_hook(    self._hook_prefix+'_pre',
                                 self._target_class,
                                 datas)
-        ret = self.__query(target = self._target_class._datasource, **datas)
+        ret = self.__query(target = self._target_class, **datas)
         ret = LodelHook.call_hook(  self._hook_prefix+'_post',
                                     self._target_class,
                                     ret)
@@ -487,7 +488,7 @@ class LeInsertQuery(LeQuery):
     ## @brief Implements an insert query operation, with only one insertion
     # @param new_datas : datas to be inserted
     def __query(self, new_datas):
-        nb_inserted = self._datasource.insert(self._target_class,new_datas)
+        nb_inserted = self._rw_datasource.insert(self._target_class,new_datas)
         if nb_inserted < 0:
             raise LeQueryError("Insertion error")
         return nb_inserted
@@ -521,7 +522,7 @@ class LeUpdateQuery(LeFilteredQuery):
     #@param updated_datas dict : datas to update
     #@returns the number of updated items
     def __query(self, filters, rel_filters, updated_datas):
-        nb_updated = self._datasource.update(
+        nb_updated = self._rw_datasource.update(
             self._target_class, filters, rel_filters, update_datas)
         return nb_updated
     
@@ -546,7 +547,7 @@ class LeDeleteQuery(LeFilteredQuery):
     #@param rel_filters list : see @ref LeFilteredQuery
     #@returns the number of deleted items
     def __query(self, filters, rel_filters):
-        nb_deleted = datasource.delete(
+        nb_deleted = self._rw_datasource.delete(
             self._target_class, filters, rel_filters)
         return nb_deleted
 
@@ -636,9 +637,9 @@ class LeGetQuery(LeFilteredQuery):
 
     ##@brief Implements select query operations
     # @returns a list containing the item(s)
-    def __query(self, datasource):
+    def __query(self):
         # select datas corresponding to query_filter
-        l_datas=datasource.select(  self._target_class,
+        l_datas=self._ro_datasource.select(  self._target_class,
                                     list(self.field_list),
                                     self.query_filter,
                                     None,

lodel/settings/validator.py

@@ -329,6 +329,6 @@ LODEL2_CONF_SPECS = {
         'editormode': ( False, SettingValidator('bool')),
     },
     'lodel2.datasources.*': {
-        'read_only': (True, SettingValidator('bool')),
+        'read_only': (False, SettingValidator('bool')),
         'identifier': ( None, SettingValidator('string'))}
 }