def __init__(self, plugin_name, plugin_path): """ Set the basic information (at least name and path) about the plugin as well as the default values for other usefull variables. *plugin_name* is a simple string describing the name of the plugin. *plugin_path* describe the location where the plugin can be found. .. warning:: The ``path`` attribute is the full path to the plugin if it is organised as a directory or the full path to a file without the ``.py`` extension if the plugin is defined by a simple file. In the later case, the actual plugin is reached via ``plugin_info.path+'.py'``. """ self.__details = ConfigParser() self.name = plugin_name self.path = plugin_path self._ensureDetailsDefaultsAreBackwardCompatible() # Storage for stuff created during the plugin lifetime self.plugin_object = None self.categories = [] self.error = None
def testConfigurationFileExistence(self): """ Test if the configuration file has been properly written. """ # activate the only loaded plugin self.plugin_activate() # get rid of the plugin manager and create a new one del self.pluginManager del self.config_parser self.config_parser = ConfigParser() self.config_parser.read(self.config_file) self.assertTrue(self.config_parser.has_section("Plugin Management")) self.assertTrue( self.config_parser.has_option("Plugin Management", "default_plugins_to_load")) self.pluginManager = ConfigurablePluginManager( directories_list=[ os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins") ], plugin_info_ext="yapsy-config-plugin", configparser_instance=self.config_parser, config_change_trigger=self.update_config) self.pluginManager.collectPlugins() self.plugin_loading_check() self.assertTrue(self.plugin_info.plugin_object.is_activated) self.pluginManager.deactivatePluginByName(self.plugin_info.name, self.plugin_info.category) # check that activating the plugin once again, won't cause an error self.pluginManager.activatePluginByName(self.plugin_info.name, self.plugin_info.category) # Will be used later self.plugin_info = None
def getPluginNameAndModuleFromStream(self, infoFileObject, candidate_infofile=None): """ Extract the name and module of a plugin from the content of the info file that describes it and which is stored in ``infoFileObject``. .. note:: Prefer using ``_extractCorePluginInfo`` instead, whenever possible... .. warning:: ``infoFileObject`` must be a file-like object: either an opened file for instance or a string buffer wrapped in a StringIO instance as another example. .. note:: ``candidate_infofile`` must be provided whenever possible to get better error messages. Return a 3-uple with the name of the plugin, its module and the config_parser used to gather the core data *in a tuple*, if the required info could be localised, else return ``(None,None,None)``. .. note:: This is supposed to be used internally by subclasses and decorators. """ # parse the information buffer to get info about the plugin config_parser = ConfigParser() try: if is_py2: config_parser.readfp(infoFileObject) else: config_parser.read_file(infoFileObject) except Exception as e: log.debug( "Could not parse the plugin file '%s' (exception raised was '%s')" % (candidate_infofile, e)) return (None, None, None) # check if the basic info is available if not config_parser.has_section("Core"): log.debug("Plugin info file has no 'Core' section (in '%s')" % candidate_infofile) return (None, None, None) if not config_parser.has_option( "Core", "Name") or not config_parser.has_option( "Core", "Module"): log.debug( "Plugin info file has no 'Name' or 'Module' section (in '%s')" % candidate_infofile) return (None, None, None) # check that the given name is valid name = config_parser.get("Core", "Name") name = name.strip() if PLUGIN_NAME_FORBIDEN_STRING in name: log.debug("Plugin name contains forbiden character: %s (in '%s')" % (PLUGIN_NAME_FORBIDEN_STRING, candidate_infofile)) return (None, None, None) return (name, config_parser.get("Core", "Module"), config_parser)
def __init__(self, plugin_name, plugin_path): self.__details = ConfigParser() self.name = plugin_name self.path = plugin_path self._ensureDetailsDefaultsAreBackwardCompatible() # Storage for stuff created during the plugin lifetime self.plugin_object = None self.categories = [] self.error = None
def setUp(self): """ init """ # create a config file self.config_parser = ConfigParser() self.plugin_info = None # create the plugin manager self.pluginManager = ConfigurablePluginManager( directories_list=[ os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins") ], plugin_info_ext="yapsy-config-plugin", configparser_instance=self.config_parser) # load the plugins that may be found self.pluginManager.collectPlugins()
def testDetailsAccessors(self): pi = PluginInfo("mouf","/bla/mouf") details = ConfigParser() details.add_section("Core") details.set("Core","Name","hop") details.set("Core","Module","/greuh") details.add_section("Documentation") details.set("Documentation","Author","me") pi.details = details # Beware this is not so obvious: the plugin info still points # (and possibly modifies) the same instance of ConfigParser self.assertEqual(details,pi.details) # also the name and path are kept to their original value when # the details is set in one go. self.assertEqual("mouf",pi.name) self.assertEqual("/bla/mouf",pi.path) # check that some other info do change... self.assertEqual("me",pi.author)
def setUp(self): """ init """ # create a config file self.config_file = self.CONFIG_FILE self.config_parser = ConfigParser() self.plugin_info = None # create the plugin manager PluginManagerSingleton.setBehaviour( [ConfigurablePluginManager, VersionedPluginManager]) pluginManager = PluginManagerSingleton.get() pluginManager.setPluginPlaces( directories_list=[os.path.dirname(os.path.abspath(__file__))]) pluginManager.setPluginInfoExtension("yapsy-config-plugin") pluginManager.setConfigParser(self.config_parser, self.update_config) # load the plugins that may be found pluginManager.collectPlugins()
def getInfosDictFromPlugin(self, dirpath, filename): """ Returns the extracted plugin informations as a dictionary. This function ensures that "name" and "path" are provided. """ # use the filename alone to extract minimal informations. infos = {} module_name = os.path.splitext(filename)[0] plugin_filename = os.path.join(dirpath, filename) if module_name == "__init__": module_name = os.path.basename(dirpath) plugin_filename = dirpath infos["name"] = "%s" % module_name infos["path"] = plugin_filename cf_parser = ConfigParser() cf_parser.add_section("Core") cf_parser.set("Core", "Name", infos["name"]) cf_parser.set("Core", "Module", infos["path"]) return infos, cf_parser
def getInfosDictFromPlugin(self, dirpath, filename): return {"name": filename, "path": dirpath}, ConfigParser()