def _create_nova_zone_neighbors(self, entity_event): zone_vertex_id = self._create_entity_key(entity_event) neighbors = [self._create_cluster_neighbor(zone_vertex_id)] hosts = extract_field_value(entity_event, 'hosts') host_transformer = self.transformers[NOVA_HOST_DATASOURCE] if host_transformer: for hostname, host_data in hosts.items(): host_available = extract_field_value(host_data, 'nova-compute', 'available') host_active = extract_field_value(host_data, 'nova-compute', 'active') host_state = self.STATE_AVAILABLE \ if host_available and host_active \ else self.STATE_UNAVAILABLE host_neighbor = self._create_host_neighbor( zone_vertex_id, hostname, host_state, entity_event[DSProps.SAMPLE_DATE]) neighbors.append(host_neighbor) else: LOG.warning('Cannot find host transformer') return neighbors
def _create_snapshot_entity_vertex(self, entity_event): name = extract_field_value(entity_event, 'name') entity_id = extract_field_value(entity_event, 'id') state = extract_field_value(entity_event, 'status') return self._create_vertex(entity_event, name, entity_id, state)
def _validate_host_neighbor(self, host_neighbor, zone_vertex_id, hosts, datasource_action): host_vertex = host_neighbor.vertex host_vertex_id = host_vertex.get(VProps.ID) host_dic = hosts[host_vertex_id] self.assertIsNotNone(hosts[host_vertex_id]) host_available = tbase.extract_field_value(host_dic, 'nova-compute', 'available') host_active = tbase.extract_field_value(host_dic, 'nova-compute', 'active') if host_available and host_active: expected_host_state = ZoneTransformer.STATE_AVAILABLE else: expected_host_state = ZoneTransformer.STATE_UNAVAILABLE self.assertEqual(expected_host_state, host_vertex.get(VProps.STATE)) vitrage_is_placeholder = host_vertex[VProps.VITRAGE_IS_PLACEHOLDER] self.assertFalse(vitrage_is_placeholder) vitrage_is_deleted = host_vertex[VProps.VITRAGE_IS_DELETED] self.assertFalse(vitrage_is_deleted) # Validate neighbor edge edge = host_neighbor.edge self.assertEqual(edge.target_id, host_neighbor.vertex.vertex_id) self.assertEqual(edge.source_id, zone_vertex_id) self.assertEqual(edge.label, EdgeLabel.CONTAINS)
def _create_update_entity_vertex(self, entity_event): name = extract_field_value(entity_event, 'hostname') entity_id = extract_field_value(entity_event, 'instance_id') state = extract_field_value(entity_event, 'state') return self._create_vertex(entity_event, name, entity_id, state)
def _create_snapshot_entity_vertex(self, entity_event): name = extract_field_value(entity_event, 'name') entity_id = extract_field_value(entity_event, 'id') state = extract_field_value(entity_event, 'status') return self._create_vertex(entity_event, name, entity_id, state)
def _validate_host_neighbor(self, host_neighbor, zone_vertex_id, hosts, datasource_action): host_vertex = host_neighbor.vertex host_vertex_id = host_vertex.get(VertexProperties.ID) host_dic = hosts[host_vertex_id] self.assertIsNotNone(hosts[host_vertex_id]) host_available = tbase.extract_field_value(host_dic, "nova-compute", "available") host_active = tbase.extract_field_value(host_dic, "nova-compute", "active") if host_available and host_active: expected_host_state = ZoneTransformer.STATE_AVAILABLE else: expected_host_state = ZoneTransformer.STATE_UNAVAILABLE self.assertEqual(expected_host_state, host_vertex.get(VertexProperties.STATE)) is_placeholder = host_vertex[VertexProperties.IS_PLACEHOLDER] self.assertFalse(is_placeholder) is_deleted = host_vertex[VertexProperties.IS_DELETED] self.assertFalse(is_deleted) # Validate neighbor edge edge = host_neighbor.edge self.assertEqual(edge.target_id, host_neighbor.vertex.vertex_id) self.assertEqual(edge.source_id, zone_vertex_id) self.assertEqual(edge.label, EdgeLabel.CONTAINS)
def _validate_volume_vertex_props(self, vertex, event): is_update_event = tbase.is_update_event(event) self.assertEqual(EntityCategory.RESOURCE, vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(event[DSProps.ENTITY_TYPE], vertex[VProps.VITRAGE_TYPE]) id_field_path = 'volume_id' if is_update_event else 'id' self.assertEqual(tbase.extract_field_value(event, id_field_path), vertex[VProps.ID]) self.assertEqual(event[DSProps.SAMPLE_DATE], vertex[VProps.VITRAGE_SAMPLE_TIMESTAMP]) name_field_path = 'display_name' self.assertEqual(tbase.extract_field_value(event, name_field_path), vertex[VProps.NAME]) state_field_path = 'status' self.assertEqual(tbase.extract_field_value(event, state_field_path), vertex[VProps.STATE]) size_field_path = 'size' self.assertEqual(tbase.extract_field_value(event, size_field_path), vertex[CinderProps.SIZE]) volume_type_field_path = 'volume_type' self.assertEqual( tbase.extract_field_value(event, volume_type_field_path), vertex[CinderProps.VOLUME_TYPE]) self.assertFalse(vertex[VProps.VITRAGE_IS_PLACEHOLDER]) self.assertFalse(vertex[VProps.VITRAGE_IS_DELETED])
def _create_update_entity_vertex(self, entity_event): name = extract_field_value(entity_event, 'hostname') entity_id = extract_field_value(entity_event, 'instance_id') state = extract_field_value(entity_event, 'state') return self._create_vertex(entity_event, name, entity_id, state)
def _create_update_entity_vertex(self, entity_event): name = extract_field_value(entity_event, "hostname") entity_id = extract_field_value(entity_event, "instance_id") state = extract_field_value(entity_event, "state") return self._create_vertex(entity_event, name, entity_id, state)
def _create_snapshot_entity_vertex(self, entity_event): name = extract_field_value(entity_event, "name") entity_id = extract_field_value(entity_event, "id") state = extract_field_value(entity_event, "status") return self._create_vertex(entity_event, name, entity_id, state)
def _create_vertex(self, entity_event, name, entity_id, state): project = extract_field_value(entity_event, 'tenant_id') metadata = { VProps.NAME: name, VProps.PROJECT_ID: project } sample_timestamp = entity_event[DSProps.SAMPLE_DATE] # TODO(Alexey): need to check here that only the UPDATE sync_mode will # update the UPDATE_TIMESTAMP property update_timestamp = self._format_update_timestamp( extract_field_value(entity_event, DSProps.SAMPLE_DATE), sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_id=entity_id, entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_nova_zone_neighbors(self, entity_event): zone_vertex_id = self._create_entity_key(entity_event) neighbors = [self._create_cluster_neighbor(zone_vertex_id)] hosts = extract_field_value(entity_event, 'hosts') host_transformer = self.transformers[NOVA_HOST_DATASOURCE] if host_transformer: for hostname, host_data in hosts.items(): host_available = extract_field_value(host_data, 'nova-compute', 'available') host_active = extract_field_value(host_data, 'nova-compute', 'active') host_state = self.STATE_AVAILABLE \ if host_available and host_active \ else self.STATE_UNAVAILABLE host_neighbor = self._create_host_neighbor( zone_vertex_id, hostname, host_state, entity_event[DSProps.SAMPLE_DATE]) neighbors.append(host_neighbor) else: LOG.warning('Cannot find host transformer') return neighbors
def _validate_volume_vertex_props(self, vertex, event): is_update_event = tbase.is_update_event(event) self.assertEqual(EntityCategory.RESOURCE, vertex[VProps.CATEGORY]) self.assertEqual(event[DSProps.SYNC_TYPE], vertex[VProps.TYPE]) id_field_path = 'volume_id' if is_update_event else 'id' self.assertEqual( tbase.extract_field_value(event, id_field_path), vertex[VProps.ID]) self.assertEqual(event[DSProps.SAMPLE_DATE], vertex[VProps.SAMPLE_TIMESTAMP]) name_field_path = 'display_name' self.assertEqual( tbase.extract_field_value(event, name_field_path), vertex[VProps.NAME]) state_field_path = 'status' self.assertEqual( tbase.extract_field_value(event, state_field_path), vertex[VProps.STATE]) self.assertFalse(vertex[VProps.IS_PLACEHOLDER]) self.assertFalse(vertex[VProps.IS_DELETED])
def _create_snapshot_entity_vertex(self, entity_event): name = extract_field_value(entity_event, 'name') entity_id = extract_field_value(entity_event, 'id') state = extract_field_value(entity_event, 'status') host = extract_field_value(entity_event, 'OS-EXT-SRV-ATTR:host') return self._create_vertex(entity_event, name, entity_id, state, host)
def _create_update_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'display_name') volume_id = extract_field_value(entity_event, 'volume_id') volume_state = extract_field_value(entity_event, 'status') timestamp = entity_event.get('updated_at', None) return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp)
def _create_snapshot_entity_vertex(self, entity_event): zone_name = extract_field_value(entity_event, 'zoneName') is_available = extract_field_value(entity_event, 'zoneState', 'available') state = self.STATE_AVAILABLE if is_available \ else self.STATE_UNAVAILABLE return self._create_vertex(entity_event, state, zone_name)
def _create_snapshot_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'display_name') volume_id = extract_field_value(entity_event, 'id') volume_state = extract_field_value(entity_event, 'status') timestamp = extract_field_value(entity_event, 'created_at') return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp)
def _create_snapshot_entity_vertex(self, entity_event): zone_name = extract_field_value(entity_event, ZoneProps.ZONE_NAME) is_available = extract_field_value(entity_event, ZoneProps.ZONE_STATE, 'available') state = self.STATE_AVAILABLE if is_available \ else self.STATE_UNAVAILABLE return self._create_vertex(entity_event, state, zone_name)
def _create_snapshot_entity_vertex(self, entity_event): stack_name = extract_field_value(entity_event, 'stack_name') stack_id = extract_field_value(entity_event, 'id') stack_state = extract_field_value(entity_event, 'stack_status') timestamp = extract_field_value(entity_event, 'creation_time') project_id = extract_field_value(entity_event, 'project') return self._create_vertex(entity_event, stack_name, stack_id, stack_state, timestamp, project_id)
def _create_snapshot_entity_vertex(self, entity_event): zone_name = extract_field_value(entity_event, 'zoneName') is_available = extract_field_value(entity_event, 'zoneState', 'available') state = self.STATE_AVAILABLE if is_available \ else self.STATE_UNAVAILABLE return self._create_vertex(entity_event, state, zone_name)
def _create_update_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'stack_name') volume_id = extract_field_value(entity_event, 'stack_identity') volume_state = extract_field_value(entity_event, 'state') timestamp = entity_event.get('create_at', None) project_id = entity_event.get('tenant_id', None) return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp, project_id)
def _create_snapshot_entity_vertex(self, entity_event): stack_name = extract_field_value(entity_event, StackProps.STACK_NAME) stack_id = extract_field_value(entity_event, StackProps.ID) stack_state = extract_field_value(entity_event, StackProps.STACK_STATUS) timestamp = extract_field_value(entity_event, StackProps.CREATION_TIME) project_id = extract_field_value(entity_event, StackProps.PROJECT) return self._create_vertex(entity_event, stack_name, stack_id, stack_state, timestamp, project_id)
def _create_update_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, StackProps.STACK_NAME) volume_id = extract_field_value(entity_event, StackProps.STACK_IDENTITY) volume_state = extract_field_value(entity_event, StackProps.STATE) timestamp = entity_event.get(StackProps.CREATED_AT, None) project_id = entity_event.get(StackProps.TENANT_ID, None) return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp, project_id)
def _create_snapshot_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'display_name') volume_id = extract_field_value(entity_event, 'id') volume_state = extract_field_value(entity_event, 'status') timestamp = extract_field_value(entity_event, 'created_at') return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp)
def _create_update_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'display_name') volume_id = extract_field_value(entity_event, 'volume_id') volume_state = extract_field_value(entity_event, 'status') timestamp = entity_event.get('updated_at', None) return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp)
def _create_update_entity_vertex(self, entity_event): event_type = entity_event[DSProps.EVENT_TYPE] name = extract_field_value(entity_event, 'network', 'name') state = extract_field_value(entity_event, 'network', 'status') update_timestamp = \ extract_field_value(entity_event, 'network', 'updated_at') entity_id = extract_field_value(entity_event, *self.UPDATE_ID_PROPERTY[event_type]) project_id = extract_field_value(entity_event, 'network', 'tenant_id') return self._create_vertex(entity_event, name, entity_id, state, update_timestamp, project_id)
def _get_event_type(self, snmp_trap): if not self.oid_mapping: LOG.warning('No snmp trap is configured!') return None for mapping_info in self.oid_mapping: system_oid = extract_field_value(mapping_info, SEProps.SYSTEM_OID) conf_system = extract_field_value(mapping_info, SEProps.SYSTEM) if conf_system == extract_field_value(snmp_trap, system_oid): LOG.debug('snmp trap mapped the system: %s.' % conf_system) return extract_field_value(mapping_info, SEProps.EVENT_TYPE) LOG.error("Snmp trap does not contain system info!") return None
def _create_snapshot_entity_vertex(self, entity_event): stack_name = extract_field_value(entity_event, 'stack_name') stack_id = extract_field_value(entity_event, 'id') stack_state = extract_field_value(entity_event, 'stack_status') timestamp = extract_field_value(entity_event, 'creation_time') project_id = extract_field_value(entity_event, 'project') return self._create_vertex(entity_event, stack_name, stack_id, stack_state, timestamp, project_id)
def _create_update_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'stack_name') volume_id = extract_field_value(entity_event, 'stack_identity') volume_state = extract_field_value(entity_event, 'state') timestamp = entity_event.get('create_at', None) project_id = entity_event.get('tenant_id', None) return self._create_vertex(entity_event, volume_name, volume_id, volume_state, timestamp, project_id)
def _create_vertex(self, entity_event, name, entity_id, state, host): metadata = { VProps.NAME: name, VProps.PROJECT_ID: entity_event.get('tenant_id', None), 'host_id': host } vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] # TODO(Alexey): need to check that only the UPDATE datasource_action # will update the UPDATE_TIMESTAMP property update_timestamp = self._format_update_timestamp( extract_field_value(entity_event, DSProps.SAMPLE_DATE), vitrage_sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, entity_state=state, update_timestamp=update_timestamp, metadata=metadata)
def _create_entity_key(self, event): instance_id = 'instance_id' if tbase.is_update_event(event) else 'id' key_fields = self._key_values(NOVA_INSTANCE_DATASOURCE, extract_field_value(event, instance_id)) return tbase.build_key(key_fields)
def _create_vertex(self, entity_event, name, entity_id, state, update_timestamp, project_id): event_type = entity_event.get(DSProps.EVENT_TYPE, None) ip_addresses = [] if not event_type: fixed_ips = extract_field_value( entity_event, *self.FIXED_IPS_PROPERTY[event_type]) ip_addresses = [ip['ip_address'] for ip in fixed_ips] metadata = { VProps.NAME: name, VProps.PROJECT_ID: project_id, 'ip_addresses': tuple(ip_addresses), } sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_id=entity_id, entity_category=EntityCategory.RESOURCE, entity_type=NEUTRON_PORT_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event, name, entity_id, state, update_timestamp, project_id): event_type = entity_event.get(DSProps.EVENT_TYPE, None) ip_addresses = [] if not event_type: fixed_ips = extract_field_value( entity_event, *self.FIXED_IPS_PROPERTY[event_type]) ip_addresses = [ip[PortProps.IP_ADDRESS] for ip in fixed_ips] metadata = { VProps.NAME: name, VProps.PROJECT_ID: project_id, PortProps.IP_ADDRESSES: tuple(ip_addresses), PortProps.HOST_ID: entity_event.get('binding:%s' % PortProps.HOST_ID), } vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.RESOURCE, vitrage_type=NEUTRON_PORT_DATASOURCE, vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, entity_state=state, update_timestamp=update_timestamp, metadata=metadata)
def _create_zone_neighbor(self, entity_event, sample_timestamp, host_vertex_id, zone_name_path): zone_transformer = self.transformers[NOVA_ZONE_DATASOURCE] if zone_transformer: zone_name = extract_field_value(entity_event, zone_name_path) properties = { VProps.ID: zone_name, VProps.TYPE: NOVA_ZONE_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } zone_neighbor = zone_transformer.create_placeholder_vertex( **properties) relation_edge = graph_utils.create_edge( source_id=zone_neighbor.vertex_id, target_id=host_vertex_id, relationship_type=EdgeLabel.CONTAINS) return Neighbor(zone_neighbor, relation_edge) else: LOG.warning('Cannot find zone transformer') return None
def _create_entity_key(self, entity_event): network_id = 'network_id' if tbase.is_update_event(entity_event) \ else 'id' key_fields = self._key_values( NEUTRON_NETWORK_DATASOURCE, extract_field_value(entity_event, network_id)) return tbase.build_key(key_fields)
def _create_entity_key(self, event): instance_id = 'instance_id' if tbase.is_update_event(event) else 'id' key_fields = self._key_values(NOVA_INSTANCE_DATASOURCE, extract_field_value(event, instance_id)) return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event): network_id = 'network_id' if tbase.is_update_event(entity_event) \ else 'id' key_fields = self._key_values(NEUTRON_NETWORK_DATASOURCE, extract_field_value(entity_event, network_id)) return tbase.build_key(key_fields)
def _validate_host_neighbor(self, h_neighbor, event): it = self.transformers[NOVA_INSTANCE_DATASOURCE] name = 'host' if tbase.is_update_event(event) \ else 'OS-EXT-SRV-ATTR:host' host_name = tbase.extract_field_value(event, name) time = event[DSProps.SAMPLE_DATE] ht = self.transformers[NOVA_HOST_DATASOURCE] properties = { VProps.ID: host_name, VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: time } expected_neighbor = \ ht.create_neighbor_placeholder_vertex(**properties) self.assertEqual(expected_neighbor, h_neighbor.vertex) # Validate neighbor edge edge = h_neighbor.edge entity_key = it._create_entity_key(event) entity_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(entity_key) self.assertEqual(edge.source_id, h_neighbor.vertex.vertex_id) self.assertEqual(edge.target_id, entity_uuid) self.assertEqual(edge.label, EdgeLabel.CONTAINS)
def _create_vertex(self, entity_event): field_extractor = self._get_field_extractor(entity_event) if not field_extractor: LOG.warning('Failed to identify event type for event: %s', entity_event) return metadata = { VProps.NAME: field_extractor.name(entity_event), VProps.PROJECT_ID: field_extractor.tenant_id(entity_event), 'host_id': field_extractor.host(entity_event) } instance_name = field_extractor.instance_name(entity_event) if instance_name: metadata['instance_name'] = instance_name vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] # TODO(Alexey): need to check that only the UPDATE datasource_action # will update the UPDATE_TIMESTAMP property update_timestamp = self._format_update_timestamp( extract_field_value(entity_event, DSProps.SAMPLE_DATE), vitrage_sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=field_extractor.entity_id(entity_event), entity_state=field_extractor.state(entity_event), update_timestamp=update_timestamp, metadata=metadata)
def _create_zone_neighbor(self, entity_event, sample_timestamp, host_vertex_id, zone_name_path): zone_transformer = self.transformers[NOVA_ZONE_DATASOURCE] if zone_transformer: zone_name = extract_field_value(entity_event, zone_name_path) properties = { VProps.ID: zone_name, VProps.TYPE: NOVA_ZONE_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } zone_neighbor = zone_transformer.create_placeholder_vertex( **properties) relation_edge = graph_utils.create_edge( source_id=zone_neighbor.vertex_id, target_id=host_vertex_id, relationship_type=EdgeLabel.CONTAINS) return Neighbor(zone_neighbor, relation_edge) else: LOG.warning('Cannot find zone transformer') return None
def _validate_zone_neighbor(self, zone, event): zone_name = tbase.extract_field_value(event, 'zone') time = event[DSProps.SAMPLE_DATE] zt = self.transformers[NOVA_ZONE_DATASOURCE] properties = { VProps.ID: zone_name, VProps.VITRAGE_TYPE: NOVA_ZONE_DATASOURCE, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: time } expected_neighbor = \ zt.create_neighbor_placeholder_vertex(**properties) self.assertEqual(expected_neighbor, zone.vertex) # Validate neighbor edge edge = zone.edge transformer = self.transformers[NOVA_HOST_DATASOURCE] entity_key = transformer._create_entity_key(event) entity_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(entity_key) self.assertEqual(edge.source_id, zone.vertex.vertex_id) self.assertEqual(edge.target_id, entity_uuid) self.assertEqual(edge.label, EdgeLabel.CONTAINS)
def test_create_entity_key(self): LOG.debug('Test get key from nova instance transformer') # Test setup spec_list = mock_sync.simple_instance_generators(host_num=1, vm_num=1, snapshot_events=1, update_events=0) instance_events = mock_sync.generate_random_events_list(spec_list) instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE] for event in instance_events: # Test action observed_key = instance_transformer._create_entity_key(event) # Test assertions observed_key_fields = observed_key.split( TransformerBase.KEY_SEPARATOR) self.assertEqual(EntityCategory.RESOURCE, observed_key_fields[0]) self.assertEqual(NOVA_INSTANCE_DATASOURCE, observed_key_fields[1]) instance_id = tbase.extract_field_value(event, 'id') self.assertEqual(instance_id, observed_key_fields[2]) key_values = instance_transformer._key_values( NOVA_INSTANCE_DATASOURCE, instance_id) expected_key = tbase.build_key(key_values) self.assertEqual(expected_key, observed_key)
def _create_entity_key(self, entity_event): event_type = entity_event.get(DSProps.EVENT_TYPE, None) network_id = extract_field_value(entity_event, *self.UPDATE_ID_PROPERTY[event_type]) key_fields = self._key_values(NEUTRON_NETWORK_DATASOURCE, network_id) return tbase.build_key(key_fields)
def _create_entity_key(self, entity_event): is_update_event = tbase.is_update_event(entity_event) id_field_path = 'volume_id' if is_update_event else 'id' volume_id = extract_field_value(entity_event, id_field_path) key_fields = self._key_values(CINDER_VOLUME_DATASOURCE, volume_id) return build_key(key_fields)
def _create_entity_key(self, entity_event): is_update_event = tbase.is_update_event(entity_event) id_field_path = 'stack_identity' if is_update_event else 'id' volume_id = extract_field_value(entity_event, id_field_path) key_fields = self._key_values(HEAT_STACK_DATASOURCE, volume_id) return build_key(key_fields)
def _create_host_neighbors(self, entity_event): zone_name = extract_field_value(entity_event, HostProps.ZONE) zone_neighbor = self._create_neighbor(entity_event, zone_name, NOVA_ZONE_DATASOURCE, EdgeLabel.CONTAINS, is_entity_source=False) return [zone_neighbor]
def _create_entity_key(self, entity_event): is_update_event = tbase.is_update_event(entity_event) id_field_path = 'volume_id' if is_update_event else 'id' volume_id = extract_field_value(entity_event, id_field_path) key_fields = self._key_values(CINDER_VOLUME_DATASOURCE, volume_id) return build_key(key_fields)
def _create_entity_key(self, entity_event): is_update_event = tbase.is_update_event(entity_event) id_field_path = 'stack_identity' if is_update_event else 'id' volume_id = extract_field_value(entity_event, id_field_path) key_fields = self._key_values(HEAT_STACK_DATASOURCE, volume_id) return build_key(key_fields)
def _create_update_entity_vertex(self, entity_event): event_type = entity_event[DSProps.EVENT_TYPE] name = extract_field_value(entity_event, 'network', 'name') state = extract_field_value(entity_event, 'network', 'status') update_timestamp = \ extract_field_value(entity_event, 'network', 'updated_at') entity_id = extract_field_value(entity_event, *self.UPDATE_ID_PROPERTY[event_type]) project_id = extract_field_value(entity_event, 'network', 'tenant_id') return self._create_vertex(entity_event, name, entity_id, state, update_timestamp, project_id)
def _create_update_entity_vertex(self, entity_event): event_type = entity_event[DSProps.EVENT_TYPE] name = extract_field_value(entity_event, NetworkProps.NETWORK, NetworkProps.NAME) state = extract_field_value(entity_event, NetworkProps.NETWORK, NetworkProps.STATUS) update_timestamp = \ extract_field_value(entity_event, NetworkProps.NETWORK, NetworkProps.UPDATED_AT) entity_id = extract_field_value(entity_event, *self.UPDATE_ID_PROPERTY[event_type]) project_id = extract_field_value(entity_event, NetworkProps.NETWORK, NetworkProps.TENANT_ID) return self._create_vertex(entity_event, name, entity_id, state, update_timestamp, project_id)
def _validate_neighbors(self, neighbors, zone_vertex_id, event): cluster_neighbors_counter = 0 for neighbor in neighbors: vertex_type = neighbor.vertex.get(VertexProperties.TYPE) if OPENSTACK_CLUSTER == vertex_type: cluster_neighbors_counter += 1 self._validate_cluster_neighbor(neighbor, zone_vertex_id) else: hosts = tbase.extract_field_value(event, "hosts") self._validate_host_neighbor(neighbor, zone_vertex_id, hosts, event[DSProps.DATASOURCE_ACTION]) self.assertEqual(1, cluster_neighbors_counter, "Zone can belongs to only one Cluster")
def _create_port_neighbors(self, entity_event, device_owner_property, device_id_property, network_id_property): neighbors = [self._create_network_neighbor(entity_event, network_id_property)] device_owner = \ extract_field_value(entity_event, *device_owner_property) if device_owner == 'compute:nova' or device_owner == 'compute:None': instance = self._create_instance_neighbor( entity_event, device_id_property) neighbors.append(instance) return neighbors
def _create_nova_instance_neighbors(self, entity_event): neighbors = [] host_transformer = self.transformers[NOVA_HOST_DATASOURCE] host_name = 'host' if tbase.is_update_event(entity_event) \ else 'OS-EXT-SRV-ATTR:host' if host_transformer: host_neighbor = self._create_host_neighbor( self._create_entity_key(entity_event), extract_field_value(entity_event, host_name), entity_event[DSProps.SAMPLE_DATE], host_transformer) neighbors.append(host_neighbor) else: LOG.warning('Cannot find host transformer') return neighbors
def _create_network_neighbor(self, entity_event, net_id_property): port_vitrage_id = self._create_entity_key(entity_event) net_id = extract_field_value(entity_event, *net_id_property) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] properties = { VProps.ID: net_id, VProps.TYPE: NEUTRON_NETWORK_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } net_vertex = self.create_placeholder_vertex(**properties) relationship_edge = graph_utils.create_edge( source_id=net_vertex.vertex_id, target_id=port_vitrage_id, relationship_type=EdgeLabel.CONTAINS) return Neighbor(net_vertex, relationship_edge)
def _validate_zone_neighbor(self, zone, event): zone_name = tbase.extract_field_value(event, 'zone') time = event[DSProps.SAMPLE_DATE] zt = self.transformers[NOVA_ZONE_DATASOURCE] properties = { VertexProperties.ID: zone_name, VertexProperties.TYPE: NOVA_ZONE_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: time } expected_neighbor = zt.create_placeholder_vertex(**properties) self.assertEqual(expected_neighbor, zone.vertex) # Validate neighbor edge edge = zone.edge self.assertEqual(edge.source_id, zone.vertex.vertex_id) self.assertEqual( edge.target_id, HostTransformer(self.transformers)._create_entity_key(event) ) self.assertEqual(edge.label, EdgeLabels.CONTAINS)
def _create_instance_neighbor(self, entity_event, instance_id_property): port_vitrage_id = self._create_entity_key(entity_event) instance_id = extract_field_value(entity_event, *instance_id_property) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] properties = { VProps.ID: instance_id, VProps.TYPE: NOVA_INSTANCE_DATASOURCE, VProps.SAMPLE_TIMESTAMP: sample_timestamp } instance_vertex = self.create_placeholder_vertex(**properties) relationship_edge = graph_utils.create_edge( source_id=port_vitrage_id, target_id=instance_vertex.vertex_id, relationship_type=EdgeLabel.ATTACHED) return Neighbor(instance_vertex, relationship_edge)
def _create_vertex(self, entity_event, name, entity_id, state): metadata = {VProps.NAME: name, VProps.PROJECT_ID: entity_event.get("tenant_id", None)} sample_timestamp = entity_event[DSProps.SAMPLE_DATE] # TODO(Alexey): need to check that only the UPDATE datasource_action # will update the UPDATE_TIMESTAMP property update_timestamp = self._format_update_timestamp( extract_field_value(entity_event, DSProps.SAMPLE_DATE), sample_timestamp ) return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_id=entity_id, entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, entity_state=state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata, )
def _create_snapshot_entity_vertex(self, entity_event): volume_name = extract_field_value(entity_event, 'display_name') volume_id = extract_field_value(entity_event, 'id') volume_state = extract_field_value(entity_event, 'status') project_id = entity_event.get('os-vol-tenant-attr:tenant_id', None) timestamp = extract_field_value(entity_event, 'created_at') size = extract_field_value(entity_event, 'size') volume_type = extract_field_value(entity_event, 'volume_type') attachments = extract_field_value(entity_event, 'attachments') return self._create_vertex(entity_event, volume_name, volume_id, volume_state, project_id, timestamp, size, volume_type, attachments, 'server_id')
def _validate_host_neighbor(self, h_neighbor, event): it = self.transformers[NOVA_INSTANCE_DATASOURCE] name = 'host' if tbase.is_update_event(event) \ else 'OS-EXT-SRV-ATTR:host' host_name = tbase.extract_field_value(event, name) time = event[DSProps.SAMPLE_DATE] ht = self.transformers[NOVA_HOST_DATASOURCE] properties = { VertexProperties.ID: host_name, VertexProperties.TYPE: NOVA_HOST_DATASOURCE, VertexProperties.SAMPLE_TIMESTAMP: time } expected_neighbor = ht.create_placeholder_vertex(**properties) self.assertEqual(expected_neighbor, h_neighbor.vertex) # Validate neighbor edge edge = h_neighbor.edge self.assertEqual(edge.source_id, h_neighbor.vertex.vertex_id) self.assertEqual(edge.target_id, it._create_entity_key(event)) self.assertEqual(edge.label, EdgeLabel.CONTAINS)