Merge branch 'newlodel' of git.labocleo.org:lodel2 into newlodel

install/loader.py

@@ -32,10 +32,11 @@ if 'LODEL2_NO_SETTINGS_LOAD' not in os.environ:
     if not settings.started():
         settings('conf.d')
     from lodel.settings import Settings
-
+    
     #Starts hooks
     from lodel.plugin import LodelHook
     from lodel.plugin import core_hooks
+    from lodel.plugin import core_scripts
 
 def start():
     #Load plugins

install/lodel_admin.py

@@ -4,14 +4,20 @@ import sys
 import os, os.path
 import argparse
 
-"""
-#Dirty hack to solve symlinks problems :
-#   When loader was imported the original one (LODEL_LIBDIR/install/loader)
-#   because lodel_admin.py is a symlink from this folder
-#Another solution can be delete loader from install folder
-sys.path[0] = os.getcwd()
-import loader
-"""
+##@brief Dirty hack to avoid problems with simlink to lodel2 lib folder
+#
+#In instance folder we got a loader.py (the one we want to import here when
+#writing "import loader". The problem is that lodel_admin.py is a simlink to
+#LODEL2LIB_FOLDER/install/lodel_admin.py . In this folder there is the 
+#generic loader.py template. And when writing "import loader" its 
+#LODEL2LIB_FOLDER/install/loader.py that gets imported.
+#
+#In order to solve this problem the _simlink_hack() function delete the
+#LODEL2LIB_FOLDER/install entry from sys.path
+#@note This problem will be solved once lodel lib dir will be in 
+#/usr/lib/python3/lodel
+def _simlink_hack():
+    sys.path[0] = os.getcwd()
 
 ## @brief Utility method to generate python code given an emfile and a
 # translator
@@ -141,4 +147,10 @@ def update_plugin_discover_cache(path_list = None):
     for pname, pinfos in res['plugins'].items():
         print("\t- %s %s -> %s" % (
             pname, pinfos['version'], pinfos['path']))
-    
+
+if __name__ == '__main__':
+    _simlink_hack()
+    import loader
+    loader.start()
+    from lodel.plugin.scripts import main_run
+    main_run()

lodel/leapi/datahandlers/datas_base.py

@@ -13,13 +13,14 @@ class Boolean(DataField):
     ##@brief A boolean field
     def __init__(self, **kwargs):
         if 'check_data_value' not in kwargs:
-            kwargs['check_data_value'] = self.check_value
+            kwargs['check_data_value'] = self.check_data_value
         super().__init__(ftype='bool', **kwargs)
 
     def _check_data_value(self, value):
         error = None
         try:
-            value = bool(value)
+            if type(value) != bool:
+                raise TypeError()
         except(ValueError, TypeError):
             error = TypeError("The value '%s' is not, and will never, be a boolean" % value)
         return value, error
@@ -36,7 +37,11 @@ class Integer(DataField):
     def _check_data_value(self, value):
         error = None
         try:
-            value = int(value)
+            value = float(value)
+            if value % 1 == 0:
+                value = int(value)
+            else:
+                raise TypeError()
         except(ValueError, TypeError):
             error = TypeError("The value '%s' is not, and will never, be an integer" % value)
         return value, error
@@ -67,8 +72,12 @@ class Varchar(DataField):
         error = None
         try:
             value = str(value)
-        except(ValueError, TypeError):
+            if len(value) > self.max_length:
+                raise ValueError
+        except TypeError:
             error = TypeError("The value '%s' can't be a str" % value)
+        except ValueError:
+            error = ValueError("The value '%s' is longer than the maximum length of this field (%s)" % (value, self.max_length))
         return value, error
 
 ##@brief Data field designed to handle date & time 

lodel/plugin/core_scripts.py

