Quite dirty & quick commit implementing acl wrapper for dynleapi

Lodel/settings_format.py

@@ -9,6 +9,7 @@ MANDATORY = [
     'lodel2_lib_path',
     'em_file',
     'dynamic_code_file',
+    'acl_dyn_api',
     'ds_package',
     'datasource',
     'mh_classname',

acl/acl.py

@@ -0,0 +1,109 @@
+#-*- coding: utf-8 -*-
+
+import types
+import importlib
+
+## @brief Example implementation of an ACL class
+class ACL(object):
+    _singleton = None
+    
+    ## @brief dummy singleton contructor
+    def __init__(self, **kwargs):
+        ACL._singleton = self
+    
+    ## @brief dummy singleton getter
+    @classmethod
+    def instance(cls):
+        if cls._singleton is None:
+            cls()
+        return cls._singleton
+
+    ## @brief Callback that checks a call to wrapped classes methods
+    @classmethod
+    def check_call(cls, call_object, method_name, args, kwargs):
+        return ACL.instance()._check_call(call_object, method_name, args, kwargs)
+
+    ## @brief Callback that checks calls to wrapped classes attributes
+    @classmethod
+    def check_attr(cls, call_object, attr_name):
+        return ACL.instance()._check_attr(call_object, attr_name)
+
+    ## @brief instance version of check_attr()
+    # @note this method is the one that fetch and return the attribute
+    def _check_attr(self, call_object, attr_name):
+        print("Getting attribute '%s' on %s" % (attr_name, call_object))
+        return getattr(call_object, attr_name)
+
+    ## @brief instance version of check_call()
+    # @note this method is the one that call the method and return the returned value
+    # @param call_object : the object on wich the method is called (class if class methode else instance)
+    # @param method_name str : method name
+    # @param *args : positional method arguments
+    # @param **kwargs : keyword method arguments
+    def _check_call(self, call_object, method_name, args, kwargs):
+        print("Calling '%s' on %s with %s %s" % (method_name, call_object, args, kwargs))
+        #return call_object.__getattribute__(method_name)(*args, **kwargs)
+        if method_name == '__init__':
+            return call_object(*args, **kwargs)
+        return getattr(call_object, method_name)(*args, **kwargs)
+
+
+## @brief A class designed as a wrapper for a method
+class AclMethodWrapper(object):
+    
+    ## @brief Constructor
+    # @param wrapped_object PythonClass : A python class
+    # @param method_name str : the wrapped method name
+    def __init__(self, wrapped_object, method_name):
+        self._wrapped_object = wrapped_object
+        self._method_name = method_name
+
+    ## @brief Triggered when the wrapped method is called
+    def __call__(self, *args, **kwargs):
+        return ACL.check_call(self._wrapped_object, self._method_name, args, kwargs)
+
+## @brief Return a wrapped class
+#
+# @param module_name str : LeAPI dyn mopdule name
+# @param wrapped_class_name str : wrapped class name
+def get_wrapper(module_name, wrapped_class_name):
+    
+    module = importlib.import_module(module_name)
+    wrapped_class = getattr(module, wrapped_class_name)
+
+    ## @brief Meta class that handles accesses to wrapped class/static attributes
+    class MetaAclWrapper(type):
+        ## @brief Called when we get a class attribute
+        def __getattribute__(cls, name):
+            try:
+                attr = getattr(wrapped_class, name)
+                if isinstance(attr, types.MethodType):
+                    return AclMethodWrapper(wrapped_class, name)
+                else:
+                    return ACL.check_attr(wrapped_class, name)
+            except Exception as e:
+                #Here we can process the exception or log it
+                raise e
+
+    #class AclWrapper(metaclass=MetaAclWrapper):
+    class AclWrapper(object, metaclass=MetaAclWrapper):
+
+        def __init__(self, *args, **kwargs):
+            self._wrapped_instance = ACL.check_call(wrapped_class, '__init__', args, kwargs)
+            #self._wrapped_instance = wrapped_class(*args, **kwargs)
+
+        def __getattribute__(self, name):
+            try:
+                attr = getattr(
+                    super().__getattribute__('_wrapped_instance'),
+                    name
+                )
+                if isinstance(attr, types.MethodType):
+                    return AclMethodWrapper(super().__getattribute__('_wrapped_instance'), name)
+                else:
+                    return ACL.check_attr(super().__getattribute__('_wrapped_instance'), name)
+            except Exception as e:
+                #do what you want
+                raise e
+    return AclWrapper
+

acl/factory.py

@@ -0,0 +1,43 @@
+#-*- coding: utf-8 -*-
+
+import os
+
+import EditorialModel
+from leapi.lecrud import _LeCrud
+
+class AclFactory(object):
+    
+    def __init__(self, code_filename = 'acl/dyn.py'):
+        self._code_filename = code_filename
+        self._dyn_file = os.path.basename(code_filename)
+        self._modname = os.path.dirname(code_filename).strip('/').replace('/', '.') #Warning Windaube compatibility
+
+    ## @brief Create dynamic code python file
+    # @param modle Model : An editorial model
+    # @param leap_dyn_module_name str : Name of leapi dynamic module name
+    def create_pyfile(self, model, leapi_dyn_module_name):
+        with open(self._code_filename, "w+") as dynfp:
+            dynfp.write(self.generate_python(model, leapi_dyn_module_name))
+
+    def generate_python(self, model, leapi_module_name):
+        result = """## @author acl/factory
+
+from acl.acl import get_wrapper
+"""
+        
+        classes_to_wrap = ['LeCrud', 'LeObject', 'LeClass', 'LeType', 'LeRelation']
+        classes_to_wrap += [ _LeCrud.name2classname(emclass.name) for emclass in model.components(EditorialModel.classes.EmClass) ]
+        classes_to_wrap += [ _LeCrud.name2classname(emtype.name) for emtype in model.components(EditorialModel.types.EmType) ]
+
+        for class_to_wrap in classes_to_wrap:
+            result += """
+## @brief Wrapped for {class_to_wrap} LeAPI class
+# @see {module_name}.{class_to_wrap}
+class {class_to_wrap}(get_wrapper('{module_name}', '{class_to_wrap}')):
+    pass
+
+""".format(
+            class_to_wrap = class_to_wrap,
+            module_name = leapi_module_name
+        )
+        return result

install/instance_settings.py

@@ -11,7 +11,8 @@ templates_base_dir = 'LODEL2_INSTANCE_TEMPLATES_BASE_DIR'
 debug = False
 
 em_file = 'em.json'
-dynamic_code_file = 'dynleapi.py'
+dynamic_code_file = 'dynleapi.py' #Warning hardcoded module name in utils.py and loader.py
+acl_dyn_api = 'api.py' #Warning hardcoded module name in utils.py and loader.py
 
 ds_package = 'MySQL'
 mh_classname = 'MysqlMigrationHandler'

install/loader.py

@@ -13,7 +13,7 @@ globals()['Settings'] = Settings
 
 # Import dynamic code
 if os.path.isfile(Settings.dynamic_code_file):
-    from dynleapi import *
+    from api import *
 
 # Import wanted datasource objects
 for db_modname in ['leapidatasource', 'migrationhandler']:

install/utils.py

@@ -18,6 +18,10 @@ def refreshdyn():
     fact = LeFactory(OUTPUT)
     # Create the python file
     fact.create_pyfile(em, LeDataSourceSQL, {})
+    # Generate wrapped API
+    from acl.factory import AclFactory
+    fact = AclFactory(Settings.acl_dyn_api)
+    fact.create_pyfile(em, 'dynleapi')
 
 
 def db_init():
@@ -88,4 +92,4 @@ def dir_init():
             os.unlink(my_file_path)
         with open(my_file_path, 'w') as my_file:
             my_file.write(template['content'])
-        print("Created %s" % my_file_path)
+        print("Created %s" % my_file_path)

refreshdyn.py

@@ -7,14 +7,24 @@ from EditorialModel.model import Model
 from leapi.lefactory import LeFactory
 from EditorialModel.backend.json_backend import EmBackendJson
 from DataSource.MySQL.leapidatasource import LeDataSourceSQL
+import acl.factory
+
+if len(sys.argv) > 1:
+    raise NotImplementedError("Not implemented (broken because of leapi dyn module name)")
 
 OUTPUT = 'leapi/dyn.py' if len(sys.argv) == 1 else sys.argv[1]
 EMJSON = 'EditorialModel/test/me.json' if len(sys.argv) < 3 else sys.argv[2]
+LEAPI_MODNAME = 'leapi.dyn'
+
+ACL_OUTPUT = 'acl/dyn.py'
 
 em = Model(EmBackendJson(EMJSON))
 
 fact = LeFactory(OUTPUT)
 fact.create_pyfile(em, LeDataSourceSQL, {})
 print(fact.generate_python(em, LeDataSourceSQL, {}))
+fact = acl.factory.AclFactory(ACL_OUTPUT)
+fact.create_pyfile(em, LEAPI_MODNAME)
+print(fact.generate_python(em, LEAPI_MODNAME))