Ejemplo n.º 1
0
 def _construct_siblings(self, name, siblings, base_params,
                         sibling_instances):
     # First setup the sibling instance action references
     for (action, _entry_point) in siblings.items():
         if action not in sibling_instances:
             sibling_instances[action] = {}
     there_siblings = {}
     for (action, entry_point) in siblings.items():
         sibling_params = utils.merge_dicts(base_params,
                                            self.cli_opts,
                                            preserve=True)
         # Give the sibling the reference to all other siblings being created
         # which will be populated when they are created (now or later) for
         # the same action
         sibling_params['instances'] = sibling_instances[action]
         a_sibling = importer.construct_entry_point(entry_point,
                                                    **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
         # Update all siblings being constructed so that there siblings will
         # be correct when fetched...
         sibling_instances[action][name] = a_sibling
     return there_siblings
Ejemplo n.º 2
0
    def start(self):
        # Perform a check just to make sure said programs aren't already started and bail out
        # so that it we don't unintentionally start new ones and thus causing confusion for all
        # involved...
        what_may_already_be_started = []
        try:
            what_may_already_be_started = self.tracereader.apps_started()
        except excp.NoTraceException:
            pass
        if what_may_already_be_started:
            msg = "%s programs of component %s may already be running, did you forget to stop those?"
            raise excp.StartException(
                msg % (len(what_may_already_be_started), self.name))

        # Select how we are going to start it and get on with the show...
        runner_entry_point = self.get_option("run_type",
                                             default_value=DEFAULT_RUNNER)
        starter_args = [self, runner_entry_point]
        starter = importer.construct_entry_point(runner_entry_point,
                                                 *starter_args)
        amount_started = 0
        for program in self.applications:
            self._start_app(program, starter)
            amount_started += 1
        return amount_started
Ejemplo n.º 3
0
 def _construct_instances(self, persona):
     """
     Create component objects for each component in the persona.
     """
     persona_subsystems = persona.wanted_subsystems or {}
     persona_opts = persona.component_options or {}
     wanted_components = persona.wanted_components or []
     # All siblings for the current persona
     instances = {}
     # Keeps track of all sibling instances across all components + actions
     # so that each instance or sibling instance will be connected to the
     # right set of siblings....
     sibling_instances = {}
     for c in wanted_components:
         d_component = self.distro.extract_component(c, self.lookup_name)
         LOG.debug("Constructing component %r (%s)", c,
                   d_component.entry_point)
         d_subsystems = d_component.options.pop('subsystems', {})
         sibling_params = {}
         sibling_params['name'] = c
         # First create its siblings with a 'minimal' set of options
         # This is done, so that they will work in a minimal state, they do not
         # get access to the persona options since those are action specific (or could be),
         # if this is not useful, we can give them full access, unsure if its worse or better...
         active_subsystems = self._merge_subsystems(
             distro_subsystems=d_subsystems,
             desired_subsystems=persona_subsystems.get(c, []))
         sibling_params['subsystems'] = active_subsystems
         sibling_params['siblings'] = {
         }  # This gets adjusted during construction
         sibling_params['passwords'] = self.passwords
         sibling_params['distro'] = self.distro
         sibling_params['options'] = self._merge_options(
             c,
             component_opts=self._get_interpolated_options(c),
             distro_opts=d_component.options,
             persona_opts={})
         LOG.debug("Constructing %r %s siblings...", c,
                   len(d_component.siblings))
         my_siblings = self._construct_siblings(c, d_component.siblings,
                                                sibling_params,
                                                sibling_instances)
         # Now inject the full options and create the target instance
         # with the full set of options and not the restricted set that
         # siblings get...
         instance_params = dict(sibling_params)
         instance_params['instances'] = instances
         instance_params['options'] = self._merge_options(
             c,
             component_opts=self._get_interpolated_options(c),
             distro_opts=d_component.options,
             persona_opts=persona_opts.get(c, {}))
         instance_params['siblings'] = my_siblings
         instance_params = utils.merge_dicts(instance_params,
                                             self.cli_opts,
                                             preserve=True)
         instances[c] = importer.construct_entry_point(
             d_component.entry_point, **instance_params)
     return instances
Ejemplo n.º 4
0
 def start(self):
     # Select how we are going to start it
     run_type = self.get_option("run_type", default_value='anvil.runners.fork:ForkRunner')
     starter = importer.construct_entry_point(run_type, self)
     am_started = 0
     for app_info in self.apps_to_start:
         self._start_app(app_info, run_type, starter)
         self._post_app_start(app_info)
         am_started += 1
     return am_started
Ejemplo n.º 5
0
 def start(self):
     # Select how we are going to start it
     run_type = self.get_option("run_type", default_value='anvil.runners.fork:ForkRunner')
     starter = importer.construct_entry_point(run_type, self)
     am_started = 0
     for app_info in self.apps_to_start:
         self._start_app(app_info, run_type, starter)
         self._post_app_start(app_info)
         am_started += 1
     return am_started
Ejemplo n.º 6
0
 def _construct_instances(self, persona):
     """
     Create component objects for each component in the persona.
     """
     persona_subsystems = persona.wanted_subsystems or {}
     persona_opts = persona.component_options or {}
     wanted_components = persona.wanted_components or []
     # All siblings for the current persona
     instances = {}
     # Keeps track of all sibling instances across all components + actions
     # so that each instance or sibling instance will be connected to the
     # right set of siblings....
     sibling_instances = {}
     for c in wanted_components:
         d_component = self.distro.extract_component(c, self.lookup_name)
         LOG.debug("Constructing component %r (%s)", c, d_component.entry_point)
         d_subsystems = d_component.options.pop("subsystems", {})
         sibling_params = {}
         sibling_params["name"] = c
         # First create its siblings with a 'minimal' set of options
         # This is done, so that they will work in a minimal state, they do not
         # get access to the persona options since those are action specific (or could be),
         # if this is not useful, we can give them full access, unsure if its worse or better...
         active_subsystems = self._merge_subsystems(
             distro_subsystems=d_subsystems, desired_subsystems=persona_subsystems.get(c, [])
         )
         sibling_params["subsystems"] = active_subsystems
         sibling_params["siblings"] = {}  # This gets adjusted during construction
         sibling_params["passwords"] = self.passwords
         sibling_params["distro"] = self.distro
         sibling_params["options"] = self._merge_options(
             c, component_opts=self._get_interpolated_options(c), distro_opts=d_component.options, persona_opts={}
         )
         LOG.debug("Constructing %r %s siblings...", c, len(d_component.siblings))
         my_siblings = self._construct_siblings(c, d_component.siblings, sibling_params, sibling_instances)
         # Now inject the full options and create the target instance
         # with the full set of options and not the restricted set that
         # siblings get...
         instance_params = dict(sibling_params)
         instance_params["instances"] = instances
         instance_params["options"] = self._merge_options(
             c,
             component_opts=self._get_interpolated_options(c),
             distro_opts=d_component.options,
             persona_opts=persona_opts.get(c, {}),
         )
         instance_params["siblings"] = my_siblings
         instance_params = utils.merge_dicts(instance_params, self.cli_opts, preserve=True)
         instances[c] = importer.construct_entry_point(d_component.entry_point, **instance_params)
     return instances
Ejemplo n.º 7
0
Archivo: base.py Proyecto: jzako/anvil
 def _construct_instances(self, persona):
     """Create component objects for each component in the persona."""
     # Keeps track of all sibling instances across all components + actions
     # so that each instance or sibling instance will be connected to the
     # right set of siblings....
     sibling_instances = {}
     components_created = set()
     groups = []
     for group in persona.matched_components:
         instances = utils.OrderedDict()
         for c in group:
             if c in components_created:
                 raise RuntimeError("Can not duplicate component %s in a"
                                    " later group %s" % (c, group.id))
             d_component = self.distro.extract_component(
                 c, self.lookup_name, default_entry_point_creator=self._make_default_entry_points)
             LOG.debug("Constructing component %r (%s)", c, d_component.entry_point)
             d_subsystems = d_component.options.pop('subsystems', {})
             sibling_params = {}
             sibling_params['name'] = c
             # First create its siblings with a 'minimal' set of options
             # This is done, so that they will work in a minimal state, they do not
             # get access to the persona options since those are action specific (or could be),
             # if this is not useful, we can give them full access, unsure if its worse or better...
             active_subsystems = self._merge_subsystems(distro_subsystems=d_subsystems,
                                                        desired_subsystems=persona.wanted_subsystems.get(c, []))
             sibling_params['subsystems'] = active_subsystems
             sibling_params['siblings'] = {}  # This gets adjusted during construction
             sibling_params['distro'] = self.distro
             sibling_params['options'] = self.config_loader.load(
                 distro=d_component, component=c,
                 origins_patch=self.cli_opts.get('origins_patch'))
             LOG.debug("Constructing %r %s siblings...", c, len(d_component.siblings))
             my_siblings = self._construct_siblings(c, d_component.siblings, sibling_params, sibling_instances)
             # Now inject the full options and create the target instance
             # with the full set of options and not the restricted set that
             # siblings get...
             instance_params = dict(sibling_params)
             instance_params['instances'] = instances
             instance_params['options'] = self.config_loader.load(
                 distro=d_component, component=c, persona=persona,
                 origins_patch=self.cli_opts.get('origins_patch'))
             instance_params['siblings'] = my_siblings
             instance_params = utils.merge_dicts(instance_params, self.cli_opts, preserve=True)
             instances[c] = importer.construct_entry_point(d_component.entry_point, **instance_params)
             if c not in SPECIAL_GROUPS:
                 components_created.add(c)
         groups.append((group.id, instances))
     return groups
Ejemplo n.º 8
0
 def _locate_investigators(self, apps_started):
     investigator_created = {}
     to_investigate = []
     for (app_name, _trace_fn, run_type) in apps_started:
         investigator = investigator_created.get(run_type)
         if investigator is None:
             try:
                 investigator = importer.construct_entry_point(run_type, self)
                 investigator_created[run_type] = investigator
             except RuntimeError as e:
                 LOG.warn("Could not load class %s which should be used to investigate %s: %s",
                          colorizer.quote(run_type), colorizer.quote(app_name), e)
                 continue
         to_investigate.append((app_name, investigator))
     return to_investigate
Ejemplo n.º 9
0
 def _locate_investigators(self, apps_started):
     investigator_created = {}
     to_investigate = []
     for (app_name, _trace_fn, run_type) in apps_started:
         investigator = investigator_created.get(run_type)
         if investigator is None:
             try:
                 investigator = importer.construct_entry_point(run_type, self)
                 investigator_created[run_type] = investigator
             except RuntimeError as e:
                 LOG.warn("Could not load class %s which should be used to investigate %s: %s",
                          colorizer.quote(run_type), colorizer.quote(app_name), e)
                 continue
         to_investigate.append((app_name, investigator))
     return to_investigate
Ejemplo n.º 10
0
 def _locate_investigators(self, applications_started):
     # Recreate the runners that can be used to dive deeper into the applications list
     # that was started (a 3 tuple of (name, trace, who_started)).
     investigators_created = {}
     to_investigate = []
     for (name, _trace, who_started) in applications_started:
         investigator = investigators_created.get(who_started)
         if investigator is None:
             try:
                 investigator_args = [self, who_started]
                 investigator = importer.construct_entry_point(who_started, *investigator_args)
                 investigators_created[who_started] = investigator
             except RuntimeError as e:
                 LOG.warn("Could not load class %s which should be used to investigate %s: %s",
                          colorizer.quote(who_started), colorizer.quote(name), e)
                 continue
         to_investigate.append((name, investigator))
     return to_investigate
Ejemplo n.º 11
0
 def _locate_investigators(self, applications_started):
     # Recreate the runners that can be used to dive deeper into the applications list
     # that was started (a 3 tuple of (name, trace, who_started)).
     investigators_created = {}
     to_investigate = []
     for (name, _trace, who_started) in applications_started:
         investigator = investigators_created.get(who_started)
         if investigator is None:
             try:
                 investigator_args = [self, who_started]
                 investigator = importer.construct_entry_point(
                     who_started, *investigator_args)
                 investigators_created[who_started] = investigator
             except RuntimeError as e:
                 LOG.warn(
                     "Could not load class %s which should be used to investigate %s: %s",
                     colorizer.quote(who_started), colorizer.quote(name), e)
                 continue
         to_investigate.append((name, investigator))
     return to_investigate
def replace_services_endpoints(token, options):
    client = importer.construct_entry_point(
        "keystoneclient.v2_0.client:Client",
        token=token,
        endpoint=options.keystone_uri)
    current_endpoints = client.endpoints.list()
    current_services = client.services.list()

    def filter_resource(r):
        raw = dict(r.__dict__)  # Can't access the raw attrs, arg...
        raw_cleaned = {}
        for k, v in raw.items():
            if k == 'manager' or k.startswith('_'):
                continue
            raw_cleaned[k] = v
        return raw_cleaned

    for e in current_endpoints:
        print("Deleting endpoint: ")
        print(utils.prettify_yaml(filter_resource(e)))
        client.endpoints.delete(e.id)

    for s in current_services:
        print("Deleting service: ")
        print(utils.prettify_yaml(filter_resource(s)))
        client.services.delete(s.id)

    if options.file:
        with (open(options.file, 'r')) as fh:
            contents = yaml.load(fh)
        set_contents = {
            'services': contents.get('services', []),
            'endpoints': contents.get('endpoints', []),
        }
        print("Regenerating with:")
        print(utils.prettify_yaml(set_contents))
        set_contents['users'] = []
        set_contents['roles'] = []
        set_contents['tenants'] = []
        initer = keystone.Initializer(token, options.keystone_uri)
        initer.initialize(**set_contents)
Ejemplo n.º 13
0
 def _construct_siblings(self, name, siblings, base_params, sibling_instances):
     # First setup the sibling instance action references
     for (action, _entry_point) in siblings.items():
         if action not in sibling_instances:
             sibling_instances[action] = {}
     there_siblings = {}
     for (action, entry_point) in siblings.items():
         sibling_params = utils.merge_dicts(base_params, self.cli_opts, preserve=True)
         # Give the sibling the reference to all other siblings being created
         # which will be populated when they are created (now or later) for
         # the same action
         sibling_params['instances'] = sibling_instances[action]
         a_sibling = importer.construct_entry_point(entry_point, **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
         # Update all siblings being constructed so that there siblings will
         # be correct when fetched...
         sibling_instances[action][name] = a_sibling
     return there_siblings
Ejemplo n.º 14
0
    def start(self):
        # Perform a check just to make sure said programs aren't already started and bail out
        # so that it we don't unintentionally start new ones and thus causing confusion for all
        # involved...
        what_may_already_be_started = []
        try:
            what_may_already_be_started = self.tracereader.apps_started()
        except excp.NoTraceException:
            pass
        if what_may_already_be_started:
            msg = "%s programs of component %s may already be running, did you forget to stop those?"
            raise excp.StartException(msg % (len(what_may_already_be_started), self.name))

        # Select how we are going to start it and get on with the show...
        runner_entry_point = self.get_option("run_type", default_value=DEFAULT_RUNNER)
        starter_args = [self, runner_entry_point]
        starter = importer.construct_entry_point(runner_entry_point, *starter_args)
        amount_started = 0
        for program in self.applications:
            self._start_app(program, starter)
            amount_started += 1
        return amount_started
Ejemplo n.º 15
0
def replace_services_endpoints(token, options):
    client = importer.construct_entry_point("keystoneclient.v2_0.client:Client",
                                             token=token, endpoint=options.keystone_uri)
    current_endpoints = client.endpoints.list()
    current_services = client.services.list()

    def filter_resource(r):
        raw = dict(r.__dict__) # Can't access the raw attrs, arg...
        raw_cleaned = {}
        for k, v in raw.items():
            if k == 'manager' or k.startswith('_'):
                continue
            raw_cleaned[k] = v
        return raw_cleaned

    for e in current_endpoints:
        print("Deleting endpoint: ")
        print(utils.prettify_yaml(filter_resource(e)))
        client.endpoints.delete(e.id)

    for s in current_services:
        print("Deleting service: ")
        print(utils.prettify_yaml(filter_resource(s)))
        client.services.delete(s.id)

    if options.file:
        with(open(options.file, 'r')) as fh:
            contents = yaml.load(fh)
        set_contents = {
            'services': contents.get('services', []),
            'endpoints': contents.get('endpoints', []),
        }
        print("Regenerating with:")
        print(utils.prettify_yaml(set_contents))
        set_contents['users'] = []
        set_contents['roles'] = []
        set_contents['tenants'] = []
        initer = keystone.Initializer(token, options.keystone_uri)
        initer.initialize(**set_contents)
Ejemplo n.º 16
0
 def __init__(self, service_token, admin_uri):
     # Late load since its using a client lib that is only avail after install...
     self.client = importer.construct_entry_point("keystoneclient.v2_0.client:Client",
                                                 token=service_token, endpoint=admin_uri)
Ejemplo n.º 17
0
 def _construct_instances(self, persona):
     """Create component objects for each component in the persona."""
     # Keeps track of all sibling instances across all components + actions
     # so that each instance or sibling instance will be connected to the
     # right set of siblings....
     sibling_instances = {}
     components_created = set()
     groups = []
     for group in persona.matched_components:
         instances = utils.OrderedDict()
         for c in group:
             if c in components_created:
                 raise RuntimeError("Can not duplicate component %s in a"
                                    " later group %s" % (c, group.id))
             d_component = self.distro.extract_component(
                 c,
                 self.lookup_name,
                 default_entry_point_creator=self._make_default_entry_points
             )
             LOG.debug("Constructing component %r (%s)", c,
                       d_component.entry_point)
             d_subsystems = d_component.options.pop('subsystems', {})
             sibling_params = {}
             sibling_params['name'] = c
             # First create its siblings with a 'minimal' set of options
             # This is done, so that they will work in a minimal state, they do not
             # get access to the persona options since those are action specific (or could be),
             # if this is not useful, we can give them full access, unsure if its worse or better...
             active_subsystems = self._merge_subsystems(
                 distro_subsystems=d_subsystems,
                 desired_subsystems=persona.wanted_subsystems.get(c, []))
             sibling_params['subsystems'] = active_subsystems
             sibling_params['siblings'] = {
             }  # This gets adjusted during construction
             sibling_params['distro'] = self.distro
             sibling_params['options'] = self.config_loader.load(
                 distro=d_component,
                 component=c,
                 origins_patch=self.cli_opts.get('origins_patch'))
             LOG.debug("Constructing %r %s siblings...", c,
                       len(d_component.siblings))
             my_siblings = self._construct_siblings(c, d_component.siblings,
                                                    sibling_params,
                                                    sibling_instances)
             # Now inject the full options and create the target instance
             # with the full set of options and not the restricted set that
             # siblings get...
             instance_params = dict(sibling_params)
             instance_params['instances'] = instances
             instance_params['options'] = self.config_loader.load(
                 distro=d_component,
                 component=c,
                 persona=persona,
                 origins_patch=self.cli_opts.get('origins_patch'))
             instance_params['siblings'] = my_siblings
             instance_params = utils.merge_dicts(instance_params,
                                                 self.cli_opts,
                                                 preserve=True)
             instances[c] = importer.construct_entry_point(
                 d_component.entry_point, **instance_params)
             if c not in SPECIAL_GROUPS:
                 components_created.add(c)
         groups.append((group.id, instances))
     return groups
Ejemplo n.º 18
0
 def __init__(self, service_token, admin_uri):
     # Late load since its using a client lib that is only avail after install...
     self.client = importer.construct_entry_point(
         "keystoneclient.v2_0.client:Client",
         token=service_token,
         endpoint=admin_uri)