def init_callback():
tester = Eucaops(credpath=CREDPATH)
global PLUGINS
PLUGINS = ExtensionManager(namespace=NAMESPACE,
invoke_on_load=True,
invoke_args=(tester, ))
PLUGINS.propagate_map_exceptions = True
def get_available_plugins(namespace):
"""Return names of the available / installed plugins for a given namespace.
"""
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=namespace, invoke_on_load=False)
return manager.names()
def __init__(self, filename):
super(VarLoader, self).__init__()
self.filename = filename
loaders = ExtensionManager(namespace='usagi.var_loaders', )
self.loaders = dict(
(name, loaders[name].plugin) for name in loaders.names())
self.loader_keys = set(self.loaders.keys())
def get_available_plugins(namespace):
"""Return names of the available / installed plugins for a given namespace.
"""
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=namespace, invoke_on_load=False)
return manager.names()
def list_providers():
"""
Return a list of installed providers.
"""
em = ExtensionManager(NAMESPACE)
return em.map(lambda p:
{'name': p.name, 'version': p.plugin().get_version()})
def get_scripts_by_name(namespace):
scripts_by_name = defaultdict(list)
extension_manager = ExtensionManager(namespace, invoke_on_load=True)
for name, extension in zip(extension_manager.names(), extension_manager.extensions):
scripts_by_name[name].append(extension.obj)
for name, scripts in scripts_by_name.items():
scripts_by_name[name] = sorted(scripts, key=lambda x: x.priority)
return scripts_by_name
def get_available_backends():
"""
Return names of the available / installed authentication backends.
:rtype: ``list`` of ``str``
"""
manager = ExtensionManager(namespace=BACKENDS_NAMESPACE, invoke_on_load=False)
return manager.names()
def get_available_drivers(invoke_on_load=False):
"""
Return names of the available drivers
"""
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=NAMESPACE,
invoke_on_load=invoke_on_load)
return manager.names()
def get_available_backends():
"""
Return names of the available / installed authentication backends.
:rtype: ``list`` of ``str``
"""
manager = ExtensionManager(namespace=BACKENDS_NAMESPACE,
invoke_on_load=False)
return manager.names()
def list_providers():
"""
Return a list of installed providers.
"""
em = ExtensionManager(NAMESPACE)
return em.map(lambda p: {
'name': p.name,
'version': p.plugin().get_version()
})
def get_available_backends():
"""
Return names of the available / installed action runners.
:rtype: ``list`` of ``str``
"""
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=BACKENDS_NAMESPACE, invoke_on_load=False)
return manager.names()
def __init__(self, filename):
super(VarLoader, self).__init__()
self.filename = filename
loaders = ExtensionManager(
namespace='usagi.var_loaders',
)
self.loaders = dict(
(name, loaders[name].plugin)
for name in loaders.names()
)
self.loader_keys = set(self.loaders.keys())
def get_available_backends():
"""
Return names of the available / installed action runners.
:rtype: ``list`` of ``str``
"""
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=BACKENDS_NAMESPACE,
invoke_on_load=False)
return manager.names()
def get_available_plugins(cls, namespace=None):
"""
Returns a dict of all the plugins that have been made available through the platform.
"""
# Note: we're creating the extension manager lazily to ensure that the Python path
# has been correctly set up. Trying to create this statically will fail, unfortunately.
plugins = OrderedDict()
extension_manager = ExtensionManager(namespace=namespace or cls.NAMESPACE) # pylint: disable=no-member
for plugin_name in extension_manager.names():
plugins[plugin_name] = extension_manager[plugin_name].plugin
return plugins
def __init__(self):
self.hook_managers = OrderedDict()
self.hook_managers[self.ENVIRONMENT_HOOK] = ExtensionManager(
namespace=self.ENVIRONMENT_HOOK, )
self.hook_managers[self.RESULT_HANDLERS] = ExtensionManager(
namespace=self.RESULT_HANDLERS, )
self.driver_managers = OrderedDict()
self.driver_managers[self.TEST_DISCOVERY] = ExtensionManager(
namespace=self.TEST_DISCOVERY, )
self.driver_managers[self.TEST_RUNNER] = ExtensionManager(
namespace=self.TEST_RUNNER, )
def get_available_backends(namespace, invoke_on_load=False):
"""
Return names of the available / installed backends.
:rtype: ``list`` of ``str``
"""
# NOTE: We use lazy import because importing from stevedore adds significat import time
# overhead to other modules which don't need this package (stevedore needs to inspect various
# entrypoint files on disk for all the installed Python packages which is slow)
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=namespace, invoke_on_load=invoke_on_load)
return manager.names()
def _load_plugins(self, plugins):
""" Load plugins via Stevedore. """
mgr = ExtensionManager(
namespace='force.bdss.extensions',
invoke_on_load=True,
on_load_failure_callback=functools.partial(_load_failure_callback,
plugins)
)
try:
mgr.map(functools.partial(_import_extensions, plugins))
except NoMatches:
log.info("No extensions found")
def get_available_backends(namespace, invoke_on_load=False):
"""
Return names of the available / installed backends.
:rtype: ``list`` of ``str``
"""
# NOTE: We use lazy import because importing from stevedore adds significat import time
# overhead to other modules which don't need this package (stevedore needs to inspect various
# entrypoint files on disk for all the installed Python packages which is slow)
from stevedore.extension import ExtensionManager
manager = ExtensionManager(namespace=namespace, invoke_on_load=invoke_on_load)
return manager.names()
def setUp(self):
super(PartitionTestCase, self).setUp()
# Set up two user partition schemes: mock and random
self.non_random_scheme = MockUserPartitionScheme(self.TEST_SCHEME_NAME)
self.random_scheme = MockUserPartitionScheme("random")
extensions = [
Extension(self.non_random_scheme.name,
USER_PARTITION_SCHEME_NAMESPACE, self.non_random_scheme,
None),
Extension(self.random_scheme.name, USER_PARTITION_SCHEME_NAMESPACE,
self.random_scheme, None),
]
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
extensions, namespace=USER_PARTITION_SCHEME_NAMESPACE)
# Create a test partition
self.user_partition = UserPartition(
self.TEST_ID,
self.TEST_NAME,
self.TEST_DESCRIPTION,
self.TEST_GROUPS,
extensions[0].plugin,
self.TEST_PARAMETERS,
)
# Make sure the names are set on the schemes (which happens normally in code, but may not happen in tests).
self.user_partition.get_scheme(self.non_random_scheme.name)
self.user_partition.get_scheme(self.random_scheme.name)
def test_environment_hook_options_no_plugins(self):
# Given
environment_manager = ExtensionManager.make_test_instance(
[],
namespace=PluginManager.ENVIRONMENT_HOOK,
)
hook_managers = [(PluginManager.ENVIRONMENT_HOOK, environment_manager)]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=hook_managers, driver_managers=())
parser = ArgumentParser(add_help=False)
# When
plugin_manager.add_plugin_arguments(parser)
# Then
actions = parser._actions
self.assertEqual(len(actions), 0)
# When
args = parser.parse_args([])
enabled_plugins = plugin_manager.get_enabled_hook_plugins(
plugin_manager.ENVIRONMENT_HOOK, args)
# Then
self.assertEqual(enabled_plugins, [])
def init_app(self, obj):
"""Sets up client with config values from obj
Args:
obj (instance): config object
"""
self.data_dir = obj.config.get(u'DEV_DATA_DIR', None)
if self.data_dir is not None:
self.data_dir = os.path.join(self.data_dir, u'pyi-data')
self.deploy_dir = os.path.join(self.data_dir, u'deploy')
else:
log.debug(u'DEV_DATA_DIR is None. Setup failed.')
self.remote_dir = obj.config.get(u'REMOTE_DIR', None)
self.host = obj.config.get(u'HOST', None)
self.username = obj.config.get(u'USERNAME', None)
# If password is now get ssh key path
self.password = obj.config.get(u'PASSWORD', None)
if self.password is None:
self.password = obj.config.get(u'SSH_KEY_PATH')
self.uploader = None
self.test = False
# Extension Manager
self.mgr = ExtensionManager(namespace=u'pyiupdater.uploaders',
)
def test_get_default_driver(self):
# Given
class OtherRunner(BaseTestRunner):
pass
default = Extension(
'default', None, BaseTestRunner, None)
other = Extension(
'other', None, OtherRunner, None)
driver_managers = [
(PluginManager.TEST_RUNNER, ExtensionManager.make_test_instance(
[default, other], namespace=PluginManager.TEST_RUNNER)),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=(), driver_managers=driver_managers)
parser = create_argument_parser()
plugin_manager.add_plugin_arguments(parser)
# When
args = parser.parse_args([])
plugin_manager.get_driver(plugin_manager.TEST_RUNNER, args)
runner = plugin_manager.get_driver(plugin_manager.TEST_RUNNER, args)
# Then
self.assertNotIsInstance(runner, OtherRunner)
class SyncCommand(AbstractCommand):
"""Sync with IaaS or PaaS."""
service_manager = ExtensionManager(namespace='termius.sync.providers')
save_strategy = RelatedSaveStrategy
get_strategy = RelatedGetStrategy
def extend_parser(self, parser):
"""Add more arguments to parser."""
parser.add_argument('-c',
'--credentials',
help='Credentials (path or file) for service.')
parser.add_argument('service', metavar='SERVICE', help='Service name.')
return parser
def get_service(self, service_name):
"""Load service instance by name."""
try:
extension = self.service_manager[service_name]
except KeyError:
raise NoSuchServiceException(
'Do not support service: {}.'.format(service_name))
return extension.plugin
def sync_with_service(self, service, credentials):
"""Connect to service and retrieve it's hosts.."""
service_class = self.get_service(service)
service = service_class(self.storage, credentials)
service.sync()
def take_action(self, parsed_args):
"""Process CLI call."""
self.sync_with_service(parsed_args.service, parsed_args.credentials)
self.log.info('Sync with service %s.', parsed_args.service)
def get_grader(grader_type):
"""Returns grader by the `grader_type(str)`."""
extension = ExtensionManager(namespace='openedx.graders')
try:
return extension[grader_type].plugin
except KeyError:
raise UnrecognizedGraderError("Unrecognized grader `{0}`".format(grader_type))
def _get_extension_plugin_modules(log, warn=True):
"""
Get the modules registered by installed python modules that
provide extensions in the ``smqtk_plugins`` namespace.
:return: Iterator of python modules registered by installed extensions.
:rtype: collections.Iterator[types.ModuleType]
"""
# Get the cached extension manager.
try:
m = _get_extension_plugin_modules.ext_manager
except AttributeError:
log.debug("Creating and caching ExtensionManager for namespace '{}'."
.format(EXTENSION_NAMESPACE))
m = _get_extension_plugin_modules.ext_manager = \
ExtensionManager(EXTENSION_NAMESPACE)
# Yield registered extensions that are actually modules.
for ext in m:
ext_plugin_module = ext.plugin
if not isinstance(ext_plugin_module, types.ModuleType):
if warn:
warnings.warn("Skipping extension provided by package '{} "
"({})' that did NOT resolve to a python module "
"(got an object of type {} instead: {})."
.format(ext.entry_point.dist.key,
ext.entry_point.dist.version,
type(ext_plugin_module).__name__,
ext_plugin_module))
else:
yield ext.plugin
def __init__(self, config, plugins=None):
if isinstance(plugins, list):
_all_plugins = plugins
else:
_all_plugins = []
for pn in self.PLUGIN_NAMESPACES:
try:
namespace = ExtensionManager(pn, invoke_on_load=True)
except Exception as err:
log.debug(err, exc_info=True)
else:
for p in namespace.extensions:
_all_plugins.append(p.obj)
# Sorting by name then author
plugins = sorted(_all_plugins, key=lambda x: (x.name, x.author))
# Used as a counter when creating names to plugin
# User may have multiple plugins with the same
# name installed
self.unique_names = {}
# A list of dicts of all installed plugins.
# Keys: name author plugin
self.plugins = []
self.configs = PluginManager._get_config(config)
self._load(plugins)
def manager():
m = g.get('manager')
if m is None:
m = g['manager'] = ExtensionManager('torabot.mods',
invoke_on_load=True,
invoke_args=(get_current_conf(), ))
return m
def setUp(self):
super(PartitionTestCase, self).setUp()
# Set up two user partition schemes: mock and random
self.non_random_scheme = MockUserPartitionScheme(self.TEST_SCHEME_NAME)
self.random_scheme = MockUserPartitionScheme("random")
extensions = [
Extension(
self.non_random_scheme.name, USER_PARTITION_SCHEME_NAMESPACE, self.non_random_scheme, None
),
Extension(
self.random_scheme.name, USER_PARTITION_SCHEME_NAMESPACE, self.random_scheme, None
),
]
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
extensions, namespace=USER_PARTITION_SCHEME_NAMESPACE
)
# Create a test partition
self.user_partition = UserPartition(
self.TEST_ID,
self.TEST_NAME,
self.TEST_DESCRIPTION,
self.TEST_GROUPS,
extensions[0].plugin,
self.TEST_PARAMETERS,
)
# Make sure the names are set on the schemes (which happens normally in code, but may not happen in tests).
self.user_partition.get_scheme(self.non_random_scheme.name)
self.user_partition.get_scheme(self.random_scheme.name)
def test_environment_hook_options(self):
class TestingPlugin(BaseTestingPlugin):
add_parser_arguments_called = 0
from_args_called = 0
@classmethod
def add_parser_arguments(cls, parser, name, option_prefix,
dest_prefix):
cls.add_parser_arguments_called += 1
return super(TestingPlugin, cls).add_parser_arguments(
parser, name, option_prefix, dest_prefix)
@classmethod
def from_args(cls, args, name, dest_prefix):
cls.from_args_called += 1
return super(TestingPlugin, cls).from_args(
args, name, dest_prefix)
# Given
extension = Extension(
'testing-plugin', None, TestingPlugin, None)
environment_manager = ExtensionManager.make_test_instance(
[extension], namespace=PluginManager.ENVIRONMENT_HOOK,
)
hook_managers = [(PluginManager.ENVIRONMENT_HOOK, environment_manager)]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=hook_managers, driver_managers=())
parser = ArgumentParser(add_help=False)
# When
plugin_manager.add_plugin_arguments(parser)
# Then
self.assertEqual(TestingPlugin.add_parser_arguments_called, 1)
actions = parser._actions
self.assertEqual(len(actions), 1)
action, = actions
self.assertEqual(action.option_strings, ['--with-testing-plugin'])
# When
args = parser.parse_args([])
enabled_plugins = plugin_manager.get_enabled_hook_plugins(
plugin_manager.ENVIRONMENT_HOOK, args)
# Then
self.assertEqual(enabled_plugins, [])
self.assertEqual(TestingPlugin.from_args_called, 1)
# When
args = parser.parse_args(['--with-testing-plugin'])
enabled_plugins = plugin_manager.get_enabled_hook_plugins(
plugin_manager.ENVIRONMENT_HOOK, args)
# Then
self.assertEqual(len(enabled_plugins), 1)
plugin_obj, = enabled_plugins
self.assertEqual(TestingPlugin.from_args_called, 2)
self.assertTrue(plugin_obj.enabled)
def _init_classes():
"""Avoid leaking state variables by wrapping `LAYER_CLASSES` construction
in a function"""
classes = {}
for doc_type in ('cfr', 'preamble'): # @todo - make this dynamic
namespace = 'eregs_ns.parser.layer.{0}'.format(doc_type)
classes[doc_type] = {
extension.name: extension.plugin
for extension in ExtensionManager(namespace)
}
# For backwards compatibility. @todo - remove in later release
old_namespace = 'eregs_ns.parser.layers'
classes['cfr'].update({
extension.plugin.shorthand: extension.plugin
for extension in ExtensionManager(old_namespace)
})
return classes
def make_plugin_options(self):
plugin_options = []
self.mgr = ExtensionManager(u'pyiupdater.uploaders')
plugin_names = self.mgr.names()
log.debug(u'Plugin names: {}'.format(plugin_names))
for pgn in plugin_names:
# passing none as a place holder for logic in
# cli.ui.menu for processing of plugin menu creation
# Logic will pass this to else since its len is
# more then 2
log.debug(u'Plugin name: {}'.format(pgn))
option = (pgn, self.upload, None)
plugin_options.append(option)
plugin_options.append((u'Main Menu', self.done))
return plugin_options
def initialize_data_types(suffix_by_data_type=None):
for x in ExtensionManager('crosscompute.types').extensions:
data_type = x.plugin
for suffix in data_type.suffixes:
DATA_TYPE_BY_SUFFIX[suffix] = data_type
DATA_TYPE_BY_NAME[x.name] = data_type
for suffix, data_type_spec in (suffix_by_data_type or {}).items():
data_type = resolve_attribute(data_type_spec)
DATA_TYPE_BY_SUFFIX[suffix] = data_type
def manager(self):
name = '_manager'
value = getattr(self, name, None)
if value is None:
from .local import get_current_conf
value = ExtensionManager('torabot.mods',
invoke_on_load=True,
invoke_args=(get_current_conf(), ))
setattr(self, name, value)
return value
def __init__(self, loader):
super(YamlTestLoader, self).__init__()
self._loader = loader
assertions = ExtensionManager(
namespace='usagi.assertions',
)
test_parameters = ExtensionManager(
namespace='usagi.parameters'
)
self._assertions_map = dict(
(name, assertions[name].plugin)
for name in assertions.names()
)
self._test_parameters = dict(
(name, test_parameters[name].plugin)
for name in test_parameters.names()
)
def register_runners(experimental=False, fail_on_failure=True):
"""
Register runners
"""
LOG.debug('Start : register runners')
runner_count = 0
manager = ExtensionManager(namespace=RUNNERS_NAMESPACE, invoke_on_load=False)
extension_names = manager.names()
for name in extension_names:
LOG.debug('Found runner "%s"' % (name))
manager = DriverManager(namespace=RUNNERS_NAMESPACE, invoke_on_load=False, name=name)
runner_metadata = manager.driver.get_metadata()
runner_count += register_runner(runner_metadata, experimental)
LOG.debug('End : register runners')
return runner_count
def register_runners(experimental=False, fail_on_failure=True):
"""
Register runners
"""
LOG.debug('Start : register runners')
runner_count = 0
manager = ExtensionManager(namespace=RUNNERS_NAMESPACE, invoke_on_load=False)
extension_names = manager.names()
for name in extension_names:
LOG.debug('Found runner "%s"' % (name))
manager = DriverManager(namespace=RUNNERS_NAMESPACE, invoke_on_load=False, name=name)
runner_metadata = manager.driver.get_metadata()
runner_count += register_runner(runner_metadata, experimental)
LOG.debug('End : register runners')
return runner_count
def __init__(self, config: Config, invoke_on_load=False):
self._logger = logging.getLogger(__name__)
self.failed_plugins = list()
self._disabled_plugins = config.plugins.disabled
self._settings_initialized = False
def check(ext: Extension):
return self._check_extension(config, ext)
self.weather = DriverManager(
"blueweather.plugins.weather",
config.plugins.weather_driver,
on_load_failure_callback=self._on_load_fail
)
self.plugins = ExtensionManager(
"blueweather.plugins.plugin",
on_load_failure_callback=self._on_load_fail
)
self.api = EnabledExtensionManager(
"blueweather.plugins.api",
check_func=check,
on_load_failure_callback=self._on_load_fail
)
self.startup = EnabledExtensionManager(
"blueweather.plugins.startup",
check_func=check,
on_load_failure_callback=self._on_load_fail
)
self.settings = EnabledExtensionManager(
"blueweather.plugins.settings",
check_func=check,
on_load_failure_callback=self._on_load_fail
)
self.unitConversion = DispatchExtensionManager(
"blueweather.plugins.unitconv",
check_func=check,
on_load_failure_callback=self._on_load_fail
)
if self._logger.isEnabledFor(logging.INFO):
extensions = self.getAllExtensions()
for k, v in extensions.items():
extensions[k] = '\n\t'.join(v.keys())
extensions = '\n'.join(
["%s: \n\t%s" % (k, v) for k, v in extensions.items()]
)
self._logger.info("Discovered Extensions: \n%s", extensions)
if invoke_on_load:
self.invoke()
def wrapper(*args):
with patch('haas.haas_application.ResultCollector') as result_cls:
with patch('haas.plugins.runner.BaseTestRunner') as runner_class:
environment_manager = ExtensionManager.make_test_instance(
[],
namespace=PluginManager.ENVIRONMENT_HOOK,
)
result_handler = Extension('default', None, result_cls, None)
env_managers = [
(PluginManager.ENVIRONMENT_HOOK, environment_manager),
(
PluginManager.RESULT_HANDLERS,
ExtensionManager.make_test_instance(
[result_handler],
namespace=PluginManager.RESULT_HANDLERS),
),
]
runner = Extension('default', None, runner_class, None)
discoverer = Extension('default', None, Discoverer, None)
driver_managers = [
(
PluginManager.TEST_DISCOVERY,
ExtensionManager.make_test_instance(
[discoverer],
namespace=PluginManager.TEST_DISCOVERY),
),
(
PluginManager.TEST_RUNNER,
ExtensionManager.make_test_instance(
[runner], namespace=PluginManager.TEST_RUNNER),
),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=env_managers,
driver_managers=driver_managers)
args_ = args + (
runner_class,
result_cls,
plugin_manager,
)
return fn(*args_)
def update_dictionary(namespace, original):
"""
Use the extension manager to update a dictionary.
Assumes the keys are strings and the values are lists.
"""
result = defaultdict(list, original)
for extension in ExtensionManager(namespace):
assert isinstance(extension.plugin, dict)
for key, value in extension.plugin.items():
result[key].extend(value)
return dict(result)
def main():
seconds_passed = 0
while True:
for extension in ExtensionManager('pytimed', invoke_on_load=True):
try:
seconds, callable = extension.obj
except:
pass
else:
if seconds_passed % seconds == 0:
callable()
time.sleep(1)
seconds_passed += 1
def run(self):
self.result = ViewList()
ext_manager = ExtensionManager(namespace='metrics_store')
for extension in ext_manager.extensions:
driver_class = extension.plugin
self.add_extension(driver_class)
node = nodes.paragraph()
node.document = self.state.document
self.state.nested_parse(self.result, 0, node)
return node.children
def get_scheme(name):
"""
Returns the user partition scheme with the given name.
"""
# Note: we're creating the extension manager lazily to ensure that the Python path
# has been correctly set up. Trying to create this statically will fail, unfortunately.
if not UserPartition.scheme_extensions:
UserPartition.scheme_extensions = ExtensionManager(namespace=USER_PARTITION_SCHEME_NAMESPACE)
try:
scheme = UserPartition.scheme_extensions[name].plugin # lint-amnesty, pylint: disable=unsubscriptable-object
except KeyError:
raise UserPartitionError("Unrecognized scheme '{0}'".format(name)) # lint-amnesty, pylint: disable=raise-missing-from
scheme.name = name
return scheme
def wrapper(*args):
with patch('haas.haas_application.ResultCollector') as result_cls:
with patch('haas.plugins.runner.BaseTestRunner') as runner_class:
environment_manager = ExtensionManager.make_test_instance(
[], namespace=PluginManager.ENVIRONMENT_HOOK,
)
result_handler = Extension(
'default', None, result_cls, None)
env_managers = [
(PluginManager.ENVIRONMENT_HOOK, environment_manager),
(
PluginManager.RESULT_HANDLERS,
ExtensionManager.make_test_instance(
[result_handler],
namespace=PluginManager.RESULT_HANDLERS),
),
]
runner = Extension('default', None, runner_class, None)
discoverer = Extension('default', None, Discoverer, None)
driver_managers = [
(
PluginManager.TEST_DISCOVERY,
ExtensionManager.make_test_instance(
[discoverer],
namespace=PluginManager.TEST_DISCOVERY),
),
(
PluginManager.TEST_RUNNER,
ExtensionManager.make_test_instance(
[runner], namespace=PluginManager.TEST_RUNNER),
),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=env_managers,
driver_managers=driver_managers)
args_ = args + (runner_class, result_cls, plugin_manager,)
return fn(*args_)
def test_no_driver_hook_found(self):
# Given
driver_managers = [
(PluginManager.TEST_RUNNER, ExtensionManager.make_test_instance(
[], namespace=PluginManager.TEST_RUNNER)),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=(), driver_managers=driver_managers)
parser = ArgumentParser(add_help=False)
# When
plugin_manager.add_plugin_arguments(parser)
# Then
actions = parser._actions
self.assertEqual(len(actions), 0)
def get_insert_cmpt_mgr():
return ExtensionManager.make_test_instance([Extension(
'prepare_data',
'monasca_transform.component.insert.prepare_data:PrepareData',
PrepareData(),
None),
Extension('insert_data',
'tests.functional.component.insert.dummy_insert:'
'DummyInsert',
DummyInsert(),
None),
Extension('insert_data_pre_hourly',
'tests.functional.component.insert.dummy_insert:'
'DummyInsert',
DummyInsert(),
None),
])
def get_setter_cmpt_mgr():
return ExtensionManager.make_test_instance([Extension(
'set_aggregated_metric_name',
'monasca_transform.component.setter.'
'set_aggregated_metric_name:SetAggregatedMetricName',
SetAggregatedMetricName(),
None),
Extension('set_aggregated_period',
'monasca_transform.component.setter.'
'set_aggregated_period:SetAggregatedPeriod',
SetAggregatedPeriod(),
None),
Extension('rollup_quantity',
'monasca_transform.component.setter.'
'rollup_quantity:RollupQuantity',
RollupQuantity(),
None)
])
class Upload(CommonLogic, Menu):
def __init__(self, helpers):
self.unpack_helpers(helpers)
header = u'Upload'
message = (u'Make sure updates are in "new" folder '
'then press "1" to start.')
options = self.make_plugin_options()
super(Upload, self).__init__(header, options, message)
def make_plugin_options(self):
plugin_options = []
self.mgr = ExtensionManager(u'pyiupdater.uploaders')
plugin_names = self.mgr.names()
log.debug(u'Plugin names: {}'.format(plugin_names))
for pgn in plugin_names:
# passing none as a place holder for logic in
# cli.ui.menu for processing of plugin menu creation
# Logic will pass this to else since its len is
# more then 2
log.debug(u'Plugin name: {}'.format(pgn))
option = (pgn, self.upload, None)
plugin_options.append(option)
plugin_options.append((u'Main Menu', self.done))
return plugin_options
def upload(self, name):
# Load plugin & invoke upload method
self.uploader.set_uploader(name)
self.display_menu_header(u'{} Uploader'.format(name))
try:
self.uploader.upload()
time.sleep(3)
except Exception as e:
msg = (u'Looks like you forgot to add USERNAME, PASSWORD '
'and/or REMOTE_DIR')
self.display_msg(msg)
log.debug(str(e), exc_info=True)
input()
def test_driver_hooks_found(self):
# Given
extension = Extension(
'haas.runner', None, BaseTestRunner, None)
driver_managers = [
(PluginManager.TEST_RUNNER, ExtensionManager.make_test_instance(
[extension], namespace=PluginManager.TEST_RUNNER)),
]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=(), driver_managers=driver_managers)
parser = ArgumentParser(add_help=False)
# When
plugin_manager.add_plugin_arguments(parser)
# Then
actions = parser._actions
self.assertEqual(len(actions), 1)
action, = actions
self.assertEqual(action.option_strings, ['--runner'])
def setUp(self):
# Set up two user partition schemes: mock and random
extensions = [
Extension(
self.TEST_SCHEME_NAME, USER_PARTITION_SCHEME_NAMESPACE,
MockUserPartitionScheme(self.TEST_SCHEME_NAME), None
),
Extension(
"random", USER_PARTITION_SCHEME_NAMESPACE, MockUserPartitionScheme("random"), None
),
]
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
extensions, namespace=USER_PARTITION_SCHEME_NAMESPACE
)
# Create a test partition
self.user_partition = UserPartition(
self.TEST_ID,
self.TEST_NAME,
self.TEST_DESCRIPTION,
self.TEST_GROUPS,
extensions[0].plugin
)
def get_usage_cmpt_mgr():
return ExtensionManager.make_test_instance([Extension(
'fetch_quantity',
'monasca_transform.component.usage.'
'fetch_quantity:'
'FetchQuantity',
FetchQuantity(),
None),
Extension(
'fetch_quantity_util',
'monasca_transform.component.usage.'
'fetch_quantity_util:'
'FetchQuantityUtil',
FetchQuantityUtil(),
None),
Extension(
'calculate_rate',
'monasca_transform.component.usage.'
'calculate_rate:'
'CalculateRate',
CalculateRate(),
None),
])
def test_hook_plugin_none(self):
class TestingPlugin(BaseTestingPlugin):
@classmethod
def from_args(cls, args, name, dest_prefix):
return None
# Given
extension = Extension(
'testing-plugin', None, TestingPlugin, None)
environment_manager = ExtensionManager.make_test_instance(
[extension], namespace=PluginManager.ENVIRONMENT_HOOK,
)
hook_managers = [(PluginManager.ENVIRONMENT_HOOK, environment_manager)]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=hook_managers, driver_managers=())
parser = ArgumentParser(add_help=False)
args = parser.parse_args([])
# When
plugin = plugin_manager._create_hook_plugin(extension, args)
# Then
self.assertIsNone(plugin)
def test_environment_hook_options_no_plugins(self):
# Given
environment_manager = ExtensionManager.make_test_instance(
[], namespace=PluginManager.ENVIRONMENT_HOOK,
)
hook_managers = [(PluginManager.ENVIRONMENT_HOOK, environment_manager)]
plugin_manager = PluginManager.testing_plugin_manager(
hook_managers=hook_managers, driver_managers=())
parser = ArgumentParser(add_help=False)
# When
plugin_manager.add_plugin_arguments(parser)
# Then
actions = parser._actions
self.assertEqual(len(actions), 0)
# When
args = parser.parse_args([])
enabled_plugins = plugin_manager.get_enabled_hook_plugins(
plugin_manager.ENVIRONMENT_HOOK, args)
# Then
self.assertEqual(enabled_plugins, [])
def _register_extensions(self, namespace):
"""Register any extensions under the given namespace."""
# Register any extension classes for this class.
extmanager = ExtensionManager(
'extensions.classes.{}'.format(namespace),
propagate_map_exceptions=True
)
if extmanager.extensions:
extmanager.map(util.register_extension_class, base=self)
# Register any extension methods for this class.
extmanager = ExtensionManager(
'extensions.methods.{}'.format(namespace),
propagate_map_exceptions=True
)
if extmanager.extensions:
extmanager.map(util.register_extension_method, base=self)
def register_providers(context):
conn = get_connection('collector')
em = ExtensionManager(Provider.__plugin_ns__)
em.map(_register, context, conn)
def get_data_type_by_name():
data_type_by_name = {}
x_manager = ExtensionManager('crosscompute.types')
for data_type_name, x in zip(x_manager.names(), x_manager.extensions):
data_type_by_name[data_type_name] = x.plugin
return data_type_by_name
def setUp(self):
super(GroupAccessTestCase, self).setUp()
UserPartition.scheme_extensions = ExtensionManager.make_test_instance(
[
Extension(
"memory",
USER_PARTITION_SCHEME_NAMESPACE,
MemoryUserPartitionScheme(),
None
),
Extension(
"random",
USER_PARTITION_SCHEME_NAMESPACE,
MemoryUserPartitionScheme(),
None
)
],
namespace=USER_PARTITION_SCHEME_NAMESPACE
)
self.cat_group = Group(10, 'cats')
self.dog_group = Group(20, 'dogs')
self.worm_group = Group(30, 'worms')
self.animal_partition = UserPartition(
0,
'Pet Partition',
'which animal are you?',
[self.cat_group, self.dog_group, self.worm_group],
scheme=UserPartition.get_scheme("memory"),
)
self.red_group = Group(1000, 'red')
self.blue_group = Group(2000, 'blue')
self.gray_group = Group(3000, 'gray')
self.color_partition = UserPartition(
100,
'Color Partition',
'what color are you?',
[self.red_group, self.blue_group, self.gray_group],
scheme=UserPartition.get_scheme("memory"),
)
self.course = CourseFactory.create(
user_partitions=[self.animal_partition, self.color_partition],
)
with self.store.bulk_operations(self.course.id, emit_signals=False):
chapter = ItemFactory.create(category='chapter', parent=self.course)
section = ItemFactory.create(category='sequential', parent=chapter)
vertical = ItemFactory.create(category='vertical', parent=section)
component = ItemFactory.create(category='problem', parent=vertical)
self.chapter_location = chapter.location
self.section_location = section.location
self.vertical_location = vertical.location
self.component_location = component.location
self.red_cat = UserFactory() # student in red and cat groups
self.set_user_group(self.red_cat, self.animal_partition, self.cat_group)
self.set_user_group(self.red_cat, self.color_partition, self.red_group)
self.blue_dog = UserFactory() # student in blue and dog groups
self.set_user_group(self.blue_dog, self.animal_partition, self.dog_group)
self.set_user_group(self.blue_dog, self.color_partition, self.blue_group)
self.white_mouse = UserFactory() # student in no group
self.gray_worm = UserFactory() # student in deleted group
self.set_user_group(self.gray_worm, self.animal_partition, self.worm_group)
self.set_user_group(self.gray_worm, self.color_partition, self.gray_group)
# delete the gray/worm groups from the partitions now so we can test scenarios
# for user whose group is missing.
self.animal_partition.groups.pop()
self.color_partition.groups.pop()
# add a staff user, whose access will be unconditional in spite of group access.
self.staff = StaffFactory.create(course_key=self.course.id)
def builder_names(ext_mgr=None):
if not ext_mgr:
ext_mgr = ExtensionManager(BUILDER_DRIVER_NAMESPACE)
return ext_mgr.names()
