Hooks & plugins first implementation

Lodel/hooks.py

+#-*- coding: utf-8 -*-
+
+import os
+from importlib.machinery import SourceFileLoader
+
+from Lodel.settings import Settings
+
+## @brief Class designed to handle a hook's callback with a priority
+class DecoratedWrapper(object):
+    ## @brief Constructor
+    # @param hook function : the function to wrap
+    # @param priority int : the callbacl priority
+    def __init__(self, hook, priority):
+        self._priority = priority
+        self._hook = hook
+    
+    ## @brief Call the callback
+    # @param *args
+    # @param **kwargs
+    # @return modified payload
+    def __call__(self, hook_name, caller, payload):
+        return self._hook(hook_name, caller, payload)
+
+## @brief Decorator designed to register hook's callbacks
+#
+# Example : 
+#
+# <pre>
+# @LodelHook('hook_name', 42)
+# def super_callback(hook_name, caller, payload):
+#    return payload
+#
+# LodelHook.call_hook('hook_name', caller, 'foobar') #calls super_callback('hook_name', caller, 'foobar')
+# </pre>
+class LodelHook(object):
+    
+    ## @brief Stores all hooks (DecoratedWrapper instances)
+    _hooks = dict()
+    
+    ## @brief Decorator constructor
+    # @param hook_name str : the name of the hook to register to
+    # @param priority int : the hook priority
+    def __init__(self, hook_name, priority = None):
+        self._hook_name = hook_name
+        self._priority = 0xFFF if priority is None else priority
+    
+    ## @brief called just after __init__
+    # @param hook function : the decorated function
+    # @return the hook argument
+    def __call__(self, hook):
+        if not self._hook_name in self._hooks:
+            self._hooks[self._hook_name] = list()
+        wrapped = DecoratedWrapper(hook, self._priority)
+        self._hooks[self._hook_name].append(wrapped)
+        self._hooks[self._hook_name] = sorted(self._hooks[self._hook_name], key = lambda h: h._priority)
+        return hook
+
+    ## @brief Call hooks
+    # @param hook_name str : the hook's name
+    # @param payload * : datas for the hook
+    # @return modified payload
+    @classmethod
+    def call_hook(cls, hook_name, caller, payload):
+        if hook_name in cls._hooks:
+            for hook in cls._hooks[hook_name]:
+                payload = hook(hook_name, caller, payload)
+        return payload
+

Lodel/settings_format.py

     'datasource',
     'mh_classname',
     'migration_options',
-    'base_path'
+    'base_path',
+    'plugins',
 ]
 
 ## @brief List allowed (but not mandatory) configurations keys

install/loader.py

 Settings.load_module(instance_settings)
 globals()['Settings'] = Settings
 
+from plugins import * #Load activated plugins
+
 # Import dynamic code
 if os.path.isfile(Settings.dynamic_code_file):
     from dynleapi import *

leapi/lecrud.py

 import re
 
 from EditorialModel.fieldtypes.generic import DatasConstructor
+from Lodel.hooks import LodelHook
 
 REL_SUP = 0
 REL_SUB = 1
     # @todo better error handling
     # @todo for check_data_consistency, datas must be populated to make update safe !
     def update(self, datas=None):
+        kwargs = locals()
+        del(kwargs['self'])
+        kwargs = LodelHook.call_hook('leapi_update_pre', self, kwargs)
+        ret = self.__update_unsafe(**kwargs)
+        return ret
+
+    ## @brief Unsafe, without hooks version of insert method
+    # @see _LeCrud.update()
+    def __update_unsafe(self, datas=None):
         if not self.is_complete():
             self.populate()
             warnings.warn("\nThis object %s is not complete and has been populated when update was called. This is very unsafe\n" % self)
     # @return True if success
     # @todo better error handling
     def delete(self):
+        LodelHook.call_hook('leapi_delete_pre', self, None)
         self._datasource.delete(self.__class__, self.uidget())
+        return LodelHook.call_hook('leapi_delete_post', self, None)
 
     ## @brief Check that datas are valid for this type
     # @param datas dict : key == field name value are field values
     # @todo think about LeObject and LeClass instanciation (partial instanciation, etc)
     @classmethod
     def get(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+        kwargs = locals()
+        del(kwargs['cls'])
+        kwargs = LodelHook.call_hook('leapi_get_pre', cls, kwargs)
+        ret = cls.__get_unsafe(**kwargs)
+        return LodelHook.call_hook('leapi_get_post', cls, ret)
+
+    ## @brief Unsafe, without hooks version of get() method
+    # @see _LeCrud.get()
+    @classmethod
+    def __get_unsafe(cls, query_filters, field_list=None, order=None, group=None, limit=None, offset=0, instanciate=True):
+
         if field_list is None or len(field_list) == 0:
             #default field_list
             field_list = cls.fieldlist()
     # @return A new id if success else False
     @classmethod
     def insert(cls, datas, classname=None):
+        kwargs = locals()
+        del(kwargs['cls'])
+        kwargs = LodelHook.call_hook('leapi_insert_pre', cls, kwargs)
+        ret = cls.__insert_unsafe(**kwargs)
+        return LodelHook.call_hook('leapi_insert_post', cls, ret)
+
+    ## @brief Unsafe, without hooks version of insert() method
+    # @see _LeCrud.insert()
+    @classmethod
+    def __insert_unsafe(cls, datas, classname=None):
         callcls = cls if classname is None else cls.name2class(classname)
         if not callcls:
             raise LeApiErrors("Error when inserting",{'error':ValueError("The class '%s' was not found"%classname)})

plugins/__init__.py

+import Lodel.settings
+__all__ = Lodel.settings.Settings.plugins

plugins/dummy.py

+#-*- coding: utf-8 -*-
+
+import Lodel.settings
+from Lodel.hooks import LodelHook
+
+## @brief Hook's callback example
+@LodelHook('leapi_get_pre')
+@LodelHook('leapi_get_post')
+@LodelHook('leapi_update_pre')
+@LodelHook('leapi_update_post')
+@LodelHook('leapi_delete_pre')
+@LodelHook('leapi_delete_post')
+@LodelHook('leapi_insert_pre')
+@LodelHook('leapi_insert_post')
+def dummy_callback(hook_name, caller, payload):
+    if Lodel.settings.Settings.debug:
+        print("\tHook %s\tcaller %s with %s" % (hook_name, caller, payload))
+    return payload   

settings.py

 
 import pymysql
 import os
+import os.path
 
 lodel2_lib_path = os.path.dirname(os.path.abspath(__file__))
 base_path = os.path.dirname(os.path.abspath(__file__))
 debug = False
 debug_sql = False
 
+plugins = ['dummy']
+
 datasource = {
     'default': {
         'module':pymysql,