def fetch(name, conf, namespace=BACKEND_NAMESPACE, **kwargs): """Fetch a jobboard backend with the given configuration. This fetch method will look for the entrypoint name in the entrypoint namespace, and then attempt to instantiate that entrypoint using the provided name, configuration and any board specific kwargs. NOTE(harlowja): to aid in making it easy to specify configuration and options to a board the configuration (which is typical just a dictionary) can also be a URI string that identifies the entrypoint name and any configuration specific to that board. For example, given the following configuration URI:: zookeeper://<not-used>/?a=b&c=d This will look for the entrypoint named 'zookeeper' and will provide a configuration object composed of the URI's components, in this case that is ``{'a': 'b', 'c': 'd'}`` to the constructor of that board instance (also including the name specified). """ board, conf = misc.extract_driver_and_conf(conf, 'board') LOG.debug('Looking for %r jobboard driver in %r', board, namespace) try: mgr = driver.DriverManager(namespace, board, invoke_on_load=True, invoke_args=(name, conf), invoke_kwds=kwargs) return mgr.driver except RuntimeError as e: raise exc.NotFound("Could not find jobboard %s" % (board), e)
def load(flow, store=None, flow_detail=None, book=None, backend=None, namespace=ENGINES_NAMESPACE, engine=ENGINE_DEFAULT, **kwargs): """Load a flow into an engine. This function creates and prepares an engine to run the provided flow. All that is left after this returns is to run the engine with the engines :py:meth:`~zag.engines.base.Engine.run` method. Which engine to load is specified via the ``engine`` parameter. It can be a string that names the engine type to use, or a string that is a URI with a scheme that names the engine type to use and further options contained in the URI's host, port, and query parameters... Which storage backend to use is defined by the backend parameter. It can be backend itself, or a dictionary that is passed to :py:func:`~zag.persistence.backends.fetch` to obtain a viable backend. :param flow: flow to load :param store: dict -- data to put to storage to satisfy flow requirements :param flow_detail: FlowDetail that holds the state of the flow (if one is not provided then one will be created for you in the provided backend) :param book: LogBook to create flow detail in if flow_detail is None :param backend: storage backend to use or configuration that defines it :param namespace: driver namespace for stevedore (or empty for default) :param engine: string engine type or URI string with scheme that contains the engine type and any URI specific components that will become part of the engine options. :param kwargs: arbitrary keyword arguments passed as options (merged with any extracted ``engine``), typically used for any engine specific options that do not fit as any of the existing arguments. :returns: engine """ kind, options = _extract_engine(engine, **kwargs) if isinstance(backend, dict): backend = p_backends.fetch(backend) if flow_detail is None: flow_detail = p_utils.create_flow_detail(flow, book=book, backend=backend) LOG.debug('Looking for %r engine driver in %r', kind, namespace) try: mgr = stevedore.driver.DriverManager(namespace, kind, invoke_on_load=True, invoke_args=(flow, flow_detail, backend, options)) engine = mgr.driver except RuntimeError as e: raise exc.NotFound("Could not find engine '%s'" % (kind), e) else: if store: engine.storage.inject(store) return engine