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)
