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