@@ -0,0 +1,32 @@
+import lodel.plugin.scripts as lodel_script
+
+##@brief Implements lodel_admin.py discover-plugin action
+#
+#In depth directory scan to find plugins.
+class DiscoverPlugin(lodel_script.LodelScript):
+    _action = 'discover-plugin'
+    _description = 'Walk through given folders looking for plugins'
+    
+    @classmethod
+    def argparser_config(cls, parser):
+        parser.add_argument('-d', '--directory',
+            help="Directory to walk through looking for lodel2 plugins",
+            nargs='+')
+        parser.add_argument('-l', '--list-only', default=False,
+            action = 'store_true',
+            help="Use this option to print a list of discovered plugins \
+without modifying existing cache")
+
+    @classmethod
+    def run(cls, args):
+        from lodel.plugin.plugins import Plugin
+        if args.directory is None or len(args.directory) == 0:
+            cls.help_exit("Specify a least one directory")
+        no_cache = args.list_only
+        res = Plugin.discover(args.directory, no_cache)
+        print("Found plugins in : %s" % ', '.join(args.directory))
+        for pname, pinfos in res['plugins'].items():
+            print("\t- %s(%s) in %s" % (
+                pname, pinfos['version'], pinfos['path']))
+            
+

lodel/plugin/exceptions.py

@@ -1,2 +1,5 @@
 class PluginError(Exception):
     pass
+
+class LodelScriptError(Exception):
+    pass

lodel/plugin/plugins.py

@@ -513,9 +513,13 @@ name differ from the one found in plugin's init file"
     
     ##@brief Reccursively walk throught paths to find plugin, then stores
     #found plugin in a file...
+    #@param paths list : list of directory paths
+    #@param no_cache bool : if true only return a list of found plugins 
+    #without modifying the cache file
     #@return a dict {'path_list': [...], 'plugins': { see @ref _discover }}
+    #@todo add max_depth and symlink following options
     @classmethod
-    def discover(cls, paths = None):
+    def discover(cls, paths = None, no_cache = False):
         logger.info("Running plugin discover")
         if paths is None:
             paths = DEFAULT_PLUGINS_PATH_LIST
@@ -536,8 +540,9 @@ name differ from the one found in plugin's init file"
                 pass
         result = {'path_list': paths, 'plugins': result}
         #Writing to cache
-        with open(DISCOVER_CACHE_FILENAME, 'w+') as pdcache:
-            pdcache.write(json.dumps(result))
+        if not no_cache:
+            with open(DISCOVER_CACHE_FILENAME, 'w+') as pdcache:
+                pdcache.write(json.dumps(result))
         return result
     
     ##@brief Return discover result

lodel/plugin/scripts.py

