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)
