def testTwoStepsLoad(self): """ Test loading the plugins in two steps in order to collect more deltailed informations. """ spm = PluginManager(directories_list=[ os.path.join( os.path.dirname(os.path.abspath(__file__)),"plugins")]) # trigger the first step to look up for plugins spm.locatePlugins() # make full use of the "feedback" the loadPlugins can give # - set-up the callback function that will be called *before* # loading each plugin callback_infos = [] def preload_cbk(plugin_info): callback_infos.append(plugin_info) # - gather infos about the processed plugins (loaded or not) loadedPlugins = spm.loadPlugins(callback=preload_cbk) self.assertEqual(len(loadedPlugins),1) self.assertEqual(len(callback_infos),1) self.assertEqual(loadedPlugins[0].error,None) self.assertEqual(loadedPlugins[0],callback_infos[0]) # check that the getCategories works self.assertEqual(len(spm.getCategories()),1) sole_category = spm.getCategories()[0] # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),1) plugin_info = spm.getPluginsOfCategory(sole_category)[0] # try to remove it and check that is worked spm.removePluginFromCategory(plugin_info,sole_category) self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),0) # now re-add this plugin the to same category spm.appendPluginToCategory(plugin_info,sole_category) self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),1)
def testTwoStepsLoadWithError(self):
"""
Test loading the plugins in two steps in order to collect more
deltailed informations and take care of an erroneous plugin.
"""
spm = PluginManager(directories_list=[
os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
],
plugin_info_ext="yapsy-error-plugin")
# trigger the first step to look up for plugins
spm.locatePlugins()
# make full use of the "feedback" the loadPlugins can give
# - set-up the callback function that will be called *before*
# loading each plugin
callback_infos = []
def preload_cbk(i_plugin_info):
callback_infos.append(i_plugin_info)
callback_after_infos = []
def postload_cbk(i_plugin_info):
callback_after_infos.append(i_plugin_info)
# - gather infos about the processed plugins (loaded or not)
# and for the test, monkey patch the logger
originalLogLevel = log.getEffectiveLevel()
log.setLevel(logging.ERROR)
errorLogCallFlag = [False]
def errorMock(*args, **kwargs):
errorLogCallFlag[0] = True
originalErrorMethod = log.error
log.error = errorMock
try:
loadedPlugins = spm.loadPlugins(callback=preload_cbk,
callback_after=postload_cbk)
finally:
log.setLevel(originalLogLevel)
log.error = originalErrorMethod
self.assertTrue(errorLogCallFlag[0])
self.assertEqual(len(loadedPlugins), 1)
self.assertEqual(len(callback_infos), 1)
self.assertTrue(isinstance(callback_infos[0].error, tuple))
self.assertEqual(loadedPlugins[0], callback_infos[0])
self.assertTrue(issubclass(callback_infos[0].error[0], ImportError))
self.assertEqual(len(callback_after_infos), 0)
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 0)
def testMultipleCategoriesForASamePlugin(self):
"""
Test that associating a plugin to multiple categories works as expected.
"""
class AnotherPluginIfce(object):
def __init__(self):
pass
def activate(self):
pass
def deactivate(self):
pass
spm = PluginManager(categories_filter={
"Default": IPlugin,
"IP": IPlugin,
"Other": AnotherPluginIfce,
},
directories_list=[
os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"plugins")
])
# load the plugins that may be found
spm.collectPlugins()
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 3)
categories = spm.getCategories()
self.assertTrue("Default" in categories)
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory("Default")), 1)
plugin_info = spm.getPluginsOfCategory("Default")[0]
self.assertTrue("Default" in plugin_info.categories)
self.assertTrue("IP" in plugin_info.categories)
self.assertTrue("IP" in categories)
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1)
self.assertTrue("Other" in categories)
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory("Other")), 0)
# try to remove the plugin from one category and check the
# other category
spm.removePluginFromCategory(plugin_info, "Default")
self.assertEqual(len(spm.getPluginsOfCategory("Default")), 0)
self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1)
# now re-add this plugin the to same category
spm.appendPluginToCategory(plugin_info, "Default")
self.assertEqual(len(spm.getPluginsOfCategory("Default")), 1)
self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1)
class ExtInfoTest(unittest.TestCase):
def setUp(self):
# create the plugin manager - use the base plugin manager to
# remove any unecessary dependencies
self.simplePluginManager = PluginManager(directories_list=[
os.path.join(
os.path.dirname(os.path.abspath(__file__)),"Plugins")
],
plugin_info_ext="mm-plugin",
)
#Set mode to test info class
self.simplePluginManager.setPluginInfoClass(ExtensionInfo)
# load the plugins that may be found
self.simplePluginManager.collectPlugins()
# Will be used later
self.plugin_info = None
def loading_check(self):
"""
Test the plugins load.
"""
if self.plugin_info is None:
# check nb of categories
self.assertEqual(len(self.simplePluginManager.getCategories()),1)
sole_category = self.simplePluginManager.getCategories()[0]
# check the number of plugins
self.assertEqual(len(self.simplePluginManager.getPluginsOfCategory(sole_category)),2)
self.plugin_info = [ None , None ]
self.plugin_info[0] = self.simplePluginManager.getPluginsOfCategory(sole_category)[0]
self.plugin_info[1] = self.simplePluginManager.getPluginsOfCategory(sole_category)[1]
# test that the name of the plugin has been correctly defined
self.assertTrue("FirstPlugin" in [x.name for x in self.plugin_info])
self.assertEqual(sole_category,self.plugin_info[0].category)
else:
self.assert_(True)
def testBasic(self):
self.loading_check()
def testKnownHash(self):
"""
Test hash can be fetched thru ExtensionInfo
"""
self.loading_check()
hash1=ExtensionSecureID.fromPathName(self.plugin_info[0].path+".py")
self.assertEquals(hash1,self.plugin_info[0].getSecureID())
self.assertNotEquals(self.plugin_info[0].getSecureID(),self.plugin_info[1].getSecureID())
def testRecursivePluginlocation(self): """ Test detection of plugins which by default must be recusrive. Here we give the test directory as a plugin place whereas we expect the plugins to be in test/plugins. """ spm = PluginManager(directories_list=[ os.path.dirname(os.path.abspath(__file__))]) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()),1) sole_category = spm.getCategories()[0] # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),1)
def testRecursivePluginlocation(self):
"""
Test detection of plugins which by default must be
recusrive. Here we give the test directory as a plugin place
whereas we expect the plugins to be in test/plugins.
"""
spm = PluginManager(
directories_list=[os.path.dirname(os.path.abspath(__file__))])
# load the plugins that may be found
spm.collectPlugins()
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
def test_init_with_plugin_locator(self):
class SpecificLocator(IPluginLocator):
pass
pm = PluginManager(plugin_locator=SpecificLocator())
self.assertEqual(["Default"], pm.getCategories())
self.assertTrue(isinstance(pm.getPluginLocator(), SpecificLocator))
def testMultipleCategoriesForASamePlugin(self):
"""
Test that associating a plugin to multiple categories works as expected.
"""
class AnotherPluginIfce(object):
def __init__(self):
pass
def activate(self):
pass
def deactivate(self):
pass
spm = PluginManager(
categories_filter = {
"Default": IPlugin,
"IP": IPlugin,
"Other": AnotherPluginIfce,
},
directories_list=[
os.path.join(
os.path.dirname(os.path.abspath(__file__)),"plugins")])
# load the plugins that may be found
spm.collectPlugins()
# check that the getCategories works
self.assertEqual(len(spm.getCategories()),3)
categories = spm.getCategories()
self.assertTrue("Default" in categories)
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory("Default")), 1)
plugin_info = spm.getPluginsOfCategory("Default")[0]
self.assertTrue("Default" in plugin_info.categories)
self.assertTrue("IP" in plugin_info.categories)
self.assertTrue("IP" in categories)
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory("IP")),1)
self.assertTrue("Other" in categories)
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory("Other")),0)
# try to remove the plugin from one category and check the
# other category
spm.removePluginFromCategory(plugin_info, "Default")
self.assertEqual(len(spm.getPluginsOfCategory("Default")), 0)
self.assertEqual(len(spm.getPluginsOfCategory("IP")), 1)
# now re-add this plugin the to same category
spm.appendPluginToCategory(plugin_info, "Default")
self.assertEqual(len(spm.getPluginsOfCategory("Default")),1)
self.assertEqual(len(spm.getPluginsOfCategory("IP")),1)
def testTwoStepsLoadWithError(self):
"""
Test loading the plugins in two steps in order to collect more
deltailed informations and take care of an erroneous plugin.
"""
spm = PluginManager(
directories_list=[os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")],
plugin_info_ext="yapsy-error-plugin",
)
# trigger the first step to look up for plugins
spm.locatePlugins()
# make full use of the "feedback" the loadPlugins can give
# - set-up the callback function that will be called *before*
# loading each plugin
callback_infos = []
def preload_cbk(i_plugin_info):
callback_infos.append(i_plugin_info)
# - gather infos about the processed plugins (loaded or not)
# and for the test, monkey patch the logger
originalLogLevel = log.getEffectiveLevel()
log.setLevel(logging.ERROR)
errorLogCallFlag = [False]
def errorMock(*args, **kwargs):
errorLogCallFlag[0] = True
originalErrorMethod = log.error
log.error = errorMock
try:
loadedPlugins = spm.loadPlugins(callback=preload_cbk)
finally:
log.setLevel(originalLogLevel)
log.error = originalErrorMethod
self.assertTrue(errorLogCallFlag[0])
self.assertEqual(len(loadedPlugins), 1)
self.assertEqual(len(callback_infos), 1)
self.assertTrue(isinstance(callback_infos[0].error, tuple))
self.assertEqual(loadedPlugins[0], callback_infos[0])
self.assertEqual(callback_infos[0].error[0], ImportError)
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 0)
def testTwoStepsLoad(self):
"""
Test loading the plugins in two steps in order to collect more
deltailed informations.
"""
spm = PluginManager(directories_list=[
os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
])
# trigger the first step to look up for plugins
spm.locatePlugins()
# make full use of the "feedback" the loadPlugins can give
# - set-up the callback function that will be called *before*
# loading each plugin
callback_infos = []
def preload_cbk(plugin_info):
callback_infos.append(plugin_info)
callback_after_infos = []
def postload_cbk(plugin_info):
callback_after_infos.append(plugin_info)
# - gather infos about the processed plugins (loaded or not)
loadedPlugins = spm.loadPlugins(callback=preload_cbk,
callback_after=postload_cbk)
self.assertEqual(len(loadedPlugins), 1)
self.assertEqual(len(callback_infos), 1)
self.assertEqual(loadedPlugins[0].error, None)
self.assertEqual(loadedPlugins[0], callback_infos[0])
self.assertEqual(len(callback_after_infos), 1)
self.assertEqual(loadedPlugins[0], callback_infos[0])
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
plugin_info = spm.getPluginsOfCategory(sole_category)[0]
# try to remove it and check that is worked
spm.removePluginFromCategory(plugin_info, sole_category)
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 0)
# now re-add this plugin the to same category
spm.appendPluginToCategory(plugin_info, sole_category)
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
def testNonRecursivePluginlocationNotFound(self):
"""
Test detection of plugins when the detection is non recursive.
Here we test that it cannot look into subdirectories of the
test directory.
"""
pluginLocator = PluginFileLocator()
pluginLocator.setPluginPlaces(
[os.path.dirname(os.path.abspath(__file__))])
pluginLocator.disableRecursiveScan()
spm = PluginManager()
spm.setPluginLocator(pluginLocator)
# load the plugins that may be found
spm.collectPlugins()
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 0)
def testNonRecursivePluginlocationNotFound(self): """ Test detection of plugins when the detection is non recursive. Here we test that it cannot look into subdirectories of the test directory. """ pluginLocator = PluginFileLocator() pluginLocator.setPluginPlaces([ os.path.dirname(os.path.abspath(__file__))]) pluginLocator.disableRecursiveScan() spm = PluginManager() spm.setPluginLocator(pluginLocator) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()),1) sole_category = spm.getCategories()[0] # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),0)
def testDisablingRecursivePluginLocationAllowsFindingTopLevelPlugins(self):
"""
Test detection of plugins when the detection is non
recursive. Here we test that if we give test/plugin as the
directory to scan it can find the plugin.
"""
pluginLocator = PluginFileLocator()
pluginLocator.setPluginPlaces([
os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
])
pluginLocator.disableRecursiveScan()
spm = PluginManager()
spm.setPluginLocator(pluginLocator)
# load the plugins that may be found
spm.collectPlugins()
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
def testCategoryManipulation(self): """ Test querying, removing and adding plugins from/to a category. """ spm = PluginManager(directories_list=[ os.path.join( os.path.dirname(os.path.abspath(__file__)),"plugins")]) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()),1)
def testDisablingRecursivePluginLocationAllowsFindingTopLevelPlugins(self): """ Test detection of plugins when the detection is non recursive. Here we test that if we give test/plugin as the directory to scan it can find the plugin. """ pluginLocator = PluginFileLocator() pluginLocator.setPluginPlaces([ os.path.join( os.path.dirname(os.path.abspath(__file__)),"plugins")]) pluginLocator.disableRecursiveScan() spm = PluginManager() spm.setPluginLocator(pluginLocator) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()),1) sole_category = spm.getCategories()[0] # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),1)
def testCategoryManipulation(self):
"""
Test querying, removing and adding plugins from/to a category.
"""
spm = PluginManager(directories_list=[
os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
])
# load the plugins that may be found
spm.collectPlugins()
# check that the getCategories works
self.assertEqual(len(spm.getCategories()), 1)
sole_category = spm.getCategories()[0]
# check the getPluginsOfCategory
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
plugin_info = spm.getPluginsOfCategory(sole_category)[0]
# try to remove it and check that is worked
spm.removePluginFromCategory(plugin_info, sole_category)
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 0)
# now re-add this plugin the to same category
spm.appendPluginToCategory(plugin_info, sole_category)
self.assertEqual(len(spm.getPluginsOfCategory(sole_category)), 1)
def testCategoryManipulation(self): """ Test querying, removing and adding plugins from/to a category. """ spm = PluginManager(directories_list=[ os.path.join( os.path.dirname(os.path.abspath(__file__)),"plugins")]) # load the plugins that may be found spm.collectPlugins() # check that the getCategories works self.assertEqual(len(spm.getCategories()),1) sole_category = spm.getCategories()[0] # check the getPluginsOfCategory self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),1) plugin_info = spm.getPluginsOfCategory(sole_category)[0] # try to remove it and check that is worked spm.removePluginFromCategory(plugin_info,sole_category) self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),0) # now re-add this plugin the to same category spm.appendPluginToCategory(plugin_info,sole_category) self.assertEqual(len(spm.getPluginsOfCategory(sole_category)),1)
def testChangingCategoriesFilter(self):
"""
Test the effect of setting a new category filer.
"""
spm = PluginManager(directories_list=[
os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
])
# load the plugins that may be found
spm.collectPlugins()
newCategory = "Mouf"
# Pre-requisite for the test
previousCategories = spm.getCategories()
self.assertTrue(len(previousCategories) >= 1)
self.assertTrue(newCategory not in previousCategories)
# change the category and see what's happening
spm.setCategoriesFilter({newCategory: IPlugin})
spm.collectPlugins()
for categoryName in previousCategories:
self.assertRaises(KeyError, spm.getPluginsOfCategory, categoryName)
self.assertTrue(len(spm.getPluginsOfCategory(newCategory)) >= 1)
def testChangingCategoriesFilter(self):
"""
Test the effect of setting a new category filer.
"""
spm = PluginManager(directories_list=[
os.path.join(
os.path.dirname(os.path.abspath(__file__)),"plugins")])
# load the plugins that may be found
spm.collectPlugins()
newCategory = "Mouf"
# Pre-requisite for the test
previousCategories = spm.getCategories()
self.assertTrue(len(previousCategories) >= 1)
self.assertTrue(newCategory not in previousCategories)
# change the category and see what's happening
spm.setCategoriesFilter({newCategory: IPlugin})
spm.collectPlugins()
for categoryName in previousCategories:
self.assertRaises(KeyError, spm.getPluginsOfCategory, categoryName)
self.assertTrue(len(spm.getPluginsOfCategory(newCategory)) >= 1)
class WeaponSystem(rpyc.Service):
'''
RPC Services: This is the code that does the actual password cracking
and returns the results to orbital control. Currently only supports
cracking using rainbow tables (RCrackPy)
'''
is_initialized = False
mutex = Lock()
is_busy = False
job_id = None
def initialize(self):
''' Initializes variables, this should only be called once '''
logging.info("Weapon system initializing ...")
self.plugin_manager = PluginManager()
self.plugin_manager.setPluginPlaces(["plugins/"])
self.plugin_manager.setCategoriesFilter(FILTERS)
self.plugin_manager.collectPlugins()
self.plugins = {}
logging.info(
"Loaded %d plugin(s)" % len(self.plugin_manager.getAllPlugins())
)
self.__cpu__()
logging.info("Weapon system online, good hunting.")
@atomic
def on_connect(self):
''' Called when successfully connected '''
if not self.is_initialized:
self.initialize()
self.is_initialized = True
logging.info("Uplink to orbital control active")
def on_disconnect(self):
''' Called if the connection is lost/disconnected '''
logging.info("Disconnected from orbital command server.")
def __cpu__(self):
''' Detects the number of CPU cores on a system (including virtual cores) '''
if cpu_count is not None:
try:
self.cpu_cores = cpu_count()
logging.info("Detected %d CPU core(s)" % self.cpu_cores)
except NotImplementedError:
logging.error("Could not detect number of processors; assuming 1")
self.cpu_cores = 1
else:
try:
self.cpu_cores = int(sysconf("SC_NPROCESSORS_CONF"))
logging.info("Detected %d CPU core(s)" % self.cpu_cores)
except ValueError:
logging.error("Could not detect number of processors; assuming 1")
self.cpu_cores = 1
############################ [ EXPOSED METHODS ] ############################
@atomic
def exposed_crack(self, plugin_name, job_id, hashes, **kwargs):
''' Exposes plugins calls '''
assert plugin_name in self.plugins
self.is_busy = True
self.job_id = job_id
self.plugin_manager.activatePluginByName(plugin_name)
plugin = self.plugin_manager.getPluginByName(plugin_name)
results = plugin.execute(hashes, **kwargs)
self.plugin_manager.deactivatePluginByName(plugin_name)
self.job_id = None
self.is_busy = False
return results
def exposed_get_plugin_names(self):
''' Returns what algorithms can be cracked '''
logging.info("Method called: exposed_get_capabilities")
plugins = self.plugin_manager.getAllPlugins()
return [plugin.name for plugin in plugins]
def exposed_get_categories(self):
''' Return categories for which we have plugins '''
categories = []
for category in self.plugin_manager.getCategories():
if 0 < len(self.plugin_manager.getPluginsOfCategory(category)):
categories.append(category)
return categories
def exposed_get_category_plugins(self, category):
''' Get plugin names for a category '''
plugins = self.plugin_manager.getPluginsOfCategory(category)
return [plugin.name for plugin in plugins]
def exposed_get_plugin_details(self, category, plugin_name):
''' Get plugin based on name details '''
plugin = self.plugin_manager.getPluginByName(plugin_name, category)
info = {'name': plugin.name}
info['author'] = plugin.details.get('Documentation', 'author')
info['website'] = plugin.details.get('Documentation', 'website')
info['version'] = plugin.details.get('Documentation', 'version')
info['description'] = plugin.details.get('Documentation', 'description')
info['copyright'] = plugin.details.get('Documentation', 'copyright')
info['precomputation'] = plugin.details.getboolean('Core', 'precomputation')
return info
def exposed_ping(self):
''' Returns a pong message '''
return "PONG"
def exposed_is_busy(self):
''' Returns True/False if the current system is busy (thread safe) '''
return self.is_busy
def exposed_current_job_id(self):
''' Returns the current job id (thread safe) '''
return self.job_id
def exposed_cpu_count(self):
''' Returns the number of detected cpu cores '''
return self.cpu_cores
def test_init_with_category_filter(self):
pm = PluginManager(categories_filter={"Mouf": IPlugin})
self.assertEqual(["Mouf"], pm.getCategories())
self.assertTrue(isinstance(pm.getPluginLocator(), PluginFileLocator))
def test_init_with_plugin_info_ext(self):
pm = PluginManager(plugin_info_ext="bla")
self.assertEqual(["Default"], pm.getCategories())
self.assertTrue(isinstance(pm.getPluginLocator(), PluginFileLocator))
class Plugins():
"""
Class responsible to manage the plugins
"""
categories = [
[
"SitePreparsing", SitePreparsing,
"Site wide plugins that execute before the parsing start."
],
[
"SiteProcessor", SiteProcessor,
"Plugins that process the whole site once after parsing."
],
[
"SiteRendering", SiteRendering,
"Plugins that render additional pages after the rendering."
],
[
"PostProcessor", PostProcessor,
"Plugins that process each post after they are parsed"
],
[
"CollectionProcessor", CollectionProcessor,
"Plugins that process each collection after posts are parsed"
],
[
"TemplateFilter", TemplateFilter,
"Plugins that define jinja2 filters to be used in templates"
],
]
# for plugin info structure
PLUGIN_CAT = 0
PLUGIN_NAME = 1
PLUGIN_DESC = 2
PLUGIN_ENABLE = 3
PLUGIN_MODULE_NAME = 4
PLUGIN_VERSION = 5
def __init__(self, plugin_directories, debug_log_fname, plugins_config):
"Load plugins"
categories_filter = {}
for cat in self.categories:
categories_filter[cat[0]] = cat[1]
# single or multi-directory handling
if not isinstance(plugin_directories, list):
plugin_directories = [plugin_directories]
self.plugins = PluginManager(plugin_info_ext='sitefab-plugin',
categories_filter=categories_filter)
self.plugins.setPluginPlaces(plugin_directories)
self.plugins.locatePlugins()
self.plugins.loadPlugins()
self.plugins_config = plugins_config
# List of enabled plugins
self.plugins_enabled = {}
for pl in self.get_plugins_info():
if pl[self.PLUGIN_ENABLE]:
self.plugins_enabled[pl[self.PLUGIN_MODULE_NAME]] = 1
# list of plugins already executed. Used for dependencies tracking
# across stages
self.plugins_executed = {}
# FIXME: make sure it is working
# logging.basicConfig(filename=debug_log_fname, level=logging.DEBUG)
def get_plugins(self, category=None):
"""Return the list of plugins
:param str category: restrict to plugins of a given category
:rtype: list(iPlugin)
:return: list of plugins
"""
if category:
return self.plugins.getPluginsOfCategory(category)
else:
return self.plugins.getAllPlugins()
def get_num_plugins(self, category=None):
""" Return the number of plugins available.
:param str category: restrict to plugins of given category
:rtype: int
:return: number of plugins
"""
plugins = self.get_plugins(category)
return len(plugins)
def get_plugin_dir(self, plugin):
""" Return the directory where the plugin is stored
:param iPlugin plugin: the plugin requested
:rtype: str
:return: the module name
"""
module_path = Path(plugin.details.get("Core", "module"))
return module_path.parent
def get_plugin_default_configuration_filename(self, plugin):
""" Return the path to the plugin default configuration filename
"""
try:
fname = plugin.details.get("Configuration", "Filename")
except: # noqa
return ""
fname = fname.replace('"', '')
path = self.get_plugin_dir(plugin)
return path / fname
def get_plugin_documentation_filename(self, plugin):
""" Return the path to the plugin documentation
"""
try:
fname = plugin.details.get("Documentation", "Filename")
except: # noqa
return ""
path = self.get_plugin_dir(plugin)
return path / fname
def get_plugin_class_name(self, plugin):
""" Return the class of a given plugin
:param iPlugin plugin: the plugin requested
:rtype: str
:return: the module classname
"""
return plugin.categories[0]
def get_plugin_module_name(self, plugin):
""" Return the module name of a given plugin
:param iPlugin plugin: the plugin requested
:rtype: str
:return: the module name
"""
module_path = plugin.details.get("Core", "module")
path, filename = os.path.split(module_path)
return filename
def get_plugin_config(self, plugin):
""" Return the configuration of a given plugin
:param iPlugin plugin: the plugin requested
:rtype: dict
:return: plugin configuration
"""
module_name = self.get_plugin_module_name(plugin)
class_name = self.get_plugin_class_name(plugin)
try:
config = self.plugins_config[class_name][module_name]
except: # noqa
config = {}
return config
def get_plugin_dependencies(self, plugin):
""" Return the dependency of a given plugin
:param iPlugin plugin: the plugin requested
:rtype: list
:return: list of plugins name the plugin depend on
"""
# No dependencies
if not plugin.details.has_option("Core", "Dependencies"):
return set()
dependencies = set()
st = plugin.details.get("Core", "Dependencies")
if "," in st:
elts = st.split(",")
for elt in elts:
dependencies.add(elt.strip())
else:
dependencies.add(st)
return dependencies
def is_plugin_enabled(self, plugin):
config = self.get_plugin_config(plugin)
if config.get('enable'):
return True
else:
return False
def get_plugins_info(self, category=None):
"""Return the list of plugins available with their type
:param str category: restrict to plugins of a given category.
:rtype: list(str)
:return: list of plugins name
"""
pl = []
if category:
categories = [category]
else:
categories = self.plugins.getCategories()
for cat in categories:
for plugin in self.plugins.getPluginsOfCategory(cat):
enabled = self.is_plugin_enabled(plugin)
module_name = self.get_plugin_module_name(plugin)
try:
version = plugin.version
except: # noqa
version = "NA"
s = [
cat, plugin.name, plugin.description, enabled, module_name,
version
]
pl.append(s)
return pl
def display_execution_results(self, results, site):
""" Display execution summary
"""
cprint("|-Execution result", "magenta")
table_data = [['name', 'ok', 'skipped', 'errors']]
count = 0
for result in results:
row = []
plugin_name, stats = result
# plugin name
c = "cyan"
if count % 2:
c = "blue"
row.append(colored(plugin_name, c))
# ok
if stats[site.OK]:
if stats[site.OK] == 1:
val = 'v'
else:
val = stats[site.OK]
row.append(colored(val, 'green'))
else:
row.append(' ')
# warning
if stats[site.SKIPPED]:
row.append(colored(stats[site.SKIPPED], "yellow"))
else:
row.append(' ')
# error
if stats[site.ERROR]:
if stats[site.ERROR] == 1:
val = 'x'
else:
val = stats[site.ERROR]
row.append(colored(val, "red"))
else:
row.append(' ')
table_data.append(row)
count += 1
print(SingleTable(table_data).table)
def run_plugins(self, items, plugin_class, unit, site):
"""Execute a set of plugins on a given list of items
:param list items: list of items to process
:param str plugin_type: the plugin_class to use
:param str unit: the unit to use in the display
:param SiteFab site: pointer to the site object to be passed
to the plugins
:rtype: dict(dict(list))
:return: plugins execution statistics
"""
# dependencies map
dependencie_map = {}
# used to get back from the module name to the plugin
module_name_to_plugin = {}
plugins = self.plugins.getPluginsOfCategory(plugin_class)
# collecting plugins that are to be executed.
for plugin in plugins:
if self.is_plugin_enabled(plugin):
module_name = self.get_plugin_module_name(plugin)
module_name_to_plugin[module_name] = plugin
# dependencies computation.
# Due to potential dependencies on plugins from previous stage
# this must be computed after collecting which
# plugins were executed.
for plugin in module_name_to_plugin.values():
all_dependencies = self.get_plugin_dependencies(plugin)
dependencies = set() # topological sort requires use of set
module_name = self.get_plugin_module_name(plugin)
for dep_module_name in all_dependencies:
if dep_module_name not in self.plugins_enabled:
utils.error("Plugin:%s can't be executed because\
plugin %s is not enable" %
(module_name, dep_module_name))
# only add to the dependencies map the plugins
# that are from the same stage
if dep_module_name in module_name_to_plugin:
dependencies.add(dep_module_name)
else:
# check if already executed
if dep_module_name not in self.plugins_executed:
utils.error("Plugin:%s can't be executed because\
plugin %s was not executed in previous\
stage" % (module_name, dep_module_name))
dependencie_map[module_name] = dependencies
# print dependencie_map
# Topological sorting
try:
plugins_to_process = toposort_flatten(dependencie_map)
except Exception as e:
utils.error("Circular dependencies between plugins.\
Can't execute plugins:%s" % e)
s = "|-%s plugins" % (unit.strip().capitalize())
desc = colored(s, "magenta")
results = []
for module_name in tqdm(plugins_to_process,
unit=' plugin',
desc=desc,
leave=True):
if module_name in module_name_to_plugin:
plugin = module_name_to_plugin[module_name]
else:
raise Exception("The following plugin module name listed in\
dependencies don't exist % s " % module_name)
pclass = plugin_class.lower()
filename = "%s.%s.html" % (pclass, module_name)
log_id = site.logger.create_log(pclass, plugin.name, filename)
plugin_results = utils.dict_to_objdict({
site.OK: 0,
site.SKIPPED: 0,
site.ERROR: 0
})
config = self.get_plugin_config(plugin)
for item in tqdm(items, unit=unit, desc=plugin.name, leave=False):
result = plugin.plugin_object.process(item, site, config)
plugin_results[result[0]] += 1
severity = result[0]
name = result[1]
details = result[2]
site.logger.record_event(log_id, name, severity, details)
self.plugins_executed[module_name] = True
results.append([plugin.name, plugin_results])
site.logger.write_log(log_id)
return results
def get_template_filters(self):
"""Load template filters and return a dictionary list
Return:
dict: jinja filter functions
"""
template_filters = {}
filters = self.plugins.getPluginsOfCategory("TemplateFilter")
for flt in filters:
filter_name = self.get_plugin_module_name(flt)
template_filters[filter_name] = flt.plugin_object.myfilter
return template_filters
def test_default_init(self):
pm = PluginManager()
self.assertEqual(["Default"], pm.getCategories())
self.assertTrue(isinstance(pm.getPluginLocator(), PluginFileLocator))
def main(args: List[AnyStr] = None) -> int:
"""
prepare and start application
the main method is responsible for setting up the environment,
i.e. to load translations, set a logger, parse the command line arguments,
load configuration files and start the application.
:param args: command line arguments; default: None
:type args: List of strings
"""
if not args:
args = sys.argv
script_name = os.path.basename(sys.argv[0])
application = AppDirs(os.path.splitext(script_name)[0],
appauthor=__author__,
version=__version__,
roaming=True)
logging_path = application.user_data_dir
config_path = application.user_config_dir
# set locale
locale.setlocale(locale.LC_ALL, '')
_locale = locale.getlocale(locale.LC_ALL)[0]
locale_path = pkg_resources.resource_filename("servertools", "data/i18n")
translate = gettext.translation("servertools",
localedir=locale_path,
languages=[locale.getlocale()[0], 'en'])
translate.install()
if '_' not in globals():
_ = unicode
# setup logging
handlers = _log_default_handler(proc=script_name, log_dir=logging_path)
logging.basicConfig(level=4, format="%(message)s", handlers=handlers)
logger = logging.getLogger("{}_logger".format(
os.path.splitext(script_name)[0]))
logger.setLevel(logging.DEBUG)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.WARNING)
stream_handler.setFormatter(logging.Formatter("%(message)s"))
logger.addHandler(stream_handler)
# setup argument parser
parser = ArgumentParser(prog=script_name)
verbosity_parsergroup = parser.add_mutually_exclusive_group()
verbosity_parsergroup.add_argument("-v",
dest='verbosity',
action="count",
help=_("increase verbosity"),
default=0)
verbosity_parsergroup.add_argument(
"--silent",
action="store_true",
help=_("silent (no output to terminal)"))
parser.add_argument("--version",
action="version",
help=_("print version and exit"))
parser.add_argument("--log-file",
metavar='FILEPATH',
action="store",
help=_("overwrite path to log file"))
command_parsers = parser.add_subparsers(help="commands")
identify_parser = command_parsers.add_parser("identify",
add_help=False,
parents=[parser])
# load plugins for different server types
plugins_directories = [
pkg_resources.resource_filename("servertools", "plugins"),
os.path.join(application.user_data_dir, 'plugins'),
os.path.expanduser(
os.path.normpath(
'~/.{appname}/plugins'.format(appname=application.appname)))
]
sys.path.extend(plugins_directories)
plugin_manager = PluginManager(directories_list=plugins_directories,
plugin_info_ext='plugin')
plugin_manager.setCategoriesFilter({
"Server": Server,
})
plugin_manager.locatePlugins()
plugin_manager.collectPlugins()
# plugins to identify servers and fix problems that might happen on them
plugins = plugin_manager.getPluginsOfCategory(
'Server') # type: List[PluginInfo]
# choices for the command line flag `--look-for`
server_choices = [] # type: List[AnyStr]
# set valid values for --look-for from installed plugins
for plugin in plugins:
commandline_argument = plugin.name.lower().replace('server',
'').strip().replace(
' ', '-')
if len(commandline_argument) > 0:
server_choices.append(commandline_argument)
else:
raise ValueError(
_("Plugin {name} doesn't have a valid name!").format(
name=plugin.name))
identify_parser.add_argument("--look-for",
metavar="SERVER",
dest="look_for",
help=_("look for a specific server"),
choices=server_choices,
default='')
identify_parser.set_defaults(name="identify")
# fix_parser = command_parsers.add_parser('fix', help=_('apply fixes for a server'))
# parse arguments
args = parser.parse_args(args[1:])
# handle verbosity
verbosity = max(0, min(3, args.verbosity))
if args.silent:
verbosity = -1
logging_level = {
-1: logging.CRITICAL, # 50
0: logging.WARNING, # 30
1: logging.INFO, # 20
2: logging.INFO, # 20
3: logging.DEBUG # 10
}.get(verbosity, logging.WARNING)
stream_handler.setLevel(logging_level)
verbose = logger.info if verbosity > 1 else logger.debug
# start application
logger.debug(
_("{program} started at {started_at:%X} on Python {py_version} ({architecture})"
).format(program=script_name,
started_at=datetime.now(),
py_version=platform.python_version(),
architecture=platform.architecture()[0]))
logger.debug(
_("Verbosity Level at {verbosity}").format(verbosity=verbosity))
plugins_information = {}
for category in plugin_manager.getCategories():
plugins_information[category] = list()
for plugin in plugin_manager.getPluginsOfCategory(category):
plugins_information[category].append({
'name': plugin.name,
'author': plugin.author
})
# if verbosity > 1:
logger.info(_("Save logs to {path}").format(path=logging_path))
logger.info(_("Load configurations from {path}").format(path=config_path))
logger.info(
_('Look for plugins in:\n\t{path}').format(
path=',\n\t'.join(plugins_directories)))
verbose(
_('Include {amount} Plugin Categories.').format(
amount=len(plugin_manager.getCategories())))
logger.debug(', '.join(plugin_manager.getCategories()))
verbose(
_('{amount} Plugin(s) loaded.').format(
amount=len(plugins_information.keys())))
for category in plugins_information:
logger.debug('[{}]'.format(category))
for cat in plugins_information[category]:
logger.debug(
_('\t{name} (by {author})').format(name=cat['name'],
author=cat['author']))
logger.debug('')
for plugin in plugins:
logger.debug(_("Try to identify {name}").format(name=plugin.name))
command = plugin.name.lower().replace('server',
'').strip().replace(' ', '-'),
if args.look_for == command and plugin.plugin_object.identify():
logger.debug(
_("Successfully identified {name}").format(name=plugin.name))
print("{} - {}".format(plugin.details.get('Server Info', 'Host'),
plugin.details.get('Server Info',
'Slogan')))
break
else:
print(
_('Not {}').format(args.look_for)
if len(args.look_for) > 0 else _('Unknown platform'))
return 1
logger.debug("-" * 80)
return 0
class Config(object):
"""
The :class:`Config <Config>` is responsible for managing the
plugins and executing given tasks.
"""
_configs = []
logging_verbosity = 0
def __init__(self, settings, name):
"""Summary
Args:
settings (dict): the dictionary of settings
name (str): the config name
"""
assert settings is not None
assert name is not None
self._name = name
self._settings = settings
self._inspect_analyzer = None
self._default_analyzer = None
self._categories = None
self._paths = _BUILTIN_PATHS
self._plugins = None
self._stacks = []
validate_config(settings)
if Config.logging_verbosity < settings['verbosity']:
configure_logging(settings['verbosity'])
Config.logging_verbosity = settings['verbosity']
logger.info(
'Increased logging verbosity from %s to %s with the new config...',
Config.logging_verbosity,
settings['verbosity']
)
self._configure_plugins()
def _configure_plugins(self):
"""
Handles initialization of the
:class:`Config <Config>`. This method shouldn't be called
outside of this class.
"""
logger.debug('Configuring Config')
# Setup the locators
# Inspection analyzer, mostly for builtin plugins
# (resources, tasks, etc)
self._inspect_analyzer = PluginFileAnalyzerInspection(
'inspector',
_BUILTIN_PATHS
)
# The default analyzer for any extension paths that we don't trust.
self._default_analyzer = PluginFileAnalyzerWithInfoFile(
'default',
extensions='plugin'
)
# The order of the analyzers could matter.
self._locator = PluginFileLocator(
analyzers=[
self._inspect_analyzer,
self._default_analyzer,
]
)
# Create the categories filter dict
self._categories = {
"Resource": Resource,
"Action": Action,
"Storage": Storage,
"Parser": Parser,
}
# Setup the search paths
if self._settings and "extension_paths" in self._settings:
self._paths.extend(self._settings["extension_paths"])
# Actually create the PluginManager
self._plugins = PluginManager(
categories_filter=self._categories,
directories_list=self._paths,
plugin_locator=self._locator
)
# Collect the plugins
self._plugins.collectPlugins()
@property
def name(self):
return self._name
@property
def settings(self):
return self._settings
@classmethod
def make(cls, settings=None, name=""):
"""
When first setting up the Config you should call this
class method.
Args:
settings (dict, optional): desire settings values overriding the defaults.
name (str, optional): the name of the config
Returns: the created config obj
"""
logger.debug('Creating Config named "%s"', name)
config_settings = _DEFAULT_SETTINGS
if settings:
config_settings.update(settings)
assert config_settings is not None
new_config = Config(config_settings, name)
for index, config in enumerate(cls._configs):
if config.name == name:
logger.warn('Recreating Config named %s', name)
cls._configs[index] = new_config
break
else:
cls._configs.append(new_config)
return new_config
@classmethod
def make_from_file(cls, filename, name=""):
"""
Loads the settings dict from a file and passes it to Config.make.
Args:
filename (str): name of the file to load
name (str, optional): the name of the config
Returns:
Config: the created config obj
"""
settings = anyconfig.load(filename, safe=True)
return cls.make(settings=settings, name=name)
@classmethod
def get(cls, name=""):
"""
Use this to access your desired Config.
Args:
name (str, optional): the unique name of the config you
want returned.
Returns: the config obj
Raises:
KeyError: if a config by that name does't exist.
"""
logger.debug('Retrieving Config named "%s"', name)
for config in cls._configs:
if config.name == name:
return config
else:
raise KeyError('No config with the name {} exists'.format(name))
def get_plugins(self, category_name=None, plugin_name=None):
"""
get_plugins returns a deepcopy of all the plugins fitting
the search criteria. While this isn't very memory efficient
our plugins should be small and few between enough that it'll be
worth getting independent copies of them. For example we will likely
want to work with multiple copies of the Same Resource plugin.
Args:
category_name (str, optional): a category to search for plugins in.
plugin_name (str, optional): the name of the plugin to look for.
Returns:
list: of the plugins that match the criteria.
"""
results = []
if category_name and plugin_name:
plugin_info = self._plugins.getPluginByName(
plugin_name,
category=category_name
)
if plugin_info:
results.append(plugin_info.plugin_object.__class__())
elif category_name and not plugin_name:
plugin_infos = self._plugins.getPluginsOfCategory(category_name)
for plugin_info in plugin_infos:
results.append(plugin_info.plugin_object.__class__())
elif plugin_name and not category_name:
for category in self._plugins.getCategories():
plugin_info = self._plugins.getPluginByName(
plugin_name,
category=category
)
if plugin_info:
results.append(plugin_info.plugin_object.__class__())
elif not category_name and not plugin_name:
plugin_infos = self._plugins.getAllPlugins()
for plugin_info in plugin_infos:
results.append(plugin_info.plugin_object.__class__())
return results
def test_default_init(self): pm = PluginManager() self.assertEqual(["Default"],pm.getCategories()) self.assertTrue(isinstance(pm.getPluginLocator(),PluginFileLocator))
class WeaponSystem(rpyc.Service):
'''
RPC Services: This is the code that does the actual password cracking
and returns the results to orbital control. Currently only supports
cracking using rainbow tables (RCrackPy)
'''
is_initialized = False
mutex = Lock()
is_busy = False
job_id = None
def initialize(self):
''' Initializes variables, this should only be called once '''
logging.info("Weapon system initializing ...")
self.plugin_manager = PluginManager()
self.plugin_manager.setPluginPlaces(["plugins/"])
self.plugin_manager.setCategoriesFilter(FILTERS)
self.plugin_manager.collectPlugins()
self.plugins = {}
logging.info("Loaded %d plugin(s)" %
len(self.plugin_manager.getAllPlugins()))
self.__cpu__()
logging.info("Weapon system online, good hunting.")
@atomic
def on_connect(self):
''' Called when successfully connected '''
if not self.is_initialized:
self.initialize()
self.is_initialized = True
logging.info("Uplink to orbital control active")
def on_disconnect(self):
''' Called if the connection is lost/disconnected '''
logging.info("Disconnected from orbital command server.")
def __cpu__(self):
''' Detects the number of CPU cores on a system (including virtual cores) '''
if cpu_count is not None:
try:
self.cpu_cores = cpu_count()
logging.info("Detected %d CPU core(s)" % self.cpu_cores)
except NotImplementedError:
logging.error(
"Could not detect number of processors; assuming 1")
self.cpu_cores = 1
else:
try:
self.cpu_cores = int(sysconf("SC_NPROCESSORS_CONF"))
logging.info("Detected %d CPU core(s)" % self.cpu_cores)
except ValueError:
logging.error(
"Could not detect number of processors; assuming 1")
self.cpu_cores = 1
############################ [ EXPOSED METHODS ] ############################
@atomic
def exposed_crack(self, plugin_name, job_id, hashes, **kwargs):
''' Exposes plugins calls '''
assert plugin_name in self.plugins
self.is_busy = True
self.job_id = job_id
self.plugin_manager.activatePluginByName(plugin_name)
plugin = self.plugin_manager.getPluginByName(plugin_name)
results = plugin.execute(hashes, **kwargs)
self.plugin_manager.deactivatePluginByName(plugin_name)
self.job_id = None
self.is_busy = False
return results
def exposed_get_plugin_names(self):
''' Returns what algorithms can be cracked '''
logging.info("Method called: exposed_get_capabilities")
plugins = self.plugin_manager.getAllPlugins()
return [plugin.name for plugin in plugins]
def exposed_get_categories(self):
''' Return categories for which we have plugins '''
categories = []
for category in self.plugin_manager.getCategories():
if 0 < len(self.plugin_manager.getPluginsOfCategory(category)):
categories.append(category)
return categories
def exposed_get_category_plugins(self, category):
''' Get plugin names for a category '''
plugins = self.plugin_manager.getPluginsOfCategory(category)
return [plugin.name for plugin in plugins]
def exposed_get_plugin_details(self, category, plugin_name):
''' Get plugin based on name details '''
plugin = self.plugin_manager.getPluginByName(plugin_name, category)
info = {'name': plugin.name}
info['author'] = plugin.details.get('Documentation', 'author')
info['website'] = plugin.details.get('Documentation', 'website')
info['version'] = plugin.details.get('Documentation', 'version')
info['description'] = plugin.details.get('Documentation',
'description')
info['copyright'] = plugin.details.get('Documentation', 'copyright')
info['precomputation'] = plugin.details.getboolean(
'Core', 'precomputation')
return info
def exposed_ping(self):
''' Returns a pong message '''
return "PONG"
def exposed_is_busy(self):
''' Returns True/False if the current system is busy (thread safe) '''
return self.is_busy
def exposed_current_job_id(self):
''' Returns the current job id (thread safe) '''
return self.job_id
def exposed_cpu_count(self):
''' Returns the number of detected cpu cores '''
return self.cpu_cores
class SimpleTestsCase(unittest.TestCase): """ Test the correct loading of a simple plugin as well as basic commands. """ def setUp(self): """ init """ # create the plugin manager self.simplePluginManager = PluginManager(directories_list=[ os.path.join( os.path.dirname(os.path.abspath(__file__)),"plugins")]) # load the plugins that may be found self.simplePluginManager.collectPlugins() # Will be used later self.plugin_info = None def plugin_loading_check(self): """ Test if the correct plugin has been loaded. """ if self.plugin_info is None: # check nb of categories self.assertEqual(len(self.simplePluginManager.getCategories()),1) sole_category = self.simplePluginManager.getCategories()[0] # check the number of plugins self.assertEqual(len(self.simplePluginManager.getPluginsOfCategory(sole_category)),1) self.plugin_info = self.simplePluginManager.getPluginsOfCategory(sole_category)[0] # test that the name of the plugin has been correctly defined self.assertEqual(self.plugin_info.name,"Simple Plugin") self.assertEqual(sole_category,self.plugin_info.category) else: self.assert_(True) def testLoaded(self): """ Test if the correct plugin has been loaded. """ self.plugin_loading_check() def testGetAll(self): """ Test if the correct plugin has been loaded. """ self.plugin_loading_check() self.assertEqual(len(self.simplePluginManager.getAllPlugins()),1) self.assertEqual(self.simplePluginManager.getAllPlugins()[0],self.plugin_info) def testActivationAndDeactivation(self): """ Test if the activation procedure works. """ self.plugin_loading_check() self.assert_(not self.plugin_info.plugin_object.is_activated) self.simplePluginManager.activatePluginByName(self.plugin_info.name, self.plugin_info.category) self.assert_(self.plugin_info.plugin_object.is_activated) self.simplePluginManager.deactivatePluginByName(self.plugin_info.name, self.plugin_info.category) self.assert_(not self.plugin_info.plugin_object.is_activated)
def test_init_with_category_filter(self):
pm = PluginManager(categories_filter={"Mouf": IPlugin})
self.assertEqual(["Mouf"],pm.getCategories())
self.assertTrue(isinstance(pm.getPluginLocator(),PluginFileLocator))
def test_init_with_plugin_info_ext(self): pm = PluginManager(plugin_info_ext="bla") self.assertEqual(["Default"],pm.getCategories()) self.assertTrue(isinstance(pm.getPluginLocator(),PluginFileLocator))
def test_init_with_plugin_locator(self): class SpecificLocator(IPluginLocator): pass pm = PluginManager(plugin_locator=SpecificLocator()) self.assertEqual(["Default"],pm.getCategories()) self.assertTrue(isinstance(pm.getPluginLocator(),SpecificLocator))
class SimpleTestsCase(unittest.TestCase):
"""
Test the correct loading of a simple plugin as well as basic
commands.
"""
def setUp(self):
"""
init
"""
# create the plugin manager
self.simplePluginManager = PluginManager(directories_list=[
os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
])
# load the plugins that may be found
self.simplePluginManager.collectPlugins()
# Will be used later
self.plugin_info = None
def plugin_loading_check(self):
"""
Test if the correct plugin has been loaded.
"""
if self.plugin_info is None:
# check nb of categories
self.assertEqual(len(self.simplePluginManager.getCategories()), 1)
sole_category = self.simplePluginManager.getCategories()[0]
# check the number of plugins
self.assertEqual(
len(
self.simplePluginManager.getPluginsOfCategory(
sole_category)), 1)
self.plugin_info = self.simplePluginManager.getPluginsOfCategory(
sole_category)[0]
# test that the name of the plugin has been correctly defined
self.assertEqual(self.plugin_info.name, "Simple Plugin")
self.assertEqual(sole_category, self.plugin_info.category)
else:
self.assert_(True)
def testLoaded(self):
"""
Test if the correct plugin has been loaded.
"""
self.plugin_loading_check()
def testGetAll(self):
"""
Test if the correct plugin has been loaded.
"""
self.plugin_loading_check()
self.assertEqual(len(self.simplePluginManager.getAllPlugins()), 1)
self.assertEqual(self.simplePluginManager.getAllPlugins()[0],
self.plugin_info)
def testActivationAndDeactivation(self):
"""
Test if the activation procedure works.
"""
self.plugin_loading_check()
self.assert_(not self.plugin_info.plugin_object.is_activated)
self.simplePluginManager.activatePluginByName(
self.plugin_info.name, self.plugin_info.category)
self.assert_(self.plugin_info.plugin_object.is_activated)
self.simplePluginManager.deactivatePluginByName(
self.plugin_info.name, self.plugin_info.category)
self.assert_(not self.plugin_info.plugin_object.is_activated)
