def entrypoint(args=None):
parser = argparse.ArgumentParser()
parser.add_argument('--debug', '-D', action='store_true')
subparsers = parser.add_subparsers(dest='command')
subparsers.required = True
commands = {}
def register_extension(ext, commands=commands):
try:
parser = subparsers.add_parser(ext.name)
commands[ext.name] = ext.plugin(parser)
except Exception:
logger.exception('Error while loading command {}.'.format(
ext.name))
from stevedore import ExtensionManager
mgr = ExtensionManager(namespace='bonobo.commands')
mgr.map(register_extension)
args = parser.parse_args(args).__dict__
if args.pop('debug', False):
settings.DEBUG = True
settings.LOGGING_LEVEL = logging.DEBUG
logging.set_level(settings.LOGGING_LEVEL)
logger.debug('Command: ' + args['command'] + ' Arguments: ' + repr(args))
commands[args.pop('command')](**args)
def entrypoint(args=None):
"""
Main callable for "bonobo" entrypoint.
Will load commands from "bonobo.commands" entrypoints, using stevedore.
"""
mondrian.setup(excepthook=True)
logger = logging.getLogger()
logger.setLevel(settings.LOGGING_LEVEL.get())
parser = argparse.ArgumentParser()
parser.add_argument("--debug", "-D", action="store_true")
subparsers = parser.add_subparsers(dest="command")
subparsers.required = True
commands = {}
def register_extension(ext):
nonlocal commands
try:
parser = subparsers.add_parser(ext.name)
if isinstance(ext.plugin, type) and issubclass(
ext.plugin, BaseCommand):
# current way, class based.
cmd = ext.plugin()
cmd.add_arguments(parser)
cmd.__name__ = ext.name
commands[ext.name] = cmd.handle
else:
# old school, function based.
commands[ext.name] = ext.plugin(parser)
except Exception:
logger.exception("Error while loading command {}.".format(
ext.name))
from stevedore import ExtensionManager
mgr = ExtensionManager(namespace="bonobo.commands")
mgr.map(register_extension)
parsed_args = parser.parse_args(args).__dict__
if parsed_args.pop("debug", False):
settings.DEBUG.set(True)
settings.LOGGING_LEVEL.set(logging.DEBUG)
logger.setLevel(settings.LOGGING_LEVEL.get())
logger.debug("Command: " + parsed_args["command"] + " Arguments: " +
repr(parsed_args))
# Get command handler, execute, rince.
command = commands[parsed_args.pop("command")]
command(**parsed_args)
return 0
def __init__(self):
self._configs = {}
self._features = {}
self._pipelines = {}
def register_feature(ext):
self._features[ext.name] = ext.plugin
mgr = ExtensionManager(namespace='medikit.feature')
mgr.map(register_feature)
def load_feature_extensions():
if not _all_features:
def register_feature(ext, all_features=_all_features):
all_features[ext.name] = ext.plugin
mgr = ExtensionManager(namespace="medikit.feature")
mgr.map(register_feature)
return _all_features
def __init__(self):
self._configs = {}
self._features = {}
self._pipelines = {}
self._variables = OrderedDict()
def register_feature(ext):
self._features[ext.name] = ext.plugin
def on_load_feature_failure(mgr, entrypoint, err):
logger.exception("Exception caught while loading {}.".format(entrypoint), err)
mgr = ExtensionManager(namespace="medikit.feature", on_load_failure_callback=on_load_feature_failure)
mgr.map(register_feature)
def entrypoint(args=None):
parser = argparse.ArgumentParser()
subparsers = parser.add_subparsers(dest='command')
subparsers.required = True
commands = {}
def register_extension(ext, commands=commands):
try:
parser = subparsers.add_parser(ext.name)
commands[ext.name] = ext.plugin(parser)
except Exception:
logging.exception('Error while loading command {}.'.format(ext.name))
mgr = ExtensionManager(
namespace='bonobo.commands',
)
mgr.map(register_extension)
args = parser.parse_args(args).__dict__
commands[args.pop('command')](**args)
def __init__(self, dispatcher: EventDispatcher):
self._configs = {}
self._features = {}
self._pipelines = {}
self._variables = OrderedDict()
self.dispatcher = dispatcher
self.resources = OrderedDict()
def register_feature(ext):
self._features[ext.name] = ext.plugin
def on_load_feature_failure(mgr, entrypoint, err):
logger.exception(
"Exception caught while loading {}.".format(entrypoint), err)
mgr = ExtensionManager(
namespace="medikit.feature",
on_load_failure_callback=on_load_feature_failure)
mgr.map(register_feature)
dispatcher.add_listener(medikit.on_end, self.write_resources)
def find_plugins(self) -> List[PluginSpec]:
from stevedore import ExtensionManager
from stevedore.exception import NoMatches
manager = ExtensionManager(
self.namespace,
invoke_on_load=False,
on_load_failure_callback=self._on_load_failure_callback,
)
# creates for each loadable stevedore extension a PluginSpec
try:
return manager.map(self.to_plugin_spec)
except NoMatches:
LOG.debug("no extensions found in namespace %s", self.namespace)
return []
