def _validate_host_neighbor(self, neighbor, event): host_vertex = neighbor.vertex observed_key = host_vertex.vertex_id expected_key = tbase.build_key( (EntityCategory.RESOURCE, NOVA_HOST_DATASOURCE, event[ZabbixProps.RESOURCE_NAME])) expected_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(expected_key) self.assertEqual(expected_uuid, observed_key) self.assertEqual(expected_uuid, host_vertex.properties.get(VProps.VITRAGE_ID)) self.assertFalse(host_vertex[VProps.VITRAGE_IS_DELETED]) self.assertTrue(host_vertex[VProps.VITRAGE_IS_PLACEHOLDER]) self.assertEqual(EntityCategory.RESOURCE, host_vertex[VProps.VITRAGE_CATEGORY]) self.assertEqual(event[ZabbixProps.RESOURCE_NAME], host_vertex[VProps.ID]) self.assertEqual(NOVA_HOST_DATASOURCE, host_vertex[VProps.VITRAGE_TYPE]) edge = neighbor.edge self.assertEqual(EdgeLabel.ON, edge.label) alarm_key = ZabbixTransformer(self.transformers, self.conf).\ _create_entity_key(event) alarm_uuid = TransformerBase.uuid_from_deprecated_vitrage_id(alarm_key) self.assertEqual(alarm_uuid, edge.source_id) self.assertEqual(host_vertex.vertex_id, edge.target_id)
def _create_vitrage_neighbors(self, event): event_type = event[EVALUATOR_EVENT_TYPE] timestamp = transformer_base.convert_timestamp_format( '%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP]) if event_type in [ADD_EDGE, REMOVE_EDGE]: relation_edge = graph_utils.create_edge( source_id=event[TFields.SOURCE], target_id=event[TFields.TARGET], relationship_type=event[EProps.RELATIONSHIP_TYPE], update_timestamp=timestamp) return [Neighbor(None, relation_edge)] if event_type == ADD_VERTEX: result = [] relation_edge = graph_utils.create_edge( source_id=TransformerBase.uuid_from_deprecated_vitrage_id( self._create_entity_key(event)), target_id=event[TFields.TARGET], relationship_type=EdgeLabel.ON, update_timestamp=timestamp) neighbor_props = { VProps.VITRAGE_IS_PLACEHOLDER: True, VProps.UPDATE_TIMESTAMP: timestamp, VProps.VITRAGE_SAMPLE_TIMESTAMP: event[VProps.VITRAGE_SAMPLE_TIMESTAMP], VProps.IS_REAL_VITRAGE_ID: True, VProps.VITRAGE_TYPE: event.get(VProps.VITRAGE_RESOURCE_TYPE), VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, } result.append( Neighbor(Vertex(event[TFields.TARGET], neighbor_props), relation_edge)) if event.get(TFields.CAUSING_ALARM): relation_edge = graph_utils.create_edge( source_id=event[TFields.CAUSING_ALARM], target_id=TransformerBase.uuid_from_deprecated_vitrage_id( self._create_entity_key(event)), relationship_type=EdgeLabel.CAUSES, update_timestamp=timestamp) result.append( Neighbor( Vertex( event[TFields.CAUSING_ALARM], { VProps.UPDATE_TIMESTAMP: timestamp, VProps.VITRAGE_IS_PLACEHOLDER: True, }), relation_edge)) return result return []
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_placeholder_vertex(self): properties = { VProps.VITRAGE_TYPE: self.entity_type, VProps.ID: self.entity_id, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: self.timestamp } placeholder = self.transformer.create_neighbor_placeholder_vertex( **properties) observed_entity_id = placeholder.vertex_id expected_entity_id = \ TransformerBase.uuid_from_deprecated_vitrage_id( 'RESOURCE:static:12345') self.assertEqual(expected_entity_id, observed_entity_id) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(self.timestamp, observed_time) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(self.entity_type, observed_subtype) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(self.entity_id, observed_entity_id) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) self.assertTrue(vitrage_is_placeholder)
def _validate_host_neighbor(self, h_neighbor, event): inst_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE] field_extractor = inst_transformer._get_field_extractor(event) host_name = field_extractor.host(event) time = event[DSProps.SAMPLE_DATE] host_transformer = 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 = \ host_transformer.create_neighbor_placeholder_vertex(**properties) self.assertEqual(expected_neighbor, h_neighbor.vertex) # Validate neighbor edge edge = h_neighbor.edge entity_key = inst_transformer._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 _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 test_nagios_alarm_transform(self): LOG.debug('Nagios alarm transformer test: transform entity event') # Test setup spec_list = mock_sync.simple_nagios_alarm_generators(host_num=4, events_num=10) nagios_alarms = mock_sync.generate_sequential_events_list(spec_list) transformer = NagiosTransformer(self.transformers, self.conf) for alarm in nagios_alarms: cur_alarm_uuid = None if alarm.get(NagiosProperties.STATUS) == NagiosTestStatus.OK: alarm_key = transformer._create_entity_key(alarm) cur_alarm_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id( alarm_key) # Test action wrapper = transformer.transform(alarm) self._validate_vertex(wrapper.vertex, alarm) neighbors = wrapper.neighbors self.assertEqual(1, len(neighbors)) neighbor = neighbors[0] # Right now we are support only host as a resource if neighbor.vertex[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE: self._validate_host_neighbor(neighbors[0], alarm, cur_alarm_uuid) self._validate_action(alarm, wrapper)
def test_create_update_entity_vertex(self): # Test setup time1 = time.time() host1 = 'compute-1' event = self._generate_event(time1, host1, 'WARNING') self.assertIsNotNone(event) # Test action transformer = self.transformers[COLLECTD_DATASOURCE] wrapper = transformer.transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) entity_key = transformer._create_entity_key(event) entity_uuid = TransformerBase.uuid_from_deprecated_vitrage_id( entity_key) # Validate the neighbors: only one valid host neighbor self._validate_host_neighbor(wrapper, entity_uuid, host1) # Validate the expected action on the graph - update or delete self._validate_graph_action(wrapper) # Create an event with status 'UP' time2 = time.time() host2 = 'compute-2' event = self._generate_event(time2, host2, 'OK') self.assertIsNotNone(event) # Test action entity_key = transformer._create_entity_key(event) entity_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(entity_key) transformer = self.transformers[COLLECTD_DATASOURCE] wrapper = transformer.transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) self._validate_host_neighbor(wrapper, entity_uuid, host2) self._validate_graph_action(wrapper)
def _create_aodh_neighbors(self, entity_event): graph_neighbors = entity_event.get(self.QUERY_RESULT, []) result = [] for vertex in graph_neighbors: edge = graph_utils.create_edge( source_id=TransformerBase.uuid_from_deprecated_vitrage_id( self._create_entity_key(entity_event)), target_id=vertex.vertex_id, relationship_type=EdgeLabel.ON) result.append(Neighbor(vertex, edge)) return result
def test_create_host_neighbor(self): LOG.debug('Test create host neighbor') # Test setup host_name = 'host123' vertex_key = 'RESOURCE:nova.instance:instance321' vertex_id = \ TransformerBase.uuid_from_deprecated_vitrage_id(vertex_key) time = datetime.datetime.utcnow() entity_event = { '_info': { 'host_name': host_name }, DSProps.DATASOURCE_ACTION: 'SNAPSHOT', 'id': 'instance321', DSProps.SAMPLE_DATE: time } # Test action instance_transformer = self.transformers[NOVA_INSTANCE_DATASOURCE] neighbor = \ instance_transformer._create_neighbor(entity_event, host_name, NOVA_HOST_DATASOURCE, EdgeLabel.CONTAINS, is_entity_source=False) # Test assertions host_vertex_id = \ TransformerBase.uuid_from_deprecated_vitrage_id( 'RESOURCE:nova.host:host123') self.assertEqual(host_vertex_id, neighbor.vertex.vertex_id) self.assertEqual( time, neighbor.vertex.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) ) # test relation edge self.assertEqual(host_vertex_id, neighbor.edge.source_id) self.assertEqual(vertex_id, neighbor.edge.target_id) self.assertEqual(EdgeLabel.CONTAINS, neighbor.edge.label)
def test_topology(self): sample_timestamp = \ datetime.now().strftime(transformer_base.TIMESTAMP_FORMAT) update_timestamp = TransformerBase._format_update_timestamp( update_timestamp=None, sample_timestamp=sample_timestamp) transformer = self.transformers[TMFAPI639_DATASOURCE] # Create 1 vertex event1 = loads(message)[0] event1[DSProps.DATASOURCE_ACTION] = DatasourceAction.SNAPSHOT event1[DSProps.SAMPLE_DATE] = update_timestamp self.assertIsNotNone(event1) # Create vertex 1 wrapper1 = transformer.transform(event1) # Assertion self._validate_base_vertex_props(wrapper1.vertex, event1["name"], TMFAPI639_DATASOURCE) # Create 2nd vertex event2 = loads(message)[1] event2[DSProps.DATASOURCE_ACTION] = DatasourceAction.SNAPSHOT event2[DSProps.SAMPLE_DATE] = update_timestamp self.assertIsNotNone(event2) # Create vertex 2 wrapper2 = transformer.transform(event2) # Assertion self._validate_base_vertex_props(wrapper2.vertex, event2["name"], TMFAPI639_DATASOURCE) # Test whether they are linked self.assertThat(wrapper2.neighbors, matchers.HasLength(1)) parent_id = transformer._create_entity_key(event1) parent_uuid = \ transformer.uuid_from_deprecated_vitrage_id(parent_id) child_id = transformer._create_entity_key(event2) child_uuid = \ transformer.uuid_from_deprecated_vitrage_id(child_id) self.assertEqual(wrapper2.neighbors[0].edge.source_id, child_uuid) self.assertEqual(wrapper2.neighbors[0].edge.target_id, parent_uuid)
def test_create_placeholder_vertex(self): LOG.debug('Static Physical transformer test: Create placeholder ' 'vertex') # Test setup switch_type = STATIC_PHYSICAL_DATASOURCE switch_name = 'switch-1' timestamp = datetime.datetime.utcnow() static_transformer = self.transformers[STATIC_PHYSICAL_DATASOURCE] # Test action properties = { VProps.VITRAGE_TYPE: switch_type, VProps.ID: switch_name, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } placeholder = \ static_transformer.create_neighbor_placeholder_vertex(**properties) # Test assertions observed_uuid = placeholder.vertex_id expected_key = tbase.build_key(static_transformer._key_values( switch_type, switch_name)) expected_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(expected_key) self.assertEqual(expected_uuid, observed_uuid) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(timestamp, observed_time) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(switch_type, observed_subtype) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(switch_name, observed_entity_id) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) self.assertTrue(vitrage_is_placeholder)
def test_create_placeholder_vertex(self): LOG.debug('Test create placeholder vertex') # Tests setup instance_id = 'Instance123' timestamp = datetime.datetime.utcnow() properties = { VProps.ID: instance_id, VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } transformer = self.transformers[NOVA_INSTANCE_DATASOURCE] # Test action placeholder = \ transformer.create_neighbor_placeholder_vertex(**properties) # Test assertions observed_uuid = placeholder.vertex_id expected_key = tbase.build_key(transformer._key_values( NOVA_INSTANCE_DATASOURCE, instance_id)) expected_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(expected_key) self.assertEqual(expected_uuid, observed_uuid) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(timestamp, observed_time) observed_type = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(NOVA_INSTANCE_DATASOURCE, observed_type) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(instance_id, observed_entity_id) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) self.assertTrue(vitrage_is_placeholder)
def test_create_placeholder_vertex(self): LOG.debug('Cetus pod transformer test: Test create placeholder ' 'vertex') # Test setup pod_id = "pod123" timestamp = datetime.datetime.utcnow() pod_transformer = self.transformers[CETUS_POD_DATASOURCE] # Test action properties = { VProps.ID: pod_id, VProps.VITRAGE_TYPE: CETUS_POD_DATASOURCE, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } placeholder = \ pod_transformer.create_neighbor_placeholder_vertex(**properties) # Test assertions observed_uuid = placeholder.vertex_id expected_key = tbase.build_key( pod_transformer._key_values(CETUS_POD_DATASOURCE, pod_id)) expected_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(expected_key) self.assertEqual(expected_uuid, observed_uuid) observed_time = placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP) self.assertEqual(timestamp, observed_time) observed_subtype = placeholder.get(VProps.VITRAGE_TYPE) self.assertEqual(CETUS_POD_DATASOURCE, observed_subtype) observed_entity_id = placeholder.get(VProps.ID) self.assertEqual(pod_id, observed_entity_id) observed_vitrage_category = placeholder.get(VProps.VITRAGE_CATEGORY) self.assertEqual(EntityCategory.RESOURCE, observed_vitrage_category) vitrage_is_placeholder = placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER) self.assertTrue(vitrage_is_placeholder)
def test_create_update_entity_vertex(self): # Test setup time1 = datetime.now().isoformat() host1 = 'host1' event = self._generate_event(time1, host1, DoctorStatus.DOWN) self.assertIsNotNone(event) # Test action transformer = self.transformers[DOCTOR_DATASOURCE] wrapper = transformer.transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) entity_key1 = transformer._create_entity_key(event) entity_uuid1 = transformer.uuid_from_deprecated_vitrage_id(entity_key1) # Validate the neighbors: only one valid host neighbor self._validate_host_neighbor(wrapper, entity_uuid1, host1) # Validate the expected action on the graph - update or delete self._validate_graph_action(wrapper) # Create an event with status 'UP' time2 = datetime.now().isoformat() host2 = 'host2' event = self._generate_event(time2, host2, DoctorStatus.UP) self.assertIsNotNone(event) # Test action # after transform vitrage uuid will be deleted from uuid cache entity_key2 = transformer._create_entity_key(event) entity_uuid2 = \ TransformerBase.uuid_from_deprecated_vitrage_id(entity_key2) transformer = self.transformers[DOCTOR_DATASOURCE] wrapper = transformer.transform(event) # Test assertions self._validate_vertex_props(wrapper.vertex, event) self._validate_host_neighbor(wrapper, entity_uuid2, host2) self._validate_graph_action(wrapper)
def test_create_placeholder_vertex(self): # Tests setup cluster_id = 'tr-cluster-0' timestamp = datetime.datetime.utcnow() properties = { VProps.ID: cluster_id, VProps.VITRAGE_TYPE: TROVE_CLUSTER_DATASOURCE, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: timestamp } transformer = self.transformers[TROVE_CLUSTER_DATASOURCE] # Test action placeholder = transformer.create_neighbor_placeholder_vertex( **properties) # Test assertions expected_key = tb.build_key( transformer._key_values(TROVE_CLUSTER_DATASOURCE, cluster_id)) expected_uuid = TransformerBase.uuid_from_deprecated_vitrage_id( expected_key) self.assertEqual(expected_uuid, placeholder.vertex_id) self.assertEqual(timestamp, placeholder.get(VProps.VITRAGE_SAMPLE_TIMESTAMP)) self.assertEqual(TROVE_CLUSTER_DATASOURCE, placeholder.get(VProps.VITRAGE_TYPE)) self.assertEqual(cluster_id, placeholder.get(VProps.ID)) self.assertEqual(EntityCategory.RESOURCE, placeholder.get(VProps.VITRAGE_CATEGORY)) self.assertTrue(placeholder.get(VProps.VITRAGE_IS_PLACEHOLDER))
def _validate_cluster_neighbors(self, neighbor, event): # Create expected neighbor time = event[DSProps.SAMPLE_DATE] external_id = event['resources'][0][kubProp.EXTERNALID] properties = { VProps.ID: external_id, VProps.VITRAGE_TYPE: NOVA_INSTANCE_DATASOURCE, VProps.VITRAGE_CATEGORY: EntityCategory.RESOURCE, VProps.VITRAGE_SAMPLE_TIMESTAMP: time } nova_instance_tran = self.transformers[NOVA_INSTANCE_DATASOURCE] expected_neighbor = \ nova_instance_tran.create_neighbor_placeholder_vertex(**properties) self.assertEqual(expected_neighbor, neighbor[0].vertex) # Validate neighbor edge edge = neighbor[0].edge entity_key = \ self.transformers[KUBERNETES_DATASOURCE]._create_entity_key(event) entity_uuid = \ TransformerBase.uuid_from_deprecated_vitrage_id(entity_key) self.assertEqual(edge.source_id, entity_uuid) self.assertEqual(edge.target_id, neighbor[0].vertex.vertex_id)