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