@@ -0,0 +1,162 @@
+import argparse
+import sys
+
+from lodel import logger
+from lodel.exceptions import *
+
+##@brief Stores registered scripts
+__registered_scripts = dict()
+
+##@brief LodelScript metaclass that allows to "catch" child class
+#declaration
+#
+#Automatic script registration on child class declaration
+class MetaLodelScript(type):
+    
+    def __init__(self, name, bases, attrs):
+        #Here we can store all child classes of LodelScript
+        super().__init__(name, bases, attrs)
+        if len(bases) == 1 and bases[0] == object:
+            print("Dropped : ", name, bases)
+            return
+
+        self.__register_script(name)
+        #_action initialization
+        if self._action is None:
+            logger.warning("%s._action is None. Trying to use class name as \
+action identifier" % name)
+            self._action = name
+        self._action = self._action.lower()
+        if self._description is None:
+            self._description = self._default_description()
+        self._parser = argparse.ArgumentParser(
+            prog = self._prog_name(),
+            description = self._description)
+        self.argparser_config(self._parser)
+            
+    
+    ##@brief Handles script registration
+    #@note Script list is maitained in 
+    #lodel.plugin.admin_script.__registered_scripts
+    def __register_script(self, name):
+        if self._action is None:
+            logger.warning("%s._action is None. Trying to use class name as \
+action identifier" % name)
+            self._action = name
+        self._action = self._action.lower()
+        script_registration(self._action, self)
+
+    def __str__(self):
+        return '%s : %s' % (self._action, self._description)
+
+class LodelScript(object, metaclass=MetaLodelScript):
+    
+    ##@brief A string to identify the action
+    _action = None
+    ##@brief Script descripiton (argparse argument)
+    _description = None
+    ##@brief argparse.ArgumentParser instance
+    _parser = None
+    
+    ##@brief No instanciation
+    def __init__(self):
+        raise NotImplementedError("Static class")
+    
+    ##@brief Virtual method. Designed to initialize arguement parser.
+    #@param argparser ArgumentParser : Child class argument parser instance
+    #@return MUST return the argument parser (NOT SURE ABOUT THAT !! Maybe it \
+    #works by reference)
+    @classmethod
+    def argparser_config(cls, parser):
+        raise LodelScriptError("LodelScript.argparser_config() is a pure \
+virtual method! MUST be implemented by ALL child classes")
+    
+    ##@brief Virtual method. Run the script
+    #@return None or an integer that will be the script return code
+    @classmethod
+    def run(cls, args):
+        raise LodelScriptError("LodelScript.run() is a pure virtual method. \
+MUST be implemented by ALL child classes")
+    
+    ##@brief Called by main_run() to execute a script.
+    #
+    #Handles argument parsing and then call LodelScript.run()
+    @classmethod
+    def _run(cls):
+        args = cls._parser.parse_args()
+        return cls.run(args)
+
+    ##@brief Append action name to the prog name
+    #@note See argparse.ArgumentParser() prog argument
+    @classmethod
+    def _prog_name(cls):
+        return '%s %s' % (sys.argv[0], cls._action)
+    
+    ##@brief Return the default description for an action
+    @classmethod
+    def _default_description(cls):
+        return "Lodel2 script : %s" % cls._action
+    
+    @classmethod
+    def help_exit(cls,msg = None, return_code = 1, exit_after = True):
+        if not (msg is None):
+            print(msg, file=sys.stderr)
+        cls._parser.print_help()
+        if exit_after:
+            exit(1)
+
+def script_registration(action_name, cls):
+    __registered_scripts[action_name] = cls
+    logger.info("New script registered : %s" % action_name)
+
+##@brief Return a list containing all available actions
+def _available_actions():
+    return [ act for act in __registered_scripts ]
+
+##@brief Returns default runner argument parser
+def _default_parser():
+
+    action_list = _available_actions()
+    if len(action_list) > 0:
+        action_list = ', '.join(sorted(action_list))
+    else:
+        action_list = 'NO SCRIPT FOUND !'
+
+    parser = argparse.ArgumentParser(description = "Lodel2 script runner")
+    parser.add_argument('-L', '--list-actions', action='store_true',
+        default=False, help="List available actions")
+    parser.add_argument('action', metavar="ACTION", type=str,
+        help="One of the following actions : %s" % action_list, nargs='?')
+    parser.add_argument('option', metavar="OPTIONS", type=str, nargs='*',
+        help="Action options. Use %s ACTION -h to have help on a specific \
+action" % sys.argv[0])
+    return parser
+
+##@brief Main function of lodel_admin.py script
+#
+#This function take care to run the good plugins and clean sys.argv from
+#action name before running script
+#
+#@return DO NOT RETURN BUT exit() ONCE SCRIPT EXECUTED !!
+def main_run():
+    default_parser = _default_parser()
+    if len(sys.argv) == 1:
+        default_parser.print_help()
+        exit(1)
+    args = default_parser.parse_args()
+    if args.list_actions:
+        print("Available actions :")
+        for sname in sorted(__registered_scripts.keys()):
+            print("\t- %s" % __registered_scripts[sname])
+        exit(0)
+    #preparing sys.argv (deleting action)
+    action = sys.argv[1].lower()
+    del(sys.argv[1])
+    if action not in __registered_scripts:
+        print("Unknow action '%s'\n" % action, file=sys.stderr)
+        default_parser.print_help()
+        exit(1)
+    script = __registered_scripts[action]
+    ret = script._run()
+    ret = 0 if ret is None else ret
+    exit(ret)

tests/datahandlers/test_boolean.py

@@ -0,0 +1,28 @@
+import unittest
+
+from lodel.leapi.datahandlers.datas import Boolean, Varchar, Integer
+
+
+class BooleanTestCase(unittest.TestCase):
+
+    def test_boolean_check_data_value(self):
+        test_boolean = Boolean()
+
+        # correct values
+        for test_value in [True, False]:
+            value, error = test_boolean._check_data_value(test_value)
+            self.assertIsNone(error)
+
+        # incorrect values
+        for test_value in ['ok', 'True', 'False']:
+            value, error = test_boolean._check_data_value(test_value)
+            self.assertIsNotNone(error)
+
+    def test_can_override(self):
+        test_boolean = Boolean()
+
+        test_varchar = Varchar()
+        test_int = Integer()
+
+        self.assertFalse(test_boolean.can_override(test_varchar))
+        self.assertFalse(test_boolean.can_override(test_int))

tests/datahandlers/test_integer.py

@@ -0,0 +1,24 @@
+import unittest
+
+from lodel.leapi.datahandlers.datas import Integer, Boolean
+
+
+class IntegerTestCase(unittest.TestCase):
+
+    def test_integer_check_data_value(self):
+        test_int = Integer()
+
+        # Incorrect values
+        for test_bad_value in ['ok','ceci est un test', '15.2', 15.2]:
+            _, error = test_int._check_data_value(test_bad_value)
+            self.assertIsNotNone(error)
+
+        # Correct values
+        for test_correct_value in [10, '15', '15.0']:
+            _, error = test_int._check_data_value(test_correct_value)
+            self.assertIsNone(error)
+
+    def test_can_override(self):
+        test_int = Integer()
+        test_boolean = Boolean()
+        self.assertFalse(test_int.can_override(test_boolean))

tests/datahandlers/test_regex.py

@@ -1,19 +1,21 @@
 import unittest
 
-from lodel.leapi.datahandlers.datas import Regex, Varchar
+from lodel.leapi.datahandlers.datas import Regex, Varchar, Integer
 
 
 class RegexTestCase(unittest.TestCase):
 
     def test_check_correct_data_value(self):
         test_value = '126.205.255.12'
-        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$', max_length=100)
+        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$',
+                           max_length=100)
         value, error = test_regex._check_data_value(test_value)
         self.assertIsNone(error)
         self.assertEqual(value, test_value)
 
     def test_check_bad_data_value(self):
-        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$', max_length=15)
+        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$',
+                           max_length=15)
         for test_value in ['800.9.10.5', 'test_string_value', '999.999.999.999']:
             value, error = test_regex._check_data_value(test_value)
             self.assertEqual(value, '')
@@ -32,9 +34,16 @@ class RegexTestCase(unittest.TestCase):
                 self.assertEqual(value, test_value)
 
     def test_can_override(self):
-        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$', max_length=15)
-        for test_varchar in [Varchar(max_length=64), Varchar(max_length=15), Varchar(max_length=9)]:
+        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$',
+                           max_length=15)
+        for test_varchar in [Varchar(), Varchar(max_length=15), Varchar(max_length=9)]:
             if test_regex.max_length == test_varchar.max_length:
                 self.assertTrue(test_regex.can_override(test_varchar))
             else:
                 self.assertFalse(test_regex.can_override(test_varchar))
+
+    def test_cant_override(self):
+        test_regex = Regex('^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$',
+                           max_length=15)
+        test_int = Integer()
+        self.assertFalse(test_regex.can_override(test_int))

tests/datahandlers/test_varchar.py

@@ -0,0 +1,27 @@
+import unittest
+
+from lodel.leapi.datahandlers.datas import Varchar, Integer
+
+
+class VarcharTestCase(unittest.TestCase):
+
+    def test_check_data_value(self):
+        test_varchar = Varchar(max_length=10)
+
+        _, error = test_varchar._check_data_value("c" * 10)
+        self.assertIsNone(error)
+
+        _, error = test_varchar._check_data_value("c" * 9)
+        self.assertIsNone(error)
+
+        _, error = test_varchar._check_data_value("c" * 11)
+        self.assertIsNotNone(error)
+        self.assertIsInstance(error, ValueError)
+
+    def test_can_override(self):
+        test_varchar1 = Varchar()
+        test_integer = Integer()
+        test_varchar2 = Varchar()
+
+        self.assertFalse(test_varchar1.can_override(test_integer))
+        self.assertTrue(test_varchar1.can_override(test_varchar2))