Ejemplo n.º 1
0
 def start(self):
     # Anything to start?
     am_started = 0
     apps_to_start = self._get_apps_to_start()
     if not apps_to_start:
         return am_started
     # Select how we are going to start it
     run_type = self._fetch_run_type()
     starter = importer.import_entry_point(run_type)(self)
     for app_info in apps_to_start:
         app_name = app_info["name"]
         app_pth = app_info.get("path", app_name)
         app_dir = app_info.get("app_dir", self.get_option('app_dir'))
         # Adjust the program options now that we have real locations
         program_opts = utils.param_replace_list(self._get_app_options(app_name), self._get_param_map(app_name))
         # Start it with the given settings
         LOG.debug("Starting %r using %r", app_name, run_type)
         details_fn = starter.start(app_name, app_pth=app_pth, app_dir=app_dir, opts=program_opts)
         LOG.info("Started %s details are in %s", colorizer.quote(app_name), colorizer.quote(details_fn))
         # This trace is used to locate details about what to stop
         self.tracewriter.app_started(app_name, details_fn, run_type)
         if app_info.get('sleep_time'):
             LOG.info("%s requested a %s second sleep time, please wait...", colorizer.quote(app_name), app_info.get('sleep_time'))
             sh.sleep(app_info.get('sleep_time'))
         am_started += 1
     return am_started
Ejemplo n.º 2
0
 def __init__(self, installer):
     super(QuantumConfigurator, self).__init__(installer, CONFIGS)
     self.core_plugin = installer.get_option("core_plugin")
     self.plugin_configurator = importer.import_entry_point(
         "anvil.components.configurators.quantum_plugins.%s:%sConfigurator" %
         (self.core_plugin, self.core_plugin.title()))(installer)
     self.config_adjusters = {
         PASTE_CONF: self._config_adjust_paste,
         API_CONF: self._config_adjust_api,
     }
     self.config_adjusters.update(self.plugin_configurator.config_adjusters)
Ejemplo n.º 3
0
def make_packager(package, default_class, **kwargs):
    packager_name = package.get("packager_name") or ""
    packager_name = packager_name.strip()
    if packager_name:
        packager_cls = importer.import_entry_point(packager_name)
    else:
        packager_cls = default_class
    if packager_cls in _PACKAGERS:
        return _PACKAGERS[packager_cls]
    p = packager_cls(**kwargs)
    _PACKAGERS[packager_cls] = p
    return p
Ejemplo n.º 4
0
def make_packager(package, default_class, **kwargs):
    packager_name = package.get('packager_name') or ''
    packager_name = packager_name.strip()
    if packager_name:
        packager_cls = importer.import_entry_point(packager_name)
    else:
        packager_cls = default_class
    if packager_cls in _PACKAGERS:
        return _PACKAGERS[packager_cls]
    p = packager_cls(**kwargs)
    _PACKAGERS[packager_cls] = p
    return p
Ejemplo n.º 5
0
 def extract_component(self, name, action):
     """Return the class + component info to use for doing the action w/the component."""
     try:
         # Use a copy instead of the original
         component_info = copy.deepcopy(self._components[name])
         action_classes = dict(component_info['action_classes'])
         entry_point = action_classes[action]
         del action_classes[action]
         cls = importer.import_entry_point(entry_point)
         return ((cls, component_info), action_classes)
     except KeyError:
         raise RuntimeError('No class configured to %r %r on %r' %
                            (action, name, self.name))
Ejemplo n.º 6
0
 def extract_component(self, name, action):
     """Return the class + component info to use for doing the action w/the component."""
     try:
         # Use a copy instead of the original
         component_info = copy.deepcopy(self._components[name])
         action_classes = component_info['action_classes']
         entry_point = action_classes[action]
         del action_classes[action]
         cls = importer.import_entry_point(entry_point)
         return ((cls, component_info), action_classes)
     except KeyError:
         raise RuntimeError('No class configured to %r %r on %r' %
                            (action, name, self.name))
Ejemplo n.º 7
0
 def get_packager_for(self, pkg_info):
     packager_name = pkg_info.get(self.PACKAGER_KEY_NAME)
     if not packager_name or not packager_name.strip():
         packager = self._get_default_pkgr()
     else:
         if packager_name in self.fetched_packagers:
             packager = self.fetched_packagers[packager_name]
         else:
             packager_cls = importer.import_entry_point(packager_name)
             LOG.debug('Loading custom package manager %s for package %r', packager_cls, pkg_info['name'])
             packager = self._construct_pkger(packager_cls)
             self.fetched_packagers[packager_name] = packager
     return packager
Ejemplo n.º 8
0
 def _construct_siblings(self, name, siblings, params, sibling_instances):
     there_siblings = {}
     for (action, cls_name) in siblings.items():
         if action not in sibling_instances:
             sibling_instances[action] = {}
         cls = importer.import_entry_point(cls_name)
         sibling_params = utils.merge_dicts(params, self.cli_opts, preserve=True)
         sibling_params["instances"] = sibling_instances[action]
         LOG.debug("Construction of sibling component %r (%r) params are:", name, action)
         utils.log_object(sibling_params, logger=LOG, level=logging.DEBUG)
         a_sibling = cls(**sibling_params)
         # Update the sibling we are returning and the corresponding
         # siblings for that action (so that the sibling can have the
         # correct 'sibling' instances associated with it, if it needs those...)
         there_siblings[action] = a_sibling
         sibling_instances[action][name] = a_sibling
     return there_siblings
Ejemplo n.º 9
0
    def __init__(self, installer):
        super(NeutronConfigurator, self).__init__(installer, CONFIGS)
        self.core_plugin = installer.get_option("core_plugin")
        self.plugin_configurators = {
            'core_plugin': importer.import_entry_point(
                "anvil.components.configurators.neutron_plugins.%s:%sConfigurator" %
                (self.core_plugin, self.core_plugin.title()))(installer),
            'l3': l3.L3Configurator(installer),
            'dhcp': dhcp.DhcpConfigurator(installer),
        }

        self.config_adjusters = {
            PASTE_CONF: self._config_adjust_paste,
            API_CONF: self._config_adjust_api,
        }
        for plugin_configurator in self.plugin_configurators.values():
            self.config_adjusters.update(plugin_configurator.config_adjusters)
Ejemplo n.º 10
0
 def _locate_investigators(self, apps_started):
     investigators = dict()
     to_investigate = list()
     for (app_name, trace_fn, how) in apps_started:
         inv_cls = None
         try:
             inv_cls = importer.import_entry_point(how)
         except RuntimeError as e:
             LOG.warn("Could not load class %s which should be used to investigate %s: %s",
                         colorizer.quote(how), colorizer.quote(app_name), e)
             continue
         investigator = None
         if inv_cls in investigators:
             investigator = investigators[inv_cls]
         else:
             investigator = inv_cls(self)
             investigators[inv_cls] = investigator
         to_investigate.append((app_name, investigator))
     return to_investigate
Ejemplo n.º 11
0
 def _construct_siblings(self, name, siblings, params, sibling_instances):
     there_siblings = {}
     for (action, cls_name) in siblings.items():
         if action not in sibling_instances:
             sibling_instances[action] = {}
         cls = importer.import_entry_point(cls_name)
         sibling_params = utils.merge_dicts(params,
                                            self.cli_opts,
                                            preserve=True)
         sibling_params['instances'] = sibling_instances[action]
         LOG.debug("Construction of sibling component %r (%r) params are:",
                   name, action)
         utils.log_object(sibling_params, logger=LOG, level=logging.DEBUG)
         a_sibling = cls(**sibling_params)
         # Update the sibling we are returning and the corresponding
         # siblings for that action (so that the sibling can have the
         # correct 'sibling' instances associated with it, if it needs those...)
         there_siblings[action] = a_sibling
         sibling_instances[action][name] = a_sibling
     return there_siblings
Ejemplo n.º 12
0
    def __init__(self, installer):
        super(NeutronConfigurator, self).__init__(installer, CONFIGS)
        self.core_plugin = installer.get_option("core_plugin")
        self.plugin_configurators = {
            'core_plugin':
            importer.import_entry_point(
                "anvil.components.configurators.neutron_plugins.%s:%sConfigurator"
                % (self.core_plugin, self.core_plugin.title()))(installer),
            'l3':
            l3.L3Configurator(installer),
            'dhcp':
            dhcp.DhcpConfigurator(installer),
        }

        self.config_adjusters = {
            PASTE_CONF: self._config_adjust_paste,
            API_CONF: self._config_adjust_api,
        }
        for plugin_configurator in self.plugin_configurators.values():
            self.config_adjusters.update(plugin_configurator.config_adjusters)
Ejemplo n.º 13
0
 def configure(self):
     # Anything to configure for starting?
     apps_to_start = self._get_apps_to_start()
     am_configured = 0
     if not apps_to_start:
         return am_configured
     # First make a pass and make sure all runtime
     # (e.g. upstart starting)
     # config files are in place....
     run_type = self._fetch_run_type()
     configurer = importer.import_entry_point(run_type)(self)
     for app_info in apps_to_start:
         app_name = app_info["name"]
         app_pth = app_info.get("path", app_name)
         app_dir = app_info.get("app_dir", self.get_option('app_dir'))
         # Configure it with the given settings
         LOG.debug("Configuring runner %r for program %r", run_type, app_name)
         cfg_am = configurer.configure(app_name,
                  app_pth=app_pth, app_dir=app_dir,
                  opts=utils.param_replace_list(self._get_app_options(app_name), self._get_param_map(app_name)))
         LOG.debug("Configured %s files for runner for program %r", cfg_am, app_name)
         am_configured += cfg_am
     return am_configured
Ejemplo n.º 14
0
def get_packager_class(package_info, default_packager_class=None):
    packager_name = package_info.get('packager_name') or ''
    packager_name = packager_name.strip()
    if not packager_name:
        return default_packager_class
    return importer.import_entry_point(packager_name)
Ejemplo n.º 15
0
 def install_helper_class(self):
     """Return an install helper that will work for this distro."""
     return importer.import_entry_point(self._install_helper)
Ejemplo n.º 16
0
 def get_default_package_manager_cls(self):
     """Return a package manager that will work for this distro."""
     return importer.import_entry_point(self._packager_name)
Ejemplo n.º 17
0
 def package_manager_class(self):
     """Return a package manager that will work for this distro."""
     return importer.import_entry_point(self._packager_name)
Ejemplo n.º 18
0
 def __init__(self, cfg):
     # Late load since its using a client lib that is only avail after install...
     self.cfg = cfg
     client_cls = importer.import_entry_point("keystoneclient.v2_0.client:Client")
     self.client = client_cls(token=self.cfg['service_token'],
         endpoint=self.cfg['endpoints']['admin']['uri'])
Ejemplo n.º 19
0
 def dependency_handler_class(self):
     """Return a dependency handler that will work for this distro."""
     return importer.import_entry_point(self._dependency_handler["name"])
Ejemplo n.º 20
0
def get_packager_class(package_info, default_packager_class=None):
    packager_name = package_info.get('packager_name') or ''
    packager_name = packager_name.strip()
    if not packager_name:
        return default_packager_class
    return importer.import_entry_point(packager_name)