def load_extensions(self): self._signing_backends = stevedore.ExtensionManager( "anchor.signing_backends") self._validators = stevedore.ExtensionManager("anchor.validators") self._authentication = stevedore.ExtensionManager( "anchor.authentication") self._fixups = stevedore.ExtensionManager("anchor.fixups")
def setUp(self): super(TestToHardwareType, self).setUp() self.driver_classes = list( driver_factory.classic_drivers_to_migrate().values()) self.existing_ifaces = {} for iface in driver_base.ALL_INTERFACES: self.existing_ifaces[iface] = stevedore.ExtensionManager( 'ironic.hardware.interfaces.%s' % iface, invoke_on_load=False).names() self.hardware_types = stevedore.ExtensionManager( 'ironic.hardware.types', invoke_on_load=False).names() # These are the interfaces that don't have a no-op version self.mandatory_interfaces = ['boot', 'deploy', 'management', 'power']
def get_knowledge_base(): """Load the knowledge base, including all content from plugins. :rtype collections.namedtuple :return: The knowledge base with the keys (cpu_info, os_info, platform_info, build_targets, host_guess) """ from e3.platform_db.knowledge_base import ( CPU_INFO, OS_INFO, PLATFORM_INFO, BUILD_TARGETS, HOST_GUESS, ) e3.log.debug("loading knownledge base") # Load all platform_db plugins ext = stevedore.ExtensionManager( namespace="e3.platform_db", invoke_on_load=True, invoke_args=(CPU_INFO, OS_INFO, PLATFORM_INFO, BUILD_TARGETS, HOST_GUESS), ) plugin_names = ext.names() if plugin_names: # Some plugins have been found e3.log.debug("loading knowledge base plugins %s", ",".join(plugin_names)) ext.map_method("update_db") return namedtuple( "KnowledgeBase", ("cpu_info", "os_info", "platform_info", "build_targets", "host_guess"), )(CPU_INFO, OS_INFO, PLATFORM_INFO, BUILD_TARGETS, HOST_GUESS)
def get_knowledge_base(): """Load the knowledge base, including all content from plugins. :rtype collections.namedtuple :return: The knowledge base with the keys (cpu_info, os_info, platform_info, build_targets, host_guess) """ from e3.platform_db.knowledge_base import ( CPU_INFO, OS_INFO, PLATFORM_INFO, BUILD_TARGETS, HOST_GUESS) e3.log.debug('loading knownledge base') # Load all platform_db plugins ext = stevedore.ExtensionManager( namespace='e3.platform_db', invoke_on_load=True, invoke_args=(CPU_INFO, OS_INFO, PLATFORM_INFO, BUILD_TARGETS, HOST_GUESS)) plugin_names = ext.names() if plugin_names: # Some plugins have been found e3.log.debug('loading knowledge base plugins %s', ','.join(plugin_names)) ext.map_method('update_db') return namedtuple('KnowledgeBase', ('cpu_info', 'os_info', 'platform_info', 'build_targets', 'host_guess'))( CPU_INFO, OS_INFO, PLATFORM_INFO, BUILD_TARGETS, HOST_GUESS)
def main(): # In order to see errors during extension loading, you can uncomment the next line. logging.basicConfig(level=logging.DEBUG) # Load tasks configured using entry_points # TODO: launch tasks by their entry_point name stevedore.ExtensionManager('edx.analytics.tasks') configuration = luigi.configuration.get_config() if os.path.exists(OVERRIDE_CONFIGURATION_FILE): log.debug('Using %s', OVERRIDE_CONFIGURATION_FILE) configuration.add_config_path(OVERRIDE_CONFIGURATION_FILE) else: log.debug('Configuration file %s does not exist', OVERRIDE_CONFIGURATION_FILE) # Tell luigi what dependencies to pass to the Hadoop nodes # - boto is used for all direct interactions with s3. # - cjson is used for all parsing event logs. # - filechunkio is used for multipart uploads of large files to s3. # - opaque_keys is used to interpret serialized course_ids # - dependencies of opaque_keys: bson, stevedore luigi.hadoop.attach(boto, cjson, filechunkio, opaque_keys, bson, stevedore, ciso8601) # TODO: setup logging for tasks or configured logging mechanism # Launch Luigi using the default builder with profile_if_necessary(os.getenv('WORKFLOW_PROFILER', ''), os.getenv('WORKFLOW_PROFILER_PATH', '')): luigi.run()
def introspection_data_manager(): global _INTROSPECTION_DATA_MGR if _INTROSPECTION_DATA_MGR is None: _INTROSPECTION_DATA_MGR = stevedore.ExtensionManager( 'ironic_inspector.introspection_data.store', invoke_on_load=True) return _INTROSPECTION_DATA_MGR
def load_hands(): """ 加载hand扩展插件 :return: 返回hand注册字典(单例) :rtype: HandDict """ # 优先进行自带 hand 的注册加载 import mohand.decorator # noqa # 注册hand插件 mgr = stevedore.ExtensionManager(namespace=env.plugin_namespace, invoke_on_load=True) def register_hand(ext): _hand = ext.obj.register() if hasattr(hand, _hand.__name__): raise HandDuplicationOfNameError(_hand.__name__) hand[_hand.__name__] = _hand _pkg, _ver = ext.obj.version() env.version[_pkg] = _ver try: mgr.map(register_hand) except stevedore.exception.NoMatches: pass return hand
def test_entry_point_middleware(self): """Assert that our list of expected middleware is present.""" expected_names = [ 'admin_token_auth', 'build_auth_context', 'crud_extension', 'cors', 'debug', 'endpoint_filter_extension', 'ec2_extension', 'ec2_extension_v3', 'federation_extension', 'json_body', 'oauth1_extension', 'request_id', 'revoke_extension', 's3_extension', 'simple_cert_extension', 'sizelimit', 'token_auth', 'url_normalize', 'user_crud_extension', ] em = stevedore.ExtensionManager('paste.filter_factory') actual_names = [extension.name for extension in em] self.assertThat(actual_names, matchers.ContainsAll(expected_names))
def get_manager(): global _global_manager if not _global_manager: LOG = log.getLogger() extension_manager = stevedore.ExtensionManager( namespace='ironic_python_agent.hardware_managers', invoke_on_load=True) # There will always be at least one extension available (the # GenericHardwareManager). if six.PY2: preferred_extension = sorted(extension_manager, _compare_extensions)[0] else: preferred_extension = sorted( extension_manager, key=functools.cmp_to_key(_compare_extensions))[0] preferred_manager = preferred_extension.obj if preferred_manager.evaluate_hardware_support() <= 0: raise RuntimeError('No suitable HardwareManager could be found') LOG.info('selected hardware manager {0}'.format( preferred_extension.entry_point_target)) _global_manager = preferred_manager return _global_manager
def rule_actions_manager(): """Create a Stevedore extension manager for actions in rules.""" global _ACTIONS_MGR if _ACTIONS_MGR is None: _ACTIONS_MGR = stevedore.ExtensionManager( 'ironic_inspector.rules.actions', invoke_on_load=True) return _ACTIONS_MGR
def get_ampt_version(with_plugins=False): '''Return software version info. :param with_plugins: whether to include information about installed monitor plugins :return: version info string ''' version_core = u'{} {}'.format(__application_title__, __version__) if with_plugins: import stevedore mgr = stevedore.ExtensionManager(namespace='ampt_monitor.plugin', invoke_on_load=False) plugin_info = [version_core] if len(mgr.extensions): from tabulate import tabulate #plugin_info.append('[Installed plugins]') plugin_entry = [] for p in mgr.list_entry_points(): plug_ver = pkg_resources.get_distribution(p.module_name.split('.')[0]).version plugin_entry.append(['', '[plugin]', p.name, plug_ver, p.attrs[0], p.module_name]) plugin_info.append(tabulate(plugin_entry, tablefmt='plain')) return '\n'.join(plugin_info) else: return version_core
def rule_conditions_manager(): """Create a Stevedore extension manager for conditions in rules.""" global _CONDITIONS_MGR if _CONDITIONS_MGR is None: _CONDITIONS_MGR = stevedore.ExtensionManager( 'ironic_inspector.rules.conditions', invoke_on_load=True) return _CONDITIONS_MGR
def __init__(self): self.ext_plugins = stevedore.ExtensionManager( 'tempest.test_plugins', invoke_on_load=True, propagate_map_exceptions=True, on_load_failure_callback=self.failure_hook) self._register_service_clients()
def get_available_model_names(): """Get the names of all the models that are available on the system. :returns: A list of names. :rtype: frozenset """ mgr = stevedore.ExtensionManager(namespace=MODEL_NAMESPACE) return frozenset(mgr.names())
def __init__(self, plugins): self._plugins = { name: stevedore.extension.Extension(name, None, plugin, plugin()) for name, plugin in plugins.items() } self._stevedore_manager = stevedore.ExtensionManager( "qiskit.unitary_synthesis", invoke_on_load=True, propagate_map_exceptions=True)
def list_extensions(namespace): """List the names of the extensions available in a given namespace. """ extensions = stevedore.ExtensionManager( namespace=namespace, invoke_on_load=False, on_load_failure_callback=on_load_failure, ) return extensions.names()
def extensions(self): extension_manager = stevedore.ExtensionManager( 'octane.handlers.' + self.name, on_load_failure_callback=self.on_load_failure_callback, ) extensions = dict( extension_manager.map(lambda ext: (ext.name, ext.plugin))) self.__dict__['extensions'] = extensions return extensions
def test_plugins_are_all_opts(self): manager = stevedore.ExtensionManager(loading.PLUGIN_NAMESPACE, propagate_map_exceptions=True) def inner(driver): for p in driver.plugin().get_options(): self.assertIsInstance(p, loading.Opt) manager.map(inner)
def load_commands(self, namespace): """Load all the commands from an entrypoint""" self.group_list.append(namespace) for ep in stevedore.ExtensionManager(namespace): LOG.debug('found command %r', ep.name) cmd_name = (ep.name.replace('_', ' ') if self.convert_underscores else ep.name) self.commands[cmd_name] = ep.entry_point return
def handle(self, *args, **options): mgr = stevedore.ExtensionManager(namespace='moear.spider', invoke_on_load=True) def register_spdier(ext): data = ext.obj.register() # 持久化Spider数据 spider_serializer = SpiderSerializer(data=data, exclude=['enabled']) if not spider_serializer.is_valid(): self.stderr.write(self.style.ERROR(spider_serializer.errors)) raise CommandError(spider_serializer.errors) spider_serializer.save() # 持久化SpiderMeta数据 spidermeta_serializer = SpiderMetaSerializer(data=data.get( 'meta', {}), many=True) if not spidermeta_serializer.is_valid(): self.stderr.write( self.style.ERROR(spidermeta_serializer.errors)) raise CommandError(spidermeta_serializer.errors) spidermeta_serializer.save(spider=spider_serializer.instance) # 创建计划任务 spider = spider_serializer.instance crawl_schedule = SpiderMeta.objects.get( spider=spider, name='crawl_schedule').value crawl_schedule_list = crawl_schedule.split() schedule, _ = CrontabSchedule.objects.get_or_create( minute=crawl_schedule_list[0], hour=crawl_schedule_list[1], day_of_week=crawl_schedule_list[2], day_of_month=crawl_schedule_list[3], month_of_year=crawl_schedule_list[4]) task_name = 'core.tasks.periodic_chain_crawl_package_deliver' try: periodic_task = PeriodicTask.objects.get( name='Crawl Spider [{}]'.format(spider.name)) periodic_task.crontab = schedule periodic_task.task = task_name periodic_task.save() except PeriodicTask.DoesNotExist: periodic_task = PeriodicTask.objects.create( crontab=schedule, name='Crawl Spider [{}]'.format(spider.name), task=task_name, args=json.dumps([spider.name]), ) spider.save() # 根据Spider使能配置,更新计划任务的使能状态 self.stdout.write( self.style.SUCCESS('[{name}] 注册成功!'.format(name=ext.name))) mgr.map(register_spdier)
def test_entry_point(self): em = stevedore.ExtensionManager('oslo.config.opts', invoke_on_load=True) for extension in em: if extension.name == 'keystonemiddleware.auth_token': break else: self.fail('keystonemiddleware.auth_token not found') self._test_list_auth_token_opts(extension.obj)
def load_source(cls) -> List[source.Base]: """load add source from entry_points :return: return a list contains enabled sources """ return [ x.plugin for x in stevedore.ExtensionManager(namespace.SOURCE, invoke_on_load=True).extensions ]
def test_entry_point(self): result = None for ext in stevedore.ExtensionManager('oslo.config.opts', invoke_on_load=True): if ext.name == "oslo.messaging": result = ext.obj break self.assertIsNotNone(result) self._test_list_opts(result)
def get_command_names(self, group=None): """Returns a list of commands loaded for the specified group""" group_list = [] if group is not None: for ep in stevedore.ExtensionManager(group): cmd_name = (ep.name.replace('_', ' ') if self.convert_underscores else ep.name) group_list.append(cmd_name) return group_list return list(self.commands.keys())
def test_plugins_are_all_opts(self): manager = stevedore.ExtensionManager(base.PLUGIN_NAMESPACE, invoke_on_load=False, propagate_map_exceptions=True) def inner(driver): for p in driver.plugin.get_options(): self.assertIsInstance(p, cfg.Opt) manager.map(inner)
def get_extensions(): global extension_checks if extension_checks is None: em = stevedore.ExtensionManager('oslo.policy.rule_checks', invoke_on_load=False) extension_checks = { extension.name: extension.plugin for extension in em } return extension_checks
def get_available_models(): """Retrieve all the models available on the system. :returns: A dict with model entrypoint name as the key and the model as the value. :rtype: dict """ mgr = stevedore.ExtensionManager(namespace=MODEL_NAMESPACE, propagate_map_exceptions=True) return dict(mgr.map(lambda ext: (ext.entry_point.name, ext.plugin)))
def get_available_plugin_names(): """Get the names of all the plugins that are available on the system. This is particularly useful for help and error text to prompt a user for example what plugins they may specify. :returns: A list of names. :rtype: frozenset """ mgr = stevedore.ExtensionManager(namespace=PLUGIN_NAMESPACE) return frozenset(mgr.names())
def load_plugins(self): if self.plugins is not None: return self.plugins = stevedore.ExtensionManager( 'muranopkgcheck.plugins', invoke_on_load=True, propagate_map_exceptions=True, on_load_failure_callback=self.failure_hook) plugin_validators = list(itertools.chain( *(p.obj.validators() for p in self.plugins) )) self.validators += plugin_validators
def get_available_plugin_classes(): """Retrieve all the plugin classes available on the system. :returns: A dict with plugin entrypoint name as the key and the plugin class as the value. :rtype: dict """ mgr = stevedore.ExtensionManager(namespace=PLUGIN_NAMESPACE, propagate_map_exceptions=True, invoke_on_load=False) return dict(mgr.map(lambda ext: (ext.entry_point.name, ext.plugin)))