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)))
