Merge remote-tracking branch 'origin/master'

lodel/plugin/core_scripts.py

+import operator
+import shutil
+import tempfile
+import os, os.path
 from lodel.context import LodelContext
 LodelContext.expose_modules(globals(), {
-    'lodel.plugin.scripts': 'lodel_script'})
+    'lodel.plugin.scripts': 'lodel_script',
+    'lodel.logger': 'logger'})
 
 ##@package lodel.plugin.core_scripts
 #@brief Lodel2 internal scripts declaration
 #@ingroup lodel2_script
 
 
-##@brief Implements lodel_admin.py **discover-plugin** action
+##@brief Implements lodel_admin.py list-plugins action
 #@ingroup lodel2_plugins
 #@ingroup lodel2_script
 #
-#In depth directory scan to find plugins in order to build a plugin list.
-class DiscoverPlugin(lodel_script.LodelScript):
-    _action = 'discover-plugin'
-    _description = 'Walk through given folders looking for plugins'
-    
+class ListPlugins(lodel_script.LodelScript):
+    _action = 'plugins-list'
+    _description = "List all installed plugins"
+
+    @classmethod
+    def argparser_config(cls, parser):
+        parser.add_argument('-v', '--verbose',
+            help="Display more informations on installed plugins",
+            action='store_true')
+        parser.add_argument('-c', '--csv',
+            help="Format output in CSV format",
+            action='store_true')
+
+    @classmethod
+    def run(cls, args):
+        import lodel.plugin.plugins
+        from lodel.plugin.plugins import Plugin
+        if args.verbose:
+            #_discover do not returns duplicated names
+            tmp_plist = Plugin._discover(lodel.plugin.plugins.PLUGINS_PATH)
+            plist = []
+            #ordering the list by plugin's name
+            for pname in sorted(set([d['name'] for d in tmp_plist])):
+                for pinfos in tmp_plist:
+                    if pinfos['name'] == pname:
+                        plist.append(pinfos)
+        else:
+            pdict = Plugin.discover()
+            #casting to a list ordered by names
+            plist = []
+            for pname in sorted(pdict.keys()):
+                plist.append(pdict[pname])
+        if args.csv:
+            if args.verbose:
+                res = "name,version,path\n"
+                fmt = "%s,%s,%s\n"
+            else:
+                res = "name,version\n"
+                fmt = "%s,%s\n"
+        else:
+            res = "Installed plugins list :\n"
+            if args.verbose:
+                fmt = "\t- %s(%s) in %s\n"
+            else:
+                fmt = "\t- %s(%s)\n"
+        for pinfos in plist:
+            if args.verbose:
+                res += fmt % (
+                    pinfos['name'], pinfos['version'], pinfos['path'])
+            else:
+                res += fmt % (pinfos['name'], pinfos['version'])
+        print(res)
+
+
+##@brief Handle install & uninstall of lodel plugins
+class PluginManager(lodel_script.LodelScript):
+    _action = 'plugins'
+    _description = "Install/Uninstall plugins"
+
     @classmethod
     def argparser_config(cls, parser):
-        #parser.add_argument('-d', '--directory',
-        parser.add_argument('PLUGIN_PATH',
-            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")
+        parser.add_argument('-u', '--uninstall',
+            help="Uninstall specified plugin",
+            action='store_true')
+        parser.add_argument('-c', '--clean',
+            help="Uninstall duplicated plugins with smallest version number",
+            action="store_true")
+        parser.add_argument('-n', '--plugin-name', nargs='*',
+            default = list(),
+            help="Indicate a plugin name to uninstall",
+            type=str)
+        parser.add_argument('-a', '--archive', nargs='*',
+            default = list(),
+            help="(NOT IMPLEMENTED) Specify a tarball containing a plugin \
+to install",
+            type=str)
+        parser.add_argument('-d', '--directory', nargs='*',
+            default = list(),
+            help="Specify a plugin by its directory",
+            type=str)
+        parser.add_argument('-f', '--force', action="store_true",
+            help="Force plugin directory deletion in case of check errors")
 
     @classmethod
     def run(cls, args):
+        if args.clean:
+            if args.uninstall or len(args.directory) > 0 \
+                    or len(args.archive) > 0:
+                raise RuntimeError("When using -c --clean option you can \
+only use option -n --name to clean plugins with specified names")
+            return cls.clean(args)
+        if args.uninstall:
+            return cls.uninstall(args)
+        return cls.install(args)
+    
+    ##@brief Handles plugins install
+    @classmethod
+    def install(cls, args):
+        import lodel.plugin.plugins
+        from lodel.plugin.plugins import Plugin
+        from lodel.plugin.exceptions import PluginError
+        if len(args.plugin_name) > 0:
+            raise RuntimeError("Unable to install a plugin from its name !\
+We do not know where to find it...")
+        plist = Plugin.discover()
+        errors = dict()
+        if len(args.archive) > 0:
+            raise NotImplementedError("Not supported yet")
+        
+        plugins_infos = {}
+        for cur_dir in args.directory:
+            try:
+                res = Plugin.dir_is_plugin(cur_dir, assert_in_package = False)
+                if res is False:
+                    errors[cur_dir] = PluginError("Not a plugin")
+                else:
+                    plugins_infos[res['name']] = res
+            except Exception as e:
+                errors[cur_dir] = e
+        #Abording because of previous errors
+        if len(errors) > 0:
+            msg = "Abording installation because of following errors :\n"
+            for path, expt in errors.items():
+                msg += ("\t- For path '%s' : %s\n" % (path, expt))
+            raise RuntimeError(msg)
+        #No errors continuing to install
+        for pname, pinfos in plugins_infos.items():
+            if pname in plist:
+                #Found an installed plugin with the same name
+                #Cehcking both versions
+                if plist[pname]['version'] == pinfos['version']:
+                    errors[pinfos['path']] = 'Abording installation of %s \
+found in %s because it seems to be allready installed in %s' % (
+    pname, pinfos['path'], plist[pname]['path'])
+                    continue
+                if plist[pname]['version'] > pinfos['version']:
+                    errors[pinfos['path']] = 'Abording installation of %s \
+found in %s because the same plugins with a greater version seems to be \
+installed in %s' % (pname, pinfos['path'], plist[pname]['path'])
+                    continue
+                logger.info("Found a plugin with the same name but with an \
+inferior version. Continuing to install")
+            #Checking that we can safely copy our plugin
+            dst_path = os.path.join(lodel.plugin.plugins.PLUGINS_PATH,
+                os.path.basename(os.path.dirname(pinfos['path'])))
+            orig_path = dst_path
+            if os.path.isdir(dst_path):
+                dst_path = tempfile.mkdtemp(
+                    prefix = os.path.basename(dst_path)+'_',
+                    dir = lodel.plugin.plugins.PLUGINS_PATH)
+                logger.warning("A plugin allready exists in %s. Installing \
+in %s" % (orig_path, dst_path))
+                shutil.rmtree(dst_path)
+                
+            #Installing the plugin
+            shutil.copytree(pinfos['path'], dst_path, symlinks = False)
+            print("%s(%s) installed in %s" % (
+                pname, pinfos['version'], dst_path))
+        if len(errors) > 0:
+            msg = "Following errors occurs during instalation process :\n"
+            for path, error_msg in errors.items():
+                msg += "\t- For '%s' : %s" % (path, error_msg)
+            print(msg)
+    
+    ##@brief Handles plugins uninstall
+    #@todo uninstall by path is broken
+    @classmethod
+    def uninstall(cls, args):
+        import lodel.plugin.plugins
         from lodel.plugin.plugins import Plugin
-        if args.PLUGIN_PATH is None or len(args.PLUGIN_PATH) == 0:
-            cls.help_exit("Specify a least one directory")
-        no_cache = args.list_only
-        res = Plugin.discover(args.PLUGIN_PATH, no_cache)
-        print("Found plugins in : %s" % ', '.join(args.PLUGIN_PATH))
-        for pname, pinfos in res['plugins'].items():
-            print("\t- %s(%s) in %s" % (
-                pname, pinfos['version'], pinfos['path']))
-            
+        if len(args.archive) > 0:
+            raise RuntimeError("Cannot uninstall plugin using -f --file \
+oprtions. Use -d --directory instead")
+        to_delete = dict() #Path to delete accumulator
+        errors = dict()
+        if len(args.directory) > 0:
+            #processing & checking -d --directory arguments
+            for path in args.directory:
+                apath = os.path.abspath(path)
+                if not apath.startswith(lodel.plugin.plugins.PLUGINS_PATH):
+                    errors[path] = "Not a subdir of %s"
+                    errors[path] %= lodel.plugin.plugins.PLUGINS_PATH
+                    continue
+                try:
+                    pinfos = Plugin.dir_is_plugin(apath)
+                except Exception as e:
+                    if not args.force:
+                        errors[path] = e
+                        continue
+                to_delete[path] = pinfos
+
+        if len(args.plugin_name) > 0:
+            #Processing -n --plugin-name arguments
+            plist = Plugin._discover(lodel.plugin.plugins.PLUGINS_PATH)
+            for pinfos in plist:
+                if pinfos['name'] in args.plugin_name:
+                    to_delete[pinfos['path']] = pinfos
+        
+        if len(errors) > 0:
+            msg = "Following errors detected before begining deletions :\n"
+            for path, errmsg in errors.items():
+                msg += "\t- For %s : %s" % (path, errmsg)
+            print(msg)
+            if not args.force:
+                exit(1)
+        
+        print("Begining deletion :")
+        for path, pinfos in to_delete.items():
+            #shutil.rmtree(path)
+            print("rm -R %s" % path)
+            print("\t%s(%s) in %s deleted" % (
+                pinfos['name'], pinfos['version'], pinfos['path']))
+
+    ##@brief Handles plugins clean
+    @classmethod
+    def clean(cls, args):
+        import lodel.plugin.plugins
+        from lodel.plugin.plugins import Plugin
+        if len(args.archive) > 0:
+            raise RuntimeError("Cannot specify plugins to uninstall using \
+-f --file option. You have to use -d --directory or -n --name")
+        if len(args.plugin_name) > 0:
+            names = args.plugin_name
+        else:
+            names = list(Plugin.discover().keys())
+        #_dicover do not remove duplicated names
+        full_list = Plugin._discover(lodel.plugin.plugins.PLUGINS_PATH)
+        #Casting into a dict with list of plugins infos
+        pdict = dict()
+        for pinfos in full_list:
+            if pinfos['name'] in names:
+                if pinfos['name'] in pdict:
+                    pdict[pinfos['name']].append(pinfos)
+                else:
+                    pdict[pinfos['name']] = [pinfos]
+        to_clean = list()
+        clean_count = 0
+        for pname, pinfos_l in pdict.items():
+            if len(pinfos_l) > 1:
+                #There are some plugins to clean
+                tmp_l = sorted(pinfos_l, key=lambda item: item['version'])
+                to_clean += tmp_l[:-1]
+                msg = "Found %s(%s). Cleaning " % (
+                    pname, tmp_l[-1]['version'])
+                for pinfos in to_clean:
+                    clean_count += 1
+                    str_info = '%s(%s)' % (pname, pinfos['version'])
+                    msg += "%s, " % (str_info)
+                    shutil.rmtree(pinfos['path'])
+                print(msg)
+        if clean_count > 0:
+            print("%d plugins were uninstalled" % clean_count)
+        else:
+            print("Allready clean")
+
+
 ##@brief Implements lodel_admin.py **hooks-list** action
 #@ingroup lodel2_script
 #@ingroup lodel2_hooks

lodel/plugin/plugins.py

 # - {{__init__.py}}} containing informations like full_name, authors, licence etc.
 # - main.py containing hooks registration etc
 # - confspec.py containing a configuration specification dictionary named CONFSPEC
+#
+# All plugins are expected to be found in multiple locations :
+# - in the lodel package (lodel.plugins)
+# - in the context directorie in a plugins/ dir (symlink to lodel.plugins) <-
+#this is obsolete now, since we enforce ALL plugins to be in the lodel package
+#
+#@todo Check if the symlink in the lodelcontext dir is obsolete !!!
+#@warning The plugins dir is at two locations : in lodel package and in
+#instance directory. Some stuff seems to still needs plugins to be in 
+#the instance directory but it seems to be a really bad idea...
 
 ##@defgroup plugin_init_specs Plugins __init__.py specifications
 #@ingroup lodel2_plugins
 PLUGIN_DEPS_VARNAME = '__plugin_deps__'
 ##@brief Name of the optionnal activate method
 ACTIVATE_METHOD_NAME = '_activate'
-##@brief Discover stage cache filename
-DISCOVER_CACHE_FILENAME = '.plugin_discover_cache.json'
 ##@brief Default & failover value for plugins path list
-DEFAULT_PLUGINS_PATH_LIST = [os.path.join(LodelContext.context_dir(),'plugins')]
+PLUGINS_PATH = os.path.join(LodelContext.context_dir(),'plugins')
 
 ##@brief List storing the mandatory variables expected in a plugin __init__.py
 #file
         if len(args) == 1:
             arg = args[0]
             if isinstance(arg, str):
+                #Casting from string to version numbers
                 spl = arg.split('.')
                 invalid = False
                 if len(spl) > 3:
                     raise PluginError("The string '%s' is not a valid plugin \
 version number" % arg)
+                if len(spl) < 3:
+                    spl += [ 0 for _ in range(3-len(spl))]
+                try:
+                    self.__version = [int(s) for s in spl]
+                except (ValueError, TypeError):
+                    raise PluginError("The string '%s' is not a valid lodel2 \
+plugin version number" % arg)
             else:
                 try:
                     if len(arg) >= 1:
                             raise PluginError("Expected maximum 3 value to \
 create a plugin version number but found '%s' as argument" % arg)
                         for i, v in enumerate(arg):
-                            self.__version[i] = arg[i]
-                except TypeError:
+                            self.__version[i] = int(arg[i])
+                except (TypeError, ValueError):
                     raise PluginError("Unable to convert argument into plugin \
 version number" % arg)
         elif len(args) > 3:
 but %d arguments found" % len(args))
         else: 
             for i,v in enumerate(args):
-                self.__version[i] = v
-    
+                self.__version[i] = int(v)
+
     ##@brief Property to access major version number
     @property
     def major(self):
             raise LodelFatalError("Invalid comparison callback given \
 to generic PluginVersion comparison function : '%s'" % cmp_fun_name)
         for property_name in self.PROPERTY_LIST:
-            if not cmpfun(getattr(self, pname), getattr(other, pname)):
-                return False
+            if not cmpfun(
+                    getattr(self, property_name),
+                    getattr(other, property_name)):
+                if property_name == self.PROPERTY_LIST[-1]:
+                    return False
         return True
 
     def __lt__(self, other):
         return '%d.%d.%d' % tuple(self.__version)
 
     def __repr__(self):
-        return {'major': self.major, 'minor': self.minor,
+        return "%s" % {'major': self.major, 'minor': self.minor,
             'revision': self.revision}
 
 ##@brief Plugin metaclass that allows to "catch" child class declaration
 # 3. the loader call load_all to register hooks etc
 class Plugin(object, metaclass=MetaPlugType):
     
-    ##@brief Stores plugin directories paths
-    _plugin_directories = None
-    
     ##@brief Stores Plugin instances indexed by name
     _plugin_instances = dict()
     
     ##@brief Attribute that stores plugins list from discover cache file
     _plugin_list = None
     
-    ##@brief Store dict representation of discover cache content
-    _discover_cache = None
-    
     #@brief Designed to store, in child classes, the confspec indicating \
     #where plugin list is stored
     _plist_confspecs = None
         self.loaded = False
         
         # Importing __init__.py infos in it
-        plugin_module = '%s.%s' % (VIRTUAL_PACKAGE_NAME,
-                                    plugin_name)
+        plugin_module = self.module_name()
         self.module = LodelContext.module(plugin_module)
 
         # loading confspecs
         module_name = self_modname+"."+base_mod
         return importlib.import_module(module_name)
    
+    ##@brief Return associated module name
+    def module_name(self):
+        if not self.path.startswith('./plugins'):
+            raise PluginError("Bad path for plugin %s : %s" % (
+                self.name, self.path))
+        mod_name = ''
+        pathbuff = self.path
+        while pathbuff != '.':
+            mod_name = os.path.basename(pathbuff) + '.' + mod_name
+            pathbuff = os.path.dirname(pathbuff)
+        #removing trailing '.' and add leading lodel.
+        return 'lodel.'+mod_name[:-1]
+
     ##@brief Check dependencies of plugin
     #@return A list of plugin name to be loaded before
     def check_deps(self):
             confspec_append(res, plcs)
         return res
 
-    ##@brief Attempt to read plugin discover cache
-    #@note If no cache yet make a discover with default plugin directory
-    #@return a dict (see @ref _discover() )
-    @classmethod
-    def plugin_cache(cls):
-        if cls._discover_cache is None:
-            if not os.path.isfile(DISCOVER_CACHE_FILENAME):
-                cls.discover()
-            with open(DISCOVER_CACHE_FILENAME) as pdcache_fd:
-                res = json.load(pdcache_fd)
-            #Check consistency of loaded cache
-            if 'path_list' not in res:
-                raise LodelFatalError("Malformed plugin's discover cache file \
-: '%s'. Unable to find plugin's paths list." % DISCOVER_CACHE_FILENAME)
-            expected_keys = ['type', 'path', 'version']
-            for pname in res['plugins']:
-                for ekey in expected_keys:
-                    if ekey not in res['plugins'][pname]:
-                        #Bad cache !
-                        logger.warning("Malformed plugin's discover cache \
-file : '%s'. Running discover again..." % DISCOVER_CACHE_FILENAME)
-                        cls._discover_cache = cls.discover(res['path_list'])
-                        break
-            else:
-                #The cache we just read was OK
-                cls._discover_cache = res
-                
-        return cls._discover_cache
-
     ##@brief Register a new plugin
     # 
     #@param plugin_name str : The plugin name
             msg %= plugin_name
             raise PluginError(msg)
         #Here we check that previous discover found a plugin with that name
-        pdcache = cls.plugin_cache()
-        if plugin_name not in pdcache['plugins']:
+        pdcache = cls.discover()
+        if plugin_name not in pdcache:
             raise PluginError("No plugin named %s found" % plugin_name)
-        pinfos = pdcache['plugins'][plugin_name]
-        ptype = pinfos['type']
+        ptype = pdcache[plugin_name]['type']
         pcls = MetaPlugType.type_from_name(ptype)
         plugin = pcls(plugin_name)
         cls._plugin_instances[plugin_name] = plugin
     # @return the plugin directory path
     @classmethod
     def plugin_path(cls, plugin_name):
-        
         plist = cls.plugin_list()
         if plugin_name not in plist:
             raise PluginError("No plugin named '%s' found" % plugin_name)
     #This module name is the "virtual" module where we imported the plugin.
     #
     #Typically composed like VIRTUAL_PACKAGE_NAME.PLUGIN_NAME
+    #@warning Brokes subdire feature
     #@param plugin_name str : a plugin name
     #@return a string representing a module name
+    #@todo fix broken subdir capabilitie ( @see module_name() )
+    #@todo check if used, else delete it
     @classmethod
     def plugin_module_name(cls, plugin_name):
         return "%s.%s" % (VIRTUAL_PACKAGE_NAME, plugin_name)
     ##@brief Attempt to "restart" the Plugin class
     @classmethod
     def clear(cls):
-        if cls._plugin_directories is not None:
-            cls._plugin_directories = None
         if cls._plugin_instances != dict():
             cls._plugin_instances = dict()
         if cls._load_called != []:
         pass
     
     ##@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
+    #found plugin in a static var
+    #
+    #Found plugins are stored in cls._plugin_list
+    #@note The discover is run only if no cached datas are found
+    #@return a list of dict with plugin infos { see @ref _discover }
+    #@todo add max_depth and no symlink following feature
     @classmethod
-    def discover(cls, paths = None, no_cache = False):
+    def discover(cls):
+        if cls._plugin_list is not None:
+            return cls._plugin_list
         logger.info("Running plugin discover")
-        if paths is None:
-            paths = DEFAULT_PLUGINS_PATH_LIST
-        tmp_res = []
-        for path in paths:
-            tmp_res += cls._discover(path)
+        tmp_res = cls._discover(PLUGINS_PATH)
         #Formating and dedoubloning result
         result = dict()
         for pinfos in tmp_res:
             else:
                 #dropped
                 pass
-        result = {'path_list': paths, 'plugins': result}
-        #Writing to cache
-        if not no_cache:
-            with open(DISCOVER_CACHE_FILENAME, 'w+') as pdcache:
-                pdcache.write(json.dumps(result))
+        cls._plugin_list = result
         return result
     
     ##@brief Return discover result
     #from the plugin's discover cache
     @classmethod
     def plugin_list(cls, refresh = False):
-        try:
-            infos = cls._load_discover_cache()
-            path_list = infos['path_list']
-        except PluginError:
-            refresh = True
-            path_list = DEFAULT_PLUGINS_PATH_LIST
-
-        if cls._plugin_list is None or refresh:
-            if not os.path.isfile(DISCOVER_CACHE_FILENAME) or refresh:
-                infos = cls.discover(path_list)
-        cls._plugin_list = infos['plugins']
         return cls._plugin_list
 
     ##@brief Return a list of child Class Plugin
     def plugin_types(cls):
         return MetaPlugType.all_types()
 
-    ##@brief Attempt to open and load plugin discover cache
-    #@return discover cache
-    #@throw PluginError when open or load fails
-    @classmethod
-    def _load_discover_cache(cls):
-        try:
-            pdcache = open(DISCOVER_CACHE_FILENAME, 'r')
-        except Exception as e:
-            msg = "Unable to open discover cache : %s"
-            msg %= e
-            raise PluginError(msg)
-        try:
-            res = json.load(pdcache)
-        except Exception as e:
-            msg = "Unable to load discover cache : %s"
-            msg %= e
-            raise PluginError(msg)
-        pdcache.close()
-        return res
-
     ##@brief Check if a directory is a plugin module
     #@param path str : path to check
+    #@param assert_in_package bool : if False didn't check that path is
+    #a subdir of PLUGINS_PATH
     #@return a dict with name, version and path if path is a plugin module, else False
     @classmethod
-    def dir_is_plugin(cls, path):
+    def dir_is_plugin(cls, path, assert_in_package = True):
         log_msg = "%s is not a plugin directory because : " % path
+        if assert_in_package:
+            #Check that path is a subdir of PLUGINS_PATH
+            abspath = os.path.abspath(path)
+            if not abspath.startswith(os.path.abspath(PLUGINS_PATH)):
+                raise PluginError(
+                    "%s is not a subdir of %s" % log_msg, PLUGINS_PATH)
         #Checks that path exists
         if not os.path.isdir(path):
             raise ValueError(
             ptype = DEFAULT_PLUGIN_TYPE
         pname = getattr(initmod, PLUGIN_NAME_VARNAME)
         return {'name': pname,
-            'version': pversion,
+            'version': PluginVersion(pversion),
             'path': path,
             'type': ptype}
     
                     #Check if it is a plugin directory
                     test_result = cls.dir_is_plugin(f_path)
                     if not (test_result is False):
-                        logger.info("Plugin found in %s" % f_path)
+                        logger.info("Plugin '%s' found in %s" % (
+                            test_result['name'],f_path))
                         res.append(test_result)
                     else:
                         to_explore.append(f_path)