def _create_entity_vertex(self, entity_event):
sync_mode = entity_event['sync_mode']
host_name = extract_field_value(
entity_event,
self.HOST_NAME[sync_mode]
)
metadata = {VertexProperties.NAME: host_name}
entity_key = self.extract_key(entity_event)
timestamp = extract_field_value(
entity_event,
self.TIMESTAMP[sync_mode]
)
return graph_utils.create_vertex(
entity_key,
entity_id=host_name,
entity_category=EntityTypes.RESOURCE,
entity_type=self.HOST_TYPE,
update_timestamp=timestamp,
metadata=metadata
)
def _create_entity_vertex(self, entity_event):
sync_mode = entity_event['sync_mode']
zone_name = extract_field_value(
entity_event,
self.ZONE_NAME[sync_mode]
)
metadata = {
VertexProperties.NAME: zone_name
}
entity_key = self.extract_key(entity_event)
is_available = extract_field_value(
entity_event,
self.ZONE_STATE[sync_mode]
)
state = self.STATE_AVAILABLE if is_available \
else self.STATE_UNAVAILABLE
timestamp = extract_field_value(
entity_event,
self.TIMESTAMP[sync_mode]
)
return graph_utils.create_vertex(
entity_key,
entity_id=zone_name,
entity_category=EntityTypes.RESOURCE,
entity_type=self.ZONE_TYPE,
entity_state=state,
update_timestamp=timestamp,
metadata=metadata
)
def _create_neighbors(self, entity_event):
sync_mode = entity_event['sync_mode']
neighbors = []
host_transformer = self.transformers['nova.host']
if host_transformer:
update_timestamp = extract_field_value(
entity_event,
self.TIMESTAMP[sync_mode]
)
host_neighbor = self._create_host_neighbor(
self.extract_key(entity_event),
extract_field_value(entity_event, self.HOST_NAME[sync_mode]),
update_timestamp,
host_transformer
)
neighbors.append(host_neighbor)
else:
LOG.warning('Cannot find host transformer')
return neighbors
def _validate_host_neighbor(self, h_neighbor, event):
it = InstanceTransformer(self.transformers)
sync_mode = event['sync_mode']
host_name = tbase.extract_field_value(event, it.HOST_NAME[sync_mode])
time = tbase.extract_field_value(event, it.TIMESTAMP[sync_mode])
ht = self.transformers['nova.host']
expected_neighbor = ht.create_placeholder_vertex(host_name, time)
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.extract_key(event))
self.assertEqual(edge.label, EdgeLabels.CONTAINS)
def extract_key(self, entity_event):
instance_id = extract_field_value(
entity_event,
self.INSTANCE_ID[entity_event['sync_mode']])
key_fields = self._key_values([instance_id])
return base.build_key(key_fields)
def _create_neighbors(self, entity_event):
sync_mode = entity_event['sync_mode']
zone_vertex_id = self.extract_key(entity_event)
neighbors = [self._create_node_neighbor(zone_vertex_id)]
hosts = extract_field_value(entity_event, self.HOSTS[sync_mode])
host_transformer = self.transformers['nova.host']
if host_transformer:
timestamp = extract_field_value(
entity_event,
self.TIMESTAMP[sync_mode]
)
for key in hosts:
host_available = extract_field_value(
hosts[key],
self.HOST_AVAILABLE[sync_mode]
)
host_active = extract_field_value(
hosts[key],
self.HOST_ACTIVE[sync_mode]
)
if host_available and host_active:
host_state = self.STATE_AVAILABLE
else:
host_state = self.STATE_UNAVAILABLE
host_neighbor = self._create_host_neighbor(
zone_vertex_id,
key,
host_state,
timestamp
)
neighbors.append(host_neighbor)
else:
LOG.warning('Cannot find host transformer')
return neighbors
def extract_key(self, entity_event):
host_name = extract_field_value(
entity_event,
self.HOST_NAME[entity_event['sync_mode']]
)
key_fields = self._key_values([host_name])
return base.build_key(key_fields)
def _validate_host_neighbor(self,
host_neighbor,
zone_vertex_id,
hosts,
sync_mode):
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,
ZoneTransformer.HOST_AVAILABLE[sync_mode]
)
host_active = tbase.extract_field_value(
host_dic,
ZoneTransformer.HOST_ACTIVE[sync_mode]
)
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, EdgeLabels.CONTAINS)
def _create_entity_vertex(self, entity_event):
sync_mode = entity_event['sync_mode']
metadata = {
VertexProperties.NAME: extract_field_value(
entity_event,
self.INSTANCE_NAME[sync_mode]
),
VertexProperties.IS_PLACEHOLDER: False
}
entity_key = self.extract_key(entity_event)
entity_id = extract_field_value(
entity_event,
self.INSTANCE_ID[sync_mode]
)
project = extract_field_value(entity_event, self.PROJECT_ID[sync_mode])
state = extract_field_value(
entity_event,
self.INSTANCE_STATE[sync_mode]
)
update_timestamp = extract_field_value(
entity_event,
self.TIMESTAMP[sync_mode]
)
return graph_utils.create_vertex(
entity_key,
entity_id=entity_id,
entity_category=EntityTypes.RESOURCE,
entity_type=self.INSTANCE_TYPE,
entity_project=project,
entity_state=state,
update_timestamp=update_timestamp,
metadata=metadata
)
def _validate_zone_neighbor(self, zone, event):
sync_mode = event['sync_mode']
zone_name = tbase.extract_field_value(
event,
HostTransformer(self.transformers).ZONE_NAME[sync_mode]
)
time = tbase.extract_field_value(
event,
HostTransformer(self.transformers).TIMESTAMP[sync_mode]
)
zt = self.transformers['nova.zone']
expected_neighbor = zt.create_placeholder_vertex(zone_name, time)
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).extract_key(event)
)
self.assertEqual(edge.label, EdgeLabels.CONTAINS)
def _validate_neighbors(self, neighbors, zone_vertex_id, event):
node_neighbors_counter = 0
for neighbor in neighbors:
vertex_type = neighbor.vertex.get(VertexProperties.TYPE)
if tbase.NODE_SUBTYPE == vertex_type:
node_neighbors_counter += 1
self._validate_node_neighbor(neighbor, zone_vertex_id)
else:
hosts = tbase.extract_field_value(event, ('hosts',))
self._validate_host_neighbor(neighbor,
zone_vertex_id,
hosts,
event['sync_mode'])
self.assertEqual(1,
node_neighbors_counter,
'Zone can belongs to only one Node')
def _create_neighbors(self, entity_event):
sync_mode = entity_event['sync_mode']
neighbors = []
timestamp = extract_field_value(
entity_event,
self.TIMESTAMP[sync_mode]
)
zone_neighbor = self._create_zone_neighbor(
entity_event,
timestamp,
self.extract_key(entity_event),
self.ZONE_NAME[sync_mode]
)
if zone_neighbor is not None:
neighbors.append(zone_neighbor)
return neighbors
def test_extract_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 = InstanceTransformer(self.transformers)
for event in instance_events:
# Test action
observed_key = instance_transformer.extract_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityTypes.RESOURCE, observed_key_fields[0])
self.assertEqual(
InstanceTransformer.INSTANCE_TYPE,
observed_key_fields[1]
)
instance_id = tbase.extract_field_value(
event,
instance_transformer.INSTANCE_ID[event['sync_mode']]
)
self.assertEqual(instance_id, observed_key_fields[2])
key_values = instance_transformer._key_values([instance_id])
expected_key = tbase.build_key(key_values)
self.assertEqual(expected_key, observed_key)
def _create_zone_neighbor(
self, entity_event, timestamp, host_vertex_id, zone_name_path):
zone_transformer = self.transformers['nova.zone']
if zone_transformer:
zone_name = extract_field_value(entity_event, zone_name_path)
zone_neighbor = zone_transformer.create_placeholder_vertex(
zone_name,
timestamp
)
relation_edge = graph_utils.create_edge(
source_id=zone_neighbor.vertex_id,
target_id=host_vertex_id,
relationship_type=EdgeLabels.CONTAINS
)
return base.Neighbor(zone_neighbor, relation_edge)
else:
LOG.warning('Cannot find zone transformer')
return None
