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()
