def discover_auth_systems():
"""Discover the available auth-systems.
This won't take into account the old style auth-systems.
"""
global _discovered_plugins
_discovered_plugins = {}
def add_plugin(ext):
_discovered_plugins[ext.name] = ext.plugin
ep_namespace = "rally.openstack.common.apiclient.auth"
mgr = extension.ExtensionManager(ep_namespace)
mgr.map(add_plugin)
def create_parser(self):
parser = argparse.ArgumentParser()
parser.add_argument('--conf',
dest='conf',
default=None,
help='configuration file')
parser.add_argument('-l',
'--log_level',
dest='log_level',
default='info',
help="log level (default: %(default)s)")
parser.add_argument(
'--use-cache',
action='store_true',
dest='use_cache',
default=False,
help='ignore the cache and update the jobs anyhow (that will only '
'flush the specified jobs cache)')
# parser.add_argument(
# '--flush-cache',
# action='store_true',
# dest='flush_cache',
# default=False,
# help='flush all the cache entries before updating'
# )
# parser.add_argument(
# '--version',
# dest='version',
# action='version',
# version=__version__(),
# help='show version'
# )
subparser = parser.add_subparsers(
# help='deploy jenkins configuration',
dest='command')
extension_manager = extension.ExtensionManager(
namespace='jenkins_manager.cli.subcommands',
invoke_on_load=True,
)
def parse_subcommand_args(ext, subparser):
ext.obj.parse_args(subparser)
extension_manager.map(parse_subcommand_args, subparser)
return parser
def get_evaluators():
global _EXP_EVALUATORS
global _EXP_EVALUATORS_LOCK
with _EXP_EVALUATORS_LOCK:
if _EXP_EVALUATORS is None:
_EXP_EVALUATORS = {}
mgr = extension.ExtensionManager(
namespace=_EXP_EVALUATOR_NAMESPACE, invoke_on_load=False)
for name in mgr.names():
_EXP_EVALUATORS[name] = get_evaluator(name)
return _EXP_EVALUATORS
def get_custom_functions():
"""Get custom functions.
Retrieves the list of custom functions used in YAQL/Jinja expressions.
"""
# {name => function object).
result = dict()
mgr = extension.ExtensionManager(namespace='mistral.expression.functions',
invoke_on_load=False)
for name in mgr.names():
result[name] = mgr[name].plugin
return result
def setUp(self):
super(TestStateBase, self).setUp()
# override the extensions to the test extensions
test_extensions = extension.ExtensionManager(
namespace='diskimage_builder.block_device.plugin_test',
invoke_on_load=False)
extensions_fixture = fixtures.MonkeyPatch(
'diskimage_builder.block_device.config._extensions',
test_extensions)
self.useFixture(extensions_fixture)
# status and other bits saved here
self.build_dir = fixtures.TempDir()
self.useFixture(self.build_dir)
def discover_auth_systems():
"""Discover the available auth-systems.
This won't take into account the old style auth-systems.
"""
ep_name = 'openstack.client.auth_plugin'
emgr = extension.ExtensionManager(ep_name, invoke_on_load=False)
for ext in emgr:
try:
auth_plugin = ext.plugin
except ImportError as e:
logger.debug("ERROR: Cannot load auth plugin %s" % ext.name)
logger.debug(e, exc_info=1)
else:
_discovered_plugins[ext.name] = auth_plugin
def test_extension_failure_custom_callback():
errors = []
def failure_callback(manager, entrypoint, error):
errors.append((manager, entrypoint, error))
em = extension.ExtensionManager('stevedore.test.extension',
invoke_on_load=True,
on_load_failure_callback=failure_callback)
extensions = list(em.extensions)
assert len(extensions) > 0
assert len(errors) == 2
for manager, entrypoint, error in errors:
assert manager is em
assert isinstance(error, (IOError, ImportError))
def reload_extensions(self):
lock = lockutils.lock('rating-modules')
with lock:
ck_utils.refresh_stevedore(PROCESSORS_NAMESPACE)
# FIXME(sheeprine): Implement RPC messages to trigger reload on
# processors
self.extensions = extension.ExtensionManager(
PROCESSORS_NAMESPACE,
# FIXME(sheeprine): don't want to load it here as we just need
# the controller
invoke_on_load=True)
if not self._first_call:
self.notify_reload()
else:
self._first_call = False
def _setup_pipeline_manager(cfg_file, transformer_manager, p_type=SAMPLE_TYPE):
if not os.path.exists(cfg_file):
cfg_file = cfg.CONF.find_file(cfg_file)
LOG.debug("Pipeline config file: %s", cfg_file)
with open(cfg_file) as fap:
data = fap.read()
pipeline_cfg = yaml.safe_load(data)
LOG.info(_("Pipeline config: %s"), pipeline_cfg)
return PipelineManager(
pipeline_cfg, transformer_manager
or extension.ExtensionManager('ceilometer.transformer', ), p_type)
def _load_notification_manager():
global _notification_manager, _pipeline_manager
namespace = 'ceilometer.notification'
LOG.debug(_('loading notification handlers from %s'), namespace)
_notification_manager = extension.ExtensionManager(
namespace=namespace,
invoke_on_load=True,
invoke_args=(_pipeline_manager, ))
if not list(_notification_manager):
LOG.warning(_('Failed to load any notification handlers for %s'),
namespace)
def _load_resources_definitions(cls, conf):
plugin_manager = extension.ExtensionManager(
namespace='ceilometer.event.trait_plugin')
data = declarative.load_definitions(
{}, conf.dispatcher_gnocchi.resources_definition_file)
resource_defs = []
for resource in data.get('resources', []):
try:
resource_defs.append(
ResourcesDefinition(resource,
conf.dispatcher_gnocchi.archive_policy,
plugin_manager))
except Exception as exc:
LOG.error(_LE("Failed to load resource due to error %s") % exc)
return resource_defs
def get_custom_functions():
"""Get custom functions
Retreives the list of custom evaluation functions
"""
functions = dict()
mgr = extension.ExtensionManager(
namespace='mistral.expression.functions',
invoke_on_load=False
)
for name in mgr.names():
functions[name] = mgr[name].plugin
return functions
def __init__(self, dbapi=None, path=None):
if path is None:
path = common.PUPPET_HIERADATA_PATH
self.dbapi = dbapi
self.path = path
puppet_plugins = extension.ExtensionManager(
namespace='systemconfig.puppet_plugins',
invoke_on_load=True, invoke_args=(self,))
self.puppet_plugins = sorted(puppet_plugins, key=lambda x: x.name)
for plugin in self.puppet_plugins:
plugin_name = plugin.name[4:]
setattr(self, plugin_name, plugin.obj)
LOG.debug("Loaded puppet plugin %s" % plugin.name)
def test_map_arguments(self):
objs = []
def mapped(ext, *args, **kwds):
objs.append((ext, args, kwds))
em = extension.ExtensionManager('stevedore.test.extension',
invoke_on_load=True,
)
em.map(mapped, 1, 2, a='A', b='B')
self.assertEqual(len(objs), 2)
names = sorted([o[0].name for o in objs])
self.assertEqual(names, WORKING_NAMES)
for o in objs:
self.assertEqual(o[1], (1, 2))
self.assertEqual(o[2], {'a': 'A', 'b': 'B'})
def test_map_arguments():
objs = []
def mapped(ext, *args, **kwds):
objs.append((ext, args, kwds))
em = extension.ExtensionManager('stevedore.test.extension',
invoke_on_load=True,
)
em.map(mapped, 1, 2, a='A', b='B')
assert len(objs) == 2
names = sorted([o[0].name for o in objs])
assert names == ['t1', 't2']
for o in objs:
assert o[1] == (1, 2)
assert o[2] == {'a': 'A', 'b': 'B'}
def test_extension_failure_custom_callback(self):
errors = []
def failure_callback(manager, entrypoint, error):
errors.append((manager, entrypoint, error))
em = extension.ExtensionManager('stevedore.test.extension',
invoke_on_load=True,
on_load_failure_callback=
failure_callback)
extensions = list(em.extensions)
self.assertThat(len(extensions), GreaterThan(0))
self.assertEqual(len(errors), 2)
for manager, entrypoint, error in errors:
self.assertIs(manager, em)
self.assertIsInstance(error, (IOError, ImportError))
def fetch_checks(cfg):
base = [
checks.CheckValidity(cfg),
checks.CheckTrailingWhitespace(cfg),
checks.CheckIndentationNoTab(cfg),
checks.CheckCarriageReturn(cfg),
checks.CheckMaxLineLength(cfg),
checks.CheckNewlineEndOfFile(cfg),
]
mgr = extension.ExtensionManager(
namespace="doc8.extension.check", invoke_on_load=True, invoke_args=(cfg.copy(),)
)
addons = []
for e in mgr:
addons.append(e.obj)
return base + addons
def load():
global _EXP_FUNC_CATALOG
global _EXP_FUNC_CATALOG_LOCK
with _EXP_FUNC_CATALOG_LOCK:
if _EXP_FUNC_CATALOG is None:
_EXP_FUNC_CATALOG = {}
mgr = extension.ExtensionManager(
namespace="orquesta.expressions.functions",
invoke_on_load=False)
for name in mgr.names():
_EXP_FUNC_CATALOG[name] = mgr[name].plugin
return _EXP_FUNC_CATALOG
def __init__(self, app, conf):
super(GlanceBillingProtocol, self).__init__(app, conf)
self.resource_regex = re.compile(
r"^/%s/%s/%s([.][^.]+)?$" % (API_VERSION, RESOURCE_RE, UUID_RE),
re.UNICODE)
self.create_resource_regex = re.compile(
r"^/%s/%s([.][^.]+)?$" % (API_VERSION, RESOURCE_RE), re.UNICODE)
self.position = 2
self.resource_regexs = [
self.resource_regex,
]
self.product_items = extension.ExtensionManager(
namespace='gringotts.snapshot.product_items',
invoke_on_load=True,
invoke_args=(self.gclient, ))
def load():
global PROVIDERS
global DEFAULT_PROVIDER
mgr = extension.ExtensionManager(
namespace='streamglob.providers',
on_load_failure_callback=log_plugin_exception,
)
PROVIDERS = AttrDict((x.name, x.plugin()) for x in mgr)
load_config()
if len(config.settings.profile.providers):
# first listed in config
DEFAULT_PROVIDER = list(config.settings.profile.providers.keys())[0]
else:
# first loaded
DEFAULT_PROVIDER = list(PROVIDERS.keys())[0]
def _extensions(category, agent_ns=None):
namespace = ('ceilometer.%s.%s' %
(category, agent_ns) if agent_ns else 'ceilometer.%s' %
category)
def _catch_extension_load_error(mgr, ep, exc):
# Extension raising ExtensionLoadError can be ignored
if isinstance(exc, plugin_base.ExtensionLoadError):
LOG.error(_("Skip loading extension for %s") % ep.name)
return
raise exc
return extension.ExtensionManager(
namespace=namespace,
invoke_on_load=True,
on_load_failure_callback=_catch_extension_load_error,
)
def extension_mode(parsed_args, data):
mgr = extension.ExtensionManager(
namespace='stevedore.example.formatter',
invoke_on_load=True,
invoke_args=(parsed_args.width, ),
)
def format_data(ext, data):
return (ext.name, ext.obj.format(data))
results = mgr.map(format_data, data)
for name, result in results:
print('Formatter: {0}'.format(name))
for chunk in result:
print(chunk, end='')
print('')
def _load_plugins(self):
global PLUGINS_CACHE
if not self.namespace:
raise ValueError('You must redefine BaseClient.namespace')
if self.namespace not in PLUGINS_CACHE:
PLUGINS_CACHE[self.namespace] = list(
extension.ExtensionManager(self.namespace))
plugins = PLUGINS_CACHE[self.namespace]
if not plugins:
logger.warning('No commands found')
return
for ext in plugins:
setattr(self, ext.name, ext.plugin(self))
def load_validators():
global VALIDATORS
def _report_load_failure(mgr, ep, err):
LOG.warning(u'Failed to load %s: %s', ep.module_name, err)
mgr = extension.ExtensionManager(
'nova.api.extra_spec_validators',
on_load_failure_callback=_report_load_failure,
invoke_on_load=False,
)
for ext in mgr:
# TODO(stephenfin): Make 'register' return a dict rather than a list?
for validator in ext.plugin.register():
VALIDATORS[validator.name] = validator
if ':' in validator.name_regex:
NAMESPACES.add(validator.name_regex.split(':', 1)[0])
def __init__(self, config):
'''Read in the modules'''
Digraph.__init__(self)
self._config = config
self.__reqdeps_sorted = None
# The different types of tags
self.__tagtypes = {}
self.__tagtypes[InputModuleTypes.reqtag] = {}
self.__tagtypes[InputModuleTypes.reqdeps] = {}
self.__tagtypes[InputModuleTypes.ctstag] = {}
self.__tagtypes[InputModuleTypes.testcase] = {}
self.__plugin_manager = extension.ExtensionManager(
namespace='rmtoo.input.plugin', invoke_on_load=False)
self.__load()
def _load_hooks(self):
# Look for command extensions
if self.app and self.cmd_name:
namespace = '{}.{}'.format(self.app.command_manager.namespace,
self.cmd_name.replace(' ', '_'))
self._hooks = extension.ExtensionManager(
namespace=namespace,
invoke_on_load=True,
invoke_kwds={
'command': self,
},
)
else:
# Setting _hooks to an empty list allows iteration without
# checking if there are hooks every time.
self._hooks = []
return
def initialize(reset=False):
global _EXT_MANAGER
if reset or (_EXT_MANAGER is None):
_EXT_MANAGER = extension.ExtensionManager(namespace='os_acc',
invoke_on_load=False)
loaded_plugins = []
for plugin_name in _EXT_MANAGER.names():
cls = _EXT_MANAGER[plugin_name].plugin
obj = cls.load(plugin_name)
LOG.debug(("Loaded ACC plugin class '%(cls)s' "
"with name '%(plugin_name)s'"), {
'cls': cls,
'plugin_name': plugin_name
})
loaded_plugins.append(plugin_name)
_EXT_MANAGER[plugin_name].obj = obj
LOG.info("Loaded ACC plugins: %s", ", ".join(loaded_plugins))
def test_match(self):
resource = {
'metrics':
['image', 'image.size', 'image.download', 'image.serve'],
'attributes':
{'container_format': 'resource_metadata.container_format',
'disk_format': 'resource_metadata.disk_format',
'name': 'resource_metadata.name'},
'event_delete': 'image.delete',
'event_attributes': {'id': 'resource_id'},
'resource_type': 'image'}
plugin_manager = extension.ExtensionManager(
namespace='ceilometer.event.trait.trait_plugin')
rd = gnocchi.ResourcesDefinition(
resource, "high", "low", plugin_manager)
operation = rd.event_match("image.delete")
self.assertEqual('delete', operation)
def _load_resources_definitions(conf, archive_policy,
resources_definition_file):
plugin_manager = extension.ExtensionManager(
namespace='ceilometer.event.trait_plugin')
data = declarative.load_definitions(
conf, {}, resources_definition_file,
pkg_resources.resource_filename(__name__,
"data/gnocchi_resources.yaml"))
resource_defs = []
for resource in data.get('resources', []):
try:
resource_defs.append(
ResourcesDefinition(resource, archive_policy,
plugin_manager))
except Exception as exc:
LOG.error("Failed to load resource due to error %s" % exc)
return resource_defs
def get_subcommand_parser(self, version):
parser = self.get_base_parser()
self.subcommands = {}
subparsers = parser.add_subparsers(metavar='<subcommand>')
submodule = utils.import_versioned_module(version, 'shell')
self._find_actions(subparsers, submodule)
self._find_actions(subparsers, collector_shell)
self._find_actions(subparsers, report_shell)
self._find_actions(subparsers, storage_shell)
extensions = extension.ExtensionManager(SUBMODULES_NAMESPACE, )
for ext in extensions:
shell = ext.plugin.get_shell()
self._find_actions(subparsers, shell)
self._find_actions(subparsers, self)
self._add_bash_completion_subparser(subparsers)
return parser
