class StatusCommand(object): def __init__(self, client, provider, log): """ Callable status command object. `client`: ZK client connection `provider`: machine provider for the environment `log`: a Python stdlib logger. """ self.client = client self.provider = provider self.log = log self.service_manager = ServiceStateManager(client) self.relation_manager = RelationStateManager(client) self.machine_manager = MachineStateManager(client) self.charm_manager = CharmStateManager(client) self._reset() def _reset(self, scope=None): # init per-run state # self.state is assembled by the various process methods # intermediate access to state is made more convenient # using these references to its internals. self.service_data = {} # service name: service info self.machine_data = {} # machine id: machine state self.unit_data = {} # unit_name :unit_info # used in collecting subordinate (which are added to state in a two # phase pass) self.subordinates = {} # service : set(principal service names) self.state = dict(services=self.service_data, machines=self.machine_data) # Filtering info self.seen_machines = set() self.filter_services, self.filter_units = digest_scope(scope) @inlineCallbacks def __call__(self, scope=None): """Extract status information into nested dicts for rendering. `scope`: an optional list of name specifiers. Globbing based wildcards supported. Defaults to all units, services and relations. """ self._reset(scope) # Pass 1 Gather Data (including principals and subordinates) # this builds unit info and container relationships # which is assembled in pass 2 below yield self._process_services() # Pass 2: Nest information according to principal/subordinates # rules self._process_subordinates() yield self._process_machines() returnValue(self.state) @inlineCallbacks def _process_services(self): """ For each service gather the following information:: <service name>: charm: <charm name> exposed: <expose boolean> relations: <relation info -- see _process_relations> units: <unit info -- see _process_units> """ services = yield self.service_manager.get_all_service_states() for service in services: if len(self.filter_services): found = False for filter_service in self.filter_services: if fnmatch(service.service_name, filter_service): found = True break if not found: continue yield self._process_service(service) @inlineCallbacks def _process_service(self, service): """ Gather the service info (described in _process_services). `service`: ServiceState instance """ relation_data = {} service_data = self.service_data charm_id = yield service.get_charm_id() charm = yield self.charm_manager.get_charm_state(charm_id) service_data[service.service_name] = ( dict(units={}, charm=charm.id, relations=relation_data)) if (yield service.is_subordinate()): service_data[service.service_name]["subordinate"] = True yield self._process_expose(service) relations, rel_svc_map = yield self._process_relation_map( service) unit_matched = yield self._process_units(service, relations, rel_svc_map) # after filtering units check if any matched or remove the # service from the output if self.filter_units and not unit_matched: del service_data[service.service_name] return yield self._process_relations(service, relations, rel_svc_map) @inlineCallbacks def _process_units(self, service, relations, rel_svc_map): """ Gather unit information for a service:: <unit name>: agent-state: <started|pendding|etc> machine: <machine id> open-ports: ["port/protocol", ...] public-address: <public dns name or ip> subordinates: <optional nested units of subordinate services> `service`: ServiceState intance `relations`: list of ServiceRelationState instance for this service `rel_svc_map`: maps relation internal ids to the remote endpoint service name. This references the name of the remote endpoint and so is generated per service. """ units = yield service.get_all_unit_states() unit_matched = False for unit in units: if len(self.filter_units): found = False for filter_unit in self.filter_units: if fnmatch(unit.unit_name, filter_unit): found = True break if not found: continue yield self._process_unit(service, unit, relations, rel_svc_map) unit_matched = True returnValue(unit_matched) @inlineCallbacks def _process_unit(self, service, unit, relations, rel_svc_map): """ Generate unit info for a single unit of a single service. `unit`: ServiceUnitState see `_process_units` for an explanation of other arguments. """ u = self.unit_data[unit.unit_name] = dict() container = yield unit.get_container() if container: u["container"] = container.unit_name self.subordinates.setdefault(unit.service_name, set()).add(container.service_name) machine_id = yield unit.get_assigned_machine_id() u["machine"] = machine_id unit_workflow_client = WorkflowStateClient(self.client, unit) unit_state = yield unit_workflow_client.get_state() if not unit_state: u["agent-state"] = "pending" else: unit_connected = yield unit.has_agent() u["agent-state"] = unit_state.replace("_", "-") \ if unit_connected else "down" exposed = self.service_data[service.service_name].get("exposed") if exposed: open_ports = yield unit.get_open_ports() u["open-ports"] = ["{port}/{proto}".format(**port_info) for port_info in open_ports] u["public-address"] = yield unit.get_public_address() # indicate we should include information about this # machine later self.seen_machines.add(machine_id) # collect info on each relation for the service unit yield self._process_unit_relations(service, unit, relations, rel_svc_map) @inlineCallbacks def _process_relation_map(self, service): """Generate a mapping from a services relations to the service name of the remote endpoints. returns: ([ServiceRelationState, ...], mapping) """ relation_data = self.service_data[service.service_name]["relations"] relation_mgr = self.relation_manager relations = yield relation_mgr.get_relations_for_service(service) rel_svc_map = {} for relation in relations: rel_services = yield relation.get_service_states() # A single related service implies a peer relation. More # imply a bi-directional provides/requires relationship. # In the later case we omit the local side of the relation # when reporting. if len(rel_services) > 1: # Filter out self from multi-service relations. rel_services = [ rsn for rsn in rel_services if rsn.service_name != service.service_name] if len(rel_services) > 1: raise ValueError("Unexpected relationship with more " "than 2 endpoints") rel_service = rel_services[0] relation_data.setdefault(relation.relation_name, set()).add( rel_service.service_name) rel_svc_map[relation.internal_relation_id] = ( rel_service.service_name) returnValue((relations, rel_svc_map)) @inlineCallbacks def _process_relations(self, service, relations, rel_svc_map): """Generate relation information for a given service Each service with relations will have a relations dict nested under it with one or more relations described:: relations: <relation name>: - <remote service name> """ relation_data = self.service_data[service.service_name]["relations"] for relation in relations: rel_services = yield relation.get_service_states() # A single related service implies a peer relation. More # imply a bi-directional provides/requires relationship. # In the later case we omit the local side of the relation # when reporting. if len(rel_services) > 1: # Filter out self from multi-service relations. rel_services = [ rsn for rsn in rel_services if rsn.service_name != service.service_name] if len(rel_services) > 1: raise ValueError("Unexpected relationship with more " "than 2 endpoints") rel_service = rel_services[0] relation_data.setdefault( relation.relation_name, set()).add( rel_service.service_name) rel_svc_map[relation.internal_relation_id] = ( rel_service.service_name) # Normalize the sets back to lists for r in relation_data: relation_data[r] = sorted(relation_data[r]) @inlineCallbacks def _process_unit_relations(self, service, unit, relations, rel_svc_map): """Collect UnitRelationState information per relation and per unit. Includes information under each unit for its relations including its relation state and information about any possible errors. see `_process_relations` for argument information """ u = self.unit_data[unit.unit_name] relation_errors = {} for relation in relations: try: relation_unit = yield relation.get_unit_state(unit) except UnitRelationStateNotFound: # This exception will occur when relations are # established between services without service # units, and therefore never have any # corresponding service relation units. # UPDATE: common with subordinate services, and # some testing scenarios. continue relation_workflow_client = WorkflowStateClient( self.client, relation_unit) workflow_state = yield relation_workflow_client.get_state() rel_svc_name = rel_svc_map.get(relation.internal_relation_id) if rel_svc_name and workflow_state not in ("up", None): relation_errors.setdefault( relation.relation_name, set()).add(rel_svc_name) if relation_errors: # Normalize sets and store. u["relation-errors"] = dict( [(r, sorted(relation_errors[r])) for r in relation_errors]) def _process_subordinates(self): """Properly nest subordinate units under their principal service's unit nodes. Services and units are generated in one pass, then iterated by this method to structure the output data to reflect actual unit containment. Subordinate units will include the follow:: subordinate: true subordinate-to: - <principal service names> Principal services that have subordinates will include:: subordinates: <subordinate unit name>: agent-state: <agent state> """ service_data = self.service_data for unit_name, u in self.unit_data.iteritems(): container = u.get("container") if container: d = self.unit_data[container].setdefault("subordinates", {}) d[unit_name] = u # remove keys that don't appear in output or come from container for key in ("container", "machine", "public-address"): u.pop(key, None) else: service_name = parse_service_name(unit_name) service_data[service_name]["units"][unit_name] = u for sub_service, principal_services in self.subordinates.iteritems(): service_data[sub_service]["subordinate-to"] = sorted(principal_services) service_data[sub_service].pop("units", None) @inlineCallbacks def _process_expose(self, service): """Indicate if a service is exposed or not.""" exposed = yield service.get_exposed_flag() if exposed: self.service_data[service.service_name].update(exposed=exposed) returnValue(exposed) @inlineCallbacks def _process_machines(self): """Gather machine information. machines: <machine id>: agent-state: <agent state> dns-name: <dns name> instance-id: <provider specific instance id> instance-state: <instance state> """ machines = yield self.machine_manager.get_all_machine_states() for machine_state in machines: if (self.filter_services or self.filter_units) and \ machine_state.id not in self.seen_machines: continue yield self._process_machine(machine_state) @inlineCallbacks def _process_machine(self, machine_state): """ `machine_state`: MachineState instance """ instance_id = yield machine_state.get_instance_id() m = {"instance-id": instance_id \ if instance_id is not None else "pending"} if instance_id is not None: try: pm = yield self.provider.get_machine(instance_id) m["dns-name"] = pm.dns_name m["instance-state"] = pm.state if (yield machine_state.has_agent()): # if the agent's connected, we're fine m["agent-state"] = "running" else: units = ( yield machine_state.get_all_service_unit_states()) for unit in units: unit_workflow_client = WorkflowStateClient( self.client, unit) if (yield unit_workflow_client.get_state()): # for unit to have a state, its agent must # have run, which implies the machine agent # must have been running correctly at some # point in the past m["agent-state"] = "down" break else: # otherwise we're probably just still waiting m["agent-state"] = "not-started" except ProviderError: # The provider doesn't have machine information self.log.error( "Machine provider information missing: machine %s" % ( machine_state.id)) self.machine_data[machine_state.id] = m
def collect(scope, machine_provider, client, log): """Extract status information into nested dicts for rendering. `scope`: an optional list of name specifiers. Globbing based wildcards supported. Defaults to all units, services and relations. `machine_provider`: machine provider for the environment `client`: ZK client connection `log`: a Python stdlib logger. """ service_manager = ServiceStateManager(client) relation_manager = RelationStateManager(client) machine_manager = MachineStateManager(client) charm_manager = CharmStateManager(client) service_data = {} machine_data = {} state = dict(services=service_data, machines=machine_data) seen_machines = set() filter_services, filter_units = digest_scope(scope) services = yield service_manager.get_all_service_states() for service in services: if len(filter_services): found = False for filter_service in filter_services: if fnmatch(service.service_name, filter_service): found = True break if not found: continue unit_data = {} relation_data = {} charm_id = yield service.get_charm_id() charm = yield charm_manager.get_charm_state(charm_id) service_data[service.service_name] = dict(units=unit_data, charm=charm.id, relations=relation_data) exposed = yield service.get_exposed_flag() if exposed: service_data[service.service_name].update(exposed=exposed) units = yield service.get_all_unit_states() unit_matched = False relations = yield relation_manager.get_relations_for_service(service) for unit in units: if len(filter_units): found = False for filter_unit in filter_units: if fnmatch(unit.unit_name, filter_unit): found = True break if not found: continue u = unit_data[unit.unit_name] = dict() machine_id = yield unit.get_assigned_machine_id() u["machine"] = machine_id unit_workflow_client = WorkflowStateClient(client, unit) unit_state = yield unit_workflow_client.get_state() if not unit_state: u["state"] = "pending" else: unit_connected = yield unit.has_agent() u["state"] = unit_state if unit_connected else "down" if exposed: open_ports = yield unit.get_open_ports() u["open-ports"] = ["{port}/{proto}".format(**port_info) for port_info in open_ports] u["public-address"] = yield unit.get_public_address() # indicate we should include information about this # machine later seen_machines.add(machine_id) unit_matched = True # collect info on each relation for the service unit relation_status = {} for relation in relations: try: relation_unit = yield relation.get_unit_state(unit) except UnitRelationStateNotFound: # This exception will occur when relations are # established between services without service # units, and therefore never have any # corresponding service relation units. This # scenario does not occur in actual deployments, # but can happen in test circumstances. In # particular, it will happen with a misconfigured # provider, which exercises this codepath. continue # should not occur, but status should not fail relation_workflow_client = WorkflowStateClient( client, relation_unit) relation_workflow_state = \ yield relation_workflow_client.get_state() relation_status[relation.relation_name] = dict( state=relation_workflow_state) u["relations"] = relation_status # after filtering units check if any matched or remove the # service from the output if filter_units and not unit_matched: del service_data[service.service_name] continue for relation in relations: rel_services = yield relation.get_service_states() # A single related service implies a peer relation. More # imply a bi-directional provides/requires relationship. # In the later case we omit the local side of the relation # when reporting. if len(rel_services) > 1: # Filter out self from multi-service relations. rel_services = [ rsn for rsn in rel_services if rsn.service_name != service.service_name] if len(rel_services) > 1: raise ValueError("Unexpected relationship with more " "than 2 endpoints") rel_service = rel_services[0] relation_data[relation.relation_name] = rel_service.service_name machines = yield machine_manager.get_all_machine_states() for machine_state in machines: if (filter_services or filter_units) and \ machine_state.id not in seen_machines: continue instance_id = yield machine_state.get_instance_id() m = {"instance-id": instance_id \ if instance_id is not None else "pending"} if instance_id is not None: try: pm = yield machine_provider.get_machine(instance_id) m["dns-name"] = pm.dns_name m["instance-state"] = pm.state if (yield machine_state.has_agent()): # if the agent's connected, we're fine m["state"] = "running" else: units = (yield machine_state.get_all_service_unit_states()) for unit in units: unit_workflow_client = WorkflowStateClient(client, unit) if (yield unit_workflow_client.get_state()): # for unit to have a state, its agent must have # run, which implies the machine agent must have # been running correctly at some point in the past m["state"] = "down" break else: # otherwise we're probably just still waiting m["state"] = "not-started" except ProviderError: # The provider doesn't have machine information log.error( "Machine provider information missing: machine %s" % ( machine_state.id)) machine_data[machine_state.id] = m returnValue(state)
def collect(scope, machine_provider, client, log): """Extract status information into nested dicts for rendering. `scope`: an optional list of name specifiers. Globbing based wildcards supported. Defaults to all units, services and relations. `machine_provider`: machine provider for the environment `client`: ZK client connection `log`: a Python stdlib logger. """ service_manager = ServiceStateManager(client) relation_manager = RelationStateManager(client) machine_manager = MachineStateManager(client) charm_manager = CharmStateManager(client) service_data = {} machine_data = {} state = dict(services=service_data, machines=machine_data) seen_machines = set() filter_services, filter_units = digest_scope(scope) services = yield service_manager.get_all_service_states() for service in services: if len(filter_services): found = False for filter_service in filter_services: if fnmatch(service.service_name, filter_service): found = True break if not found: continue unit_data = {} relation_data = {} charm_id = yield service.get_charm_id() charm = yield charm_manager.get_charm_state(charm_id) service_data[service.service_name] = dict(units=unit_data, charm=charm.id, relations=relation_data) exposed = yield service.get_exposed_flag() if exposed: service_data[service.service_name].update(exposed=exposed) units = yield service.get_all_unit_states() unit_matched = False relations = yield relation_manager.get_relations_for_service(service) for unit in units: if len(filter_units): found = False for filter_unit in filter_units: if fnmatch(unit.unit_name, filter_unit): found = True break if not found: continue u = unit_data[unit.unit_name] = dict() machine_id = yield unit.get_assigned_machine_id() u["machine"] = machine_id unit_workflow_client = WorkflowStateClient(client, unit) unit_state = yield unit_workflow_client.get_state() if not unit_state: u["state"] = "pending" else: unit_connected = yield unit.has_agent() u["state"] = unit_state if unit_connected else "down" if exposed: open_ports = yield unit.get_open_ports() u["open-ports"] = [ "{port}/{proto}".format(**port_info) for port_info in open_ports ] u["public-address"] = yield unit.get_public_address() # indicate we should include information about this # machine later seen_machines.add(machine_id) unit_matched = True # collect info on each relation for the service unit relation_status = {} for relation in relations: try: relation_unit = yield relation.get_unit_state(unit) except UnitRelationStateNotFound: # This exception will occur when relations are # established between services without service # units, and therefore never have any # corresponding service relation units. This # scenario does not occur in actual deployments, # but can happen in test circumstances. In # particular, it will happen with a misconfigured # provider, which exercises this codepath. continue # should not occur, but status should not fail relation_workflow_client = WorkflowStateClient( client, relation_unit) relation_workflow_state = \ yield relation_workflow_client.get_state() relation_status[relation.relation_name] = dict( state=relation_workflow_state) u["relations"] = relation_status # after filtering units check if any matched or remove the # service from the output if filter_units and not unit_matched: del service_data[service.service_name] continue for relation in relations: rel_services = yield relation.get_service_states() # A single related service implies a peer relation. More # imply a bi-directional provides/requires relationship. # In the later case we omit the local side of the relation # when reporting. if len(rel_services) > 1: # Filter out self from multi-service relations. rel_services = [ rsn for rsn in rel_services if rsn.service_name != service.service_name ] if len(rel_services) > 1: raise ValueError("Unexpected relationship with more " "than 2 endpoints") rel_service = rel_services[0] relation_data[relation.relation_name] = rel_service.service_name machines = yield machine_manager.get_all_machine_states() for machine_state in machines: if (filter_services or filter_units) and \ machine_state.id not in seen_machines: continue instance_id = yield machine_state.get_instance_id() m = {"instance-id": instance_id \ if instance_id is not None else "pending"} if instance_id is not None: try: pm = yield machine_provider.get_machine(instance_id) m["dns-name"] = pm.dns_name m["instance-state"] = pm.state if (yield machine_state.has_agent()): # if the agent's connected, we're fine m["state"] = "running" else: units = (yield machine_state.get_all_service_unit_states()) for unit in units: unit_workflow_client = WorkflowStateClient( client, unit) if (yield unit_workflow_client.get_state()): # for unit to have a state, its agent must have # run, which implies the machine agent must have # been running correctly at some point in the past m["state"] = "down" break else: # otherwise we're probably just still waiting m["state"] = "not-started" except ProviderError: # The provider doesn't have machine information log.error("Machine provider information missing: machine %s" % (machine_state.id)) machine_data[machine_state.id] = m returnValue(state)