def test_aggregated_state_functionalities(self): # setup state_manager = StateManager(self.conf) new_vertex1 = create_vertex('12345', entity_state='ACTIVE', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE) metadata2 = {VProps.VITRAGE_STATE: 'SUBOPTIMAL'} new_vertex2 = create_vertex('23456', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) new_vertex3 = create_vertex('34567', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE) graph_vertex3 = create_vertex('45678', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE) # action state_manager.aggregated_state(new_vertex1, None) state_manager.aggregated_state(new_vertex2, None) state_manager.aggregated_state(new_vertex3, graph_vertex3) # test assertions self.assertEqual(NormalizedResourceState.RUNNING, new_vertex1[VProps.AGGREGATED_STATE]) self.assertEqual(NormalizedResourceState.SUBOPTIMAL, new_vertex2[VProps.AGGREGATED_STATE]) self.assertEqual(NormalizedResourceState.UNDEFINED, new_vertex3[VProps.AGGREGATED_STATE])
def test_aggregated_state_not_normalized(self): # setup state_manager = StateManager(self.conf) metadata1 = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex1 = create_vertex('12345', entity_state='ACTIVE', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata1) metadata2 = {VProps.VITRAGE_STATE: 'ACTIVE'} new_vertex2 = create_vertex('23456', entity_state='SUSPENDED', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) # action state_manager.aggregated_state(new_vertex1, None) state_manager.aggregated_state(new_vertex2, None) # test assertions self.assertEqual(NormalizedResourceState.SUSPENDED, new_vertex1[VProps.AGGREGATED_STATE]) self.assertEqual(NormalizedResourceState.SUSPENDED, new_vertex2[VProps.AGGREGATED_STATE])
def test_aggregated_state(self): # setup state_manager = DatasourceInfoMapper(self.conf) metadata1 = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex1 = create_vertex('12345', entity_state='ACTIVE', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata1) metadata2 = {VProps.VITRAGE_STATE: 'ACTIVE'} new_vertex2 = create_vertex('23456', entity_state='SUSPENDED', entity_category=EntityCategory.RESOURCE, entity_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) # action state_manager.aggregated_state(new_vertex1, None) state_manager.aggregated_state(new_vertex2, None) # test assertions self.assertEqual('SUSPENDED', new_vertex1[VProps.AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex1[VProps.OPERATIONAL_STATE]) self.assertEqual('SUSPENDED', new_vertex2[VProps.AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex2[VProps.OPERATIONAL_STATE])
def test_vitrage_aggregated_value(self): # setup info_mapper = DatasourceInfoMapper(self.conf) metadata1 = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex1 = create_vertex('12345', vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='ACTIVE', metadata=metadata1) metadata2 = {VProps.VITRAGE_STATE: 'ACTIVE'} new_vertex2 = create_vertex('23456', vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='SUSPENDED', metadata=metadata2) # action info_mapper.vitrage_aggregate_values(new_vertex1, None) info_mapper.vitrage_aggregate_values(new_vertex2, None) # test assertions self.assertEqual('SUSPENDED', new_vertex1[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex1[VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual('SUSPENDED', new_vertex2[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex2[VProps.VITRAGE_OPERATIONAL_STATE])
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_vertex(self, entity_event): update_timestamp = datetime_utils.change_time_str_format( entity_event[NagiosProperties.LAST_CHECK], '%Y-%m-%d %H:%M:%S', tbase.TIMESTAMP_FORMAT) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp(update_timestamp, sample_timestamp) metadata = { VProps.NAME: entity_event[NagiosProperties.SERVICE], VProps.SEVERITY: entity_event[NagiosProperties.STATUS], VProps.INFO: entity_event[NagiosProperties.STATUS_INFO] } return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.ENTITY_TYPE], entity_state=self._get_alarm_state(entity_event), sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event): self._unify_time_format(entity_event) update_timestamp = entity_event[ZProps.TIMESTAMP] sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( update_timestamp, sample_timestamp) zabbix_hostname = entity_event[ZProps.ZABBIX_RESOURCE_NAME] vitrage_hostname = entity_event[ZProps.RESOURCE_NAME] entity_event[ZProps.DESCRIPTION] = entity_event[ZProps.DESCRIPTION]\ .replace(zabbix_hostname, vitrage_hostname) value = entity_event[ZProps.VALUE] entity_state = AlarmProps.INACTIVE_STATE if \ value == TriggerValue.OK else AlarmProps.ACTIVE_STATE metadata = { VProps.NAME: entity_event[ZProps.DESCRIPTION], VProps.SEVERITY: TriggerSeverity.str(entity_event[ZProps.PRIORITY]), VProps.RAWTEXT: entity_event[ZProps.RAWTEXT], VProps.RESOURCE_ID: entity_event[ZProps.RESOURCE_NAME] } return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.ENTITY_TYPE], entity_state=entity_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event): self._unify_time_format(entity_event) update_timestamp = entity_event[ZProps.TIMESTAMP] sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp(update_timestamp, sample_timestamp) zabbix_hostname = entity_event[ZProps.ZABBIX_RESOURCE_NAME] vitrage_hostname = entity_event[ZProps.RESOURCE_NAME] entity_event[ZProps.DESCRIPTION] = entity_event[ZProps.DESCRIPTION]\ .replace(zabbix_hostname, vitrage_hostname) value = entity_event[ZProps.VALUE] entity_state = AlarmProps.INACTIVE_STATE if \ value == TriggerValue.OK else AlarmProps.ACTIVE_STATE metadata = { VProps.NAME: entity_event[ZProps.DESCRIPTION], VProps.SEVERITY: TriggerSeverity.str( entity_event[ZProps.PRIORITY]), VProps.RAWTEXT: entity_event[ZProps.RAWTEXT] } return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.ENTITY_TYPE], entity_state=entity_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event): entity_event['timestamp'] = format_unix_timestamp( entity_event[CProps.TIME], tbase.TIMESTAMP_FORMAT) update_timestamp = entity_event['timestamp'] vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] entity_state = AlarmProps.INACTIVE_STATE \ if self._ok_status(entity_event) else AlarmProps.ACTIVE_STATE metadata = { VProps.NAME: entity_event[CProps.MESSAGE], VProps.SEVERITY: entity_event[CProps.SEVERITY], VProps.RAWTEXT: self.generate_raw_text(entity_event), VProps.RESOURCE_NAME: entity_event[CProps.RESOURCE_NAME] } return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=Category.ALARM, vitrage_type=entity_event[DSProps.ENTITY_TYPE], vitrage_sample_timestamp=vitrage_sample_timestamp, entity_state=entity_state, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event): update_timestamp = datetime_utils.change_time_str_format( entity_event[NagiosProperties.LAST_CHECK], '%Y-%m-%d %H:%M:%S', tbase.TIMESTAMP_FORMAT) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp(update_timestamp, sample_timestamp) severity = entity_event[NagiosProperties.STATUS] entity_state = AlarmProps.ALARM_INACTIVE_STATE if \ severity == NagiosStatus.OK else AlarmProps.ALARM_ACTIVE_STATE metadata = { VProps.NAME: entity_event[NagiosProperties.SERVICE], VProps.SEVERITY: severity, VProps.INFO: entity_event[NagiosProperties.STATUS_INFO] } return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.SYNC_TYPE], entity_state=entity_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, event): event_type = event[EVALUATOR_EVENT_TYPE] update_timestamp = transformer_base.convert_timestamp_format( '%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP]) if event_type == UPDATE_VERTEX: properties = { VProps.VITRAGE_STATE: event[VProps.VITRAGE_STATE], VProps.UPDATE_TIMESTAMP: update_timestamp, VProps.SAMPLE_TIMESTAMP: event[VProps.SAMPLE_TIMESTAMP], VProps.IS_PLACEHOLDER: False } return Vertex(event[VProps.VITRAGE_ID], properties) if event_type in [ADD_VERTEX, REMOVE_VERTEX]: metadata = { VProps.NAME: event[TFields.ALARM_NAME], VProps.SEVERITY: event[TFields.SEVERITY], VProps.STATE: event[VProps.STATE] } return graph_utils.create_vertex( self._create_entity_key(event), entity_category=EntityCategory.ALARM, entity_type=VITRAGE_TYPE, sample_timestamp=event[VProps.SAMPLE_TIMESTAMP], update_timestamp=update_timestamp, metadata=metadata) return None
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_vertex(self, entity_event): metadata = { VProps.NAME: entity_event[AodhProps.NAME], VProps.SEVERITY: entity_event[AodhProps.SEVERITY], AodhProps.DESCRIPTION: entity_event[AodhProps.DESCRIPTION], AodhProps.ENABLED: entity_event[AodhProps.ENABLED], VProps.PROJECT_ID: entity_event[AodhProps.PROJECT_ID], AodhProps.REPEAT_ACTIONS: entity_event[AodhProps.REPEAT_ACTIONS], 'alarm_type': entity_event[AodhProps.TYPE] } if entity_event[AodhProps.TYPE] == AodhProps.EVENT: metadata[AodhProps.EVENT_TYPE] = entity_event[AodhProps.EVENT_TYPE] elif entity_event[AodhProps.TYPE] == AodhProps.THRESHOLD: metadata[AodhProps.STATE_TIMESTAMP] = \ entity_event[AodhProps.STATE_TIMESTAMP] sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( AodhTransformer._timestamp(entity_event), sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_id=entity_event[AodhProps.ALARM_ID], entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.SYNC_TYPE], entity_state=AlarmProps.ALARM_ACTIVE_STATE, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event): update_timestamp = datetime_utils.change_to_utc_time_and_format( entity_event[NagiosProperties.LAST_CHECK], '%Y-%m-%d %H:%M:%S', tbase.TIMESTAMP_FORMAT) vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = \ self._format_update_timestamp(update_timestamp, vitrage_sample_timestamp) metadata = { VProps.NAME: entity_event[NagiosProperties.SERVICE], VProps.RESOURCE_ID: entity_event[NagiosProperties.RESOURCE_NAME], VProps.SEVERITY: entity_event[NagiosProperties.STATUS], VProps.INFO: entity_event[NagiosProperties.STATUS_INFO] } return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.ALARM, vitrage_type=entity_event[DSProps.ENTITY_TYPE], vitrage_sample_timestamp=vitrage_sample_timestamp, entity_state=self._get_alarm_state(entity_event), update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event, stack_name, stack_id, stack_state, update_timestamp, project_id): metadata = { VProps.NAME: stack_name, VProps.PROJECT_ID: project_id, } entity_key = self._create_entity_key(entity_event) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( entity_key, entity_id=stack_id, entity_category=EntityCategory.RESOURCE, entity_type=HEAT_STACK_DATASOURCE, entity_state=stack_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
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_vertex(self, entity_event): update_timestamp = entity_event[KProps.TIMESTAMP] vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = \ self._format_update_timestamp(update_timestamp, vitrage_sample_timestamp) kapacitor_hostname = entity_event[KProps.KAPACITOR_RESOURCE_NAME] vitrage_hostname = entity_event[KProps.RESOURCE_NAME] entity_event[KProps.DETAILS] = entity_event[KProps.DETAILS]\ .replace(kapacitor_hostname, vitrage_hostname) metadata = { VProps.NAME: entity_event[KProps.MESSAGE], VProps.SEVERITY: entity_event[KProps.PRIORITY], VProps.RAWTEXT: entity_event[KProps.DETAILS], VProps.RESOURCE_ID: entity_event[KProps.RESOURCE_NAME] } return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.ALARM, vitrage_type=entity_event[DSProps.ENTITY_TYPE], vitrage_sample_timestamp=vitrage_sample_timestamp, update_timestamp=update_timestamp, entity_state=self._get_alarm_state(entity_event), metadata=metadata)
def _create_vertex(self, entity_event): entity_type = entity_event[StaticFields.TYPE] entity_category = entity_event.get(StaticFields.CATEGORY, EntityCategory.RESOURCE) entity_id = entity_event[VProps.ID] vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] if entity_type in self.transformers: properties = { VProps.VITRAGE_TYPE: entity_type, VProps.ID: entity_id, VProps.VITRAGE_CATEGORY: entity_category, VProps.VITRAGE_SAMPLE_TIMESTAMP: vitrage_sample_timestamp, VProps.VITRAGE_IS_PLACEHOLDER: False } return self.create_neighbor_placeholder_vertex(**properties) else: entity_key = self._create_entity_key(entity_event) state = entity_event[VProps.STATE] update_timestamp = self._format_update_timestamp( update_timestamp=None, sample_timestamp=vitrage_sample_timestamp) metadata = entity_event.get(StaticFields.METADATA, {}) return graph_utils.create_vertex( entity_key, vitrage_category=entity_category, vitrage_type=entity_type, vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_id, update_timestamp=update_timestamp, entity_state=state, metadata=metadata)
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_vertex(self, entity_event): """Camps used from the received JSON: {id, name, @type ,resourceRelationship : [type, resource: id]} The TMF 639 API REST Endpoint can contain more information but we only use this one for topology. """ sample_timestamp = \ datetime.now().strftime(transformer_base.TIMESTAMP_FORMAT) update_timestamp = self._format_update_timestamp( update_timestamp=None, sample_timestamp=sample_timestamp) metadata = { VProps.NAME: entity_event["name"], } return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.RESOURCE, vitrage_type=TMFAPI639_DATASOURCE, vitrage_sample_timestamp=sample_timestamp, entity_id=entity_event["id"], update_timestamp=update_timestamp, entity_state='available', metadata=metadata)
def _create_vertex(self, entity_event): metadata = { VProps.NAME: entity_event[AodhProps.NAME], VProps.SEVERITY: entity_event[AodhProps.SEVERITY], AodhProps.DESCRIPTION: entity_event[AodhProps.DESCRIPTION], AodhProps.ENABLED: entity_event[AodhProps.ENABLED], VProps.PROJECT_ID: entity_event.get(AodhProps.PROJECT_ID, None), AodhProps.REPEAT_ACTIONS: entity_event[AodhProps.REPEAT_ACTIONS], VProps.RESOURCE_ID: entity_event[AodhProps.RESOURCE_ID], 'alarm_type': entity_event[AodhProps.TYPE] } # TODO(annarez): convert EVENT_TYPE to tuple if entity_event[AodhProps.TYPE] == AodhProps.EVENT: metadata[AodhProps.EVENT_TYPE] = entity_event[AodhProps.EVENT_TYPE] elif entity_event[AodhProps.TYPE] == AodhProps.THRESHOLD: metadata[AodhProps.STATE_TIMESTAMP] = \ entity_event[AodhProps.STATE_TIMESTAMP] vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( AodhTransformer._timestamp(entity_event), vitrage_sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.ALARM, vitrage_type=entity_event[DSProps.ENTITY_TYPE], vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=entity_event[AodhProps.ALARM_ID], entity_state=self._get_alarm_state(entity_event), update_timestamp=update_timestamp, metadata=metadata)
def _create_vertex(self, entity_event): metadata = { VProps.NAME: entity_event[AodhProps.NAME], VProps.SEVERITY: entity_event[AodhProps.SEVERITY], AodhProps.DESCRIPTION: entity_event[AodhProps.DESCRIPTION], AodhProps.ENABLED: entity_event[AodhProps.ENABLED], VProps.PROJECT_ID: entity_event.get(AodhProps.PROJECT_ID, None), AodhProps.REPEAT_ACTIONS: entity_event[AodhProps.REPEAT_ACTIONS], 'alarm_type': entity_event[AodhProps.TYPE] } if entity_event[AodhProps.TYPE] == AodhProps.EVENT: metadata[AodhProps.EVENT_TYPE] = entity_event[AodhProps.EVENT_TYPE] elif entity_event[AodhProps.TYPE] == AodhProps.THRESHOLD: metadata[AodhProps.STATE_TIMESTAMP] = \ entity_event[AodhProps.STATE_TIMESTAMP] sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( AodhTransformer._timestamp(entity_event), sample_timestamp) return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_id=entity_event[AodhProps.ALARM_ID], entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.ENTITY_TYPE], entity_state=self._get_alarm_state(entity_event), sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
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_vertex(self, entity_event, volume_name, volume_id, volume_state, project_id, update_timestamp, volume_size, volume_type, attachments, server_id_key): server_ids = [] for attachment in attachments: server_ids.append((attachment[server_id_key])) metadata = { VProps.NAME: volume_name, VProps.PROJECT_ID: project_id, CinderProps.SIZE: volume_size, CinderProps.VOLUME_TYPE: volume_type, CinderProps.ATTACHMENTS: tuple(server_ids) } entity_key = self._create_entity_key(entity_event) vitrage_sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( entity_key, vitrage_category=EntityCategory.RESOURCE, vitrage_type=CINDER_VOLUME_DATASOURCE, vitrage_sample_timestamp=vitrage_sample_timestamp, entity_id=volume_id, entity_state=volume_state, update_timestamp=format_timestamp(update_timestamp), metadata=metadata)
def test_update_relationship(self): # setup vertex1, neighbors1, processor = self._create_entity( spec_type=self.INSTANCE_SPEC, datasource_action=DSAction.INIT_SNAPSHOT) vertex2, neighbors2, processor = self._create_entity( spec_type=self.INSTANCE_SPEC, datasource_action=DSAction.INIT_SNAPSHOT, processor=processor) self.assertEqual(2, processor.entity_graph.num_edges()) new_edge = graph_utils.create_edge(vertex1.vertex_id, vertex2.vertex_id, 'backup') mock_neighbor = graph_utils.create_vertex( "asdjashdkahsdashdalksjhd", vitrage_category="RESOURCE", vitrage_type="nova.instance", entity_id="wtw64768476", entity_state="AVAILABLE", ) new_neighbors = [Neighbor(mock_neighbor, new_edge)] # action processor.update_relationship(vertex1, new_neighbors) # test assertions self.assertEqual(3, processor.entity_graph.num_edges())
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_vertex(self, entity_event): update_timestamp = datetime_utils.change_time_str_format( entity_event[NagiosProperties.LAST_CHECK], '%Y-%m-%d %H:%M:%S', tbase.TIMESTAMP_FORMAT) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( update_timestamp, sample_timestamp) severity = entity_event[NagiosProperties.STATUS] entity_state = AlarmProps.ALARM_INACTIVE_STATE if \ severity == NagiosStatus.OK else AlarmProps.ALARM_ACTIVE_STATE metadata = { VProps.NAME: entity_event[NagiosProperties.SERVICE], VProps.SEVERITY: severity, VProps.INFO: entity_event[NagiosProperties.STATUS_INFO] } return graph_utils.create_vertex( self._create_entity_key(entity_event), entity_category=EntityCategory.ALARM, entity_type=entity_event[DSProps.SYNC_TYPE], entity_state=entity_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def create_neighbor_placeholder_vertex(self, **kwargs): if VProps.VITRAGE_TYPE not in kwargs: LOG.error("Can't create placeholder vertex. Missing property TYPE") raise ValueError('Missing property TYPE') if VProps.ID not in kwargs: LOG.error("Can't create placeholder vertex. Missing property ID") raise ValueError('Missing property ID') metadata = {} if self.METADATA in kwargs: metadata = kwargs[self.METADATA] key_fields = self._key_values(kwargs[VProps.VITRAGE_TYPE], kwargs[VProps.ID]) vertex = graph_utils.create_vertex( build_key(key_fields), vitrage_category=kwargs[VProps.VITRAGE_CATEGORY], vitrage_type=kwargs[VProps.VITRAGE_TYPE], vitrage_sample_timestamp=kwargs[VProps.VITRAGE_SAMPLE_TIMESTAMP], vitrage_is_placeholder=kwargs.get(VProps.VITRAGE_IS_PLACEHOLDER, True), entity_id=kwargs[VProps.ID], metadata=metadata) return self.update_uuid_in_vertex(vertex)
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): return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=EntityCategory.RESOURCE, vitrage_type=None, # FIXME vitrage_sample_timestamp=None, # FIXME entity_id=None, # FIXME update_timestamp=None, # FIXME entity_state=None, # FIXME metadata=None) # FIXME
def _create_alarm(vitrage_id, alarm_type, project_id=None): return graph_utils.create_vertex(vitrage_id, entity_id=vitrage_id, entity_category=EntityCategory.ALARM, entity_type=alarm_type, entity_state='active', is_deleted=False, sample_timestamp=None, is_placeholder=False, project_id=project_id)
def _create_vertex(entity_event): metadata = { VProps.IS_REAL_VITRAGE_ID: entity_event.get(VProps.IS_REAL_VITRAGE_ID, False) } return graph_utils.create_vertex( entity_event[VProps.VITRAGE_ID], vitrage_sample_timestamp=entity_event[DSProps.SAMPLE_DATE], metadata=metadata)
def create_placeholder_vertex(self, zone_name, timestamp): key = base.build_key(self._key_values([zone_name])) return graph_utils.create_vertex( key, entity_id=zone_name, entity_category=EntityTypes.RESOURCE, entity_type=self.ZONE_TYPE, update_timestamp=timestamp, is_placeholder=True )
def _create_resource(vitrage_id, resource_type, project_id=None): return graph_utils.create_vertex( vitrage_id, entity_id=vitrage_id, entity_category=EntityCategory.RESOURCE, entity_type=resource_type, entity_state='active', is_deleted=False, sample_timestamp=None, is_placeholder=False, project_id=project_id)
def _create_alarm(vitrage_id, alarm_type): return graph_utils.create_vertex( vitrage_id, entity_id=vitrage_id, entity_category=EntityCategory.ALARM, entity_type=alarm_type, entity_state='active', is_deleted=False, sample_timestamp=utcnow(), is_placeholder=False, )
def test_vitrage_aggregated_state_functionalities(self): # setup state_manager = DatasourceInfoMapper(self.conf) new_vertex1 = create_vertex('12345', vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='ACTIVE') metadata2 = {VProps.VITRAGE_STATE: OperationalResourceState.SUBOPTIMAL} new_vertex2 = create_vertex('23456', vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, metadata=metadata2) metadata3 = {VProps.VITRAGE_STATE: OperationalResourceState.SUBOPTIMAL} new_vertex3 = create_vertex('34567', vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='ACTIVE') graph_vertex3 = create_vertex('34567', vitrage_category=EntityCategory.RESOURCE, vitrage_type=NOVA_INSTANCE_DATASOURCE, entity_state='SUSPENDED', metadata=metadata3) # action state_manager.vitrage_aggregated_state(new_vertex1, None) state_manager.vitrage_aggregated_state(new_vertex2, None) state_manager.vitrage_aggregated_state(new_vertex3, graph_vertex3) # test assertions self.assertEqual('ACTIVE', new_vertex1[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.OK, new_vertex1[VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex2[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex2[VProps.VITRAGE_OPERATIONAL_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex3[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.SUBOPTIMAL, new_vertex3[VProps.VITRAGE_OPERATIONAL_STATE])
def test_vertex_crud(self): g = create_graph('test_vertex_crud') g.add_vertex(v_node) v = g.get_vertex(v_node.vertex_id) self.assertEqual(v_node[VProps.ID], v[VProps.ID], 'vertex properties are saved') self.assertEqual(v_node[VProps.CATEGORY], v[VProps.CATEGORY], 'vertex properties are saved') self.assertEqual(v_node.vertex_id, v.vertex_id, 'vertex vertex_id is saved') # Changing the referenced item updated_v = v updated_v['KUKU'] = 'KUKU' updated_v[VProps.CATEGORY] = 'CHANGED' # Get it again v = g.get_vertex(v_node.vertex_id) self.assertIsNone(v.get('KUKU', None), 'Change should not affect graph item') self.assertFalse(v.get(EProps.IS_DELETED, None), 'Change should not affect graph item') self.assertEqual(v_node[VProps.CATEGORY], v[VProps.CATEGORY], 'Change should not affect graph item') # Update the graph item and see changes take place g.update_vertex(updated_v) # Get it again v = g.get_vertex(v_node.vertex_id) self.assertEqual(updated_v['KUKU'], v['KUKU'], 'Graph item should change after update') self.assertEqual(updated_v[VProps.CATEGORY], v[VProps.CATEGORY], 'Graph item should change after update') # check metadata another_vertex = utils.create_vertex( vertex_id='123', entity_id='456', entity_category=INSTANCE, metadata={'some_meta': 'DATA'} ) g.add_vertex(another_vertex) v = g.get_vertex(another_vertex.vertex_id) self.assertEqual(another_vertex[VProps.ID], v[VProps.ID], 'vertex properties are saved') self.assertEqual(another_vertex[VProps.CATEGORY], v[VProps.CATEGORY], 'vertex properties are saved') self.assertEqual('DATA', v['some_meta'], 'vertex properties are saved') self.assertEqual(another_vertex.vertex_id, v.vertex_id, 'vertex vertex_id is saved') # Remove the item g.remove_vertex(another_vertex) self.assertEqual(1, len(g), 'graph __len__ after remove vertex') v = g.get_vertex(another_vertex.vertex_id) self.assertIsNone(v, 'removed vertex not in graph')
def create_placeholder_vertex(self, host_name, timestamp): key_fields = self._key_values([host_name]) return graph_utils.create_vertex( base.build_key(key_fields), entity_id=host_name, entity_category=EntityTypes.RESOURCE, entity_type=self.HOST_TYPE, update_timestamp=timestamp, is_placeholder=True )
def create_cluster_placeholder_vertex(): key = build_key([cons.EntityCategory.RESOURCE, OPENSTACK_CLUSTER]) metadata = {cons.VertexProperties.NAME: OPENSTACK_CLUSTER} return graph_utils.create_vertex( key, entity_id=OPENSTACK_CLUSTER, entity_category=cons.EntityCategory.RESOURCE, entity_type=OPENSTACK_CLUSTER, entity_state=AVAILABLE, metadata=metadata)
def _create_resource(vitrage_id, resource_type, project_id=None): return graph_utils.create_vertex( vitrage_id, entity_id=vitrage_id, entity_category=EntityCategory.RESOURCE, entity_type=resource_type, entity_state='active', is_deleted=False, sample_timestamp=None, is_placeholder=False, project_id=project_id )
def create_placeholder_vertex(self, instance_id, timestamp): key_fields = self._key_values([instance_id]) return graph_utils.create_vertex( base.build_key(key_fields), entity_id=instance_id, entity_category=EntityTypes.RESOURCE, entity_type=self.INSTANCE_TYPE, update_timestamp=timestamp, is_placeholder=True )
def create_node_placeholder_vertex(): key = build_key([cons.EntityTypes.RESOURCE, NODE_SUBTYPE]) metadata = { cons.VertexProperties.NAME: NODE_SUBTYPE } return graph_utils.create_vertex( key, entity_category=cons.EntityTypes.RESOURCE, entity_type=NODE_SUBTYPE, metadata=metadata )
def _create_vertex(self, entity_event): metadata = { VProps.NAME: get_label(entity_event, PAlertLabels.ALERT_NAME), VProps.SEVERITY: get_label(entity_event, PAlertLabels.SEVERITY), PProps.STATUS: entity_event.get(PProps.STATUS), } return graph_utils.create_vertex( self._create_entity_key(entity_event), vitrage_category=ECategory.ALARM, vitrage_type=entity_event[DSProps.ENTITY_TYPE], vitrage_sample_timestamp=entity_event[DSProps.SAMPLE_DATE], entity_state=self._get_alarm_state(entity_event), update_timestamp=get_alarm_update_time(entity_event), metadata=metadata)
def add_connected_vertex(graph, entity_type, entity_subtype, entity_id, edge_type, other_vertex, reverse=False): vertex = graph_utils.create_vertex( vitrage_id=entity_subtype + str(entity_id), entity_id=entity_id, entity_category=entity_type, entity_type=entity_subtype) edge = graph_utils.create_edge( source_id=other_vertex.vertex_id if reverse else vertex.vertex_id, target_id=vertex.vertex_id if reverse else other_vertex.vertex_id, relationship_type=edge_type) graph.add_vertex(vertex) graph.add_edge(edge) return vertex
def add_connected_vertex(graph, entity_type, entity_subtype, entity_id, edge_type, other_vertex, reverse=False): vertex = graph_utils.create_vertex( vertex_id=entity_subtype + str(entity_id), entity_id=entity_id, entity_category=entity_type, entity_type=entity_subtype) edge = graph_utils.create_edge( source_id=other_vertex.vertex_id if reverse else vertex.vertex_id, target_id=vertex.vertex_id if reverse else other_vertex.vertex_id, relationship_type=edge_type) graph.add_vertex(vertex) graph.add_edge(edge) return vertex
def create_cluster_placeholder_vertex(): key = build_key([cons.EntityCategory.RESOURCE, OPENSTACK_CLUSTER]) metadata = { cons.VertexProperties.NAME: OPENSTACK_CLUSTER } return graph_utils.create_vertex( key, entity_id=OPENSTACK_CLUSTER, entity_category=cons.EntityCategory.RESOURCE, entity_type=OPENSTACK_CLUSTER, entity_state=AVAILABLE, metadata=metadata )
def _create_vertex(self, entity_event, host_name): metadata = {VProps.NAME: host_name} entity_key = self._create_entity_key(entity_event) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp(None, sample_timestamp) return graph_utils.create_vertex( entity_key, entity_id=host_name, entity_category=EntityCategory.RESOURCE, entity_type=NOVA_HOST_DATASOURCE, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def test_vitrage_aggregated_value_datasource_not_exists(self): # setup info_mapper = DatasourceInfoMapper(self.conf) metadata = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex = create_vertex('12345', vitrage_category=EntityCategory.RESOURCE, vitrage_type='NON EXISTING DATASOURCE', entity_state='ACTIVE', metadata=metadata) # action info_mapper.vitrage_aggregate_values(new_vertex, None) # test assertions self.assertEqual('ACTIVE', new_vertex[VProps.VITRAGE_AGGREGATED_STATE]) self.assertEqual(OperationalResourceState.OK, new_vertex[VProps.VITRAGE_OPERATIONAL_STATE])
def create_placeholder_vertex(self, **kwargs): if VProps.TYPE not in kwargs: LOG.error("Can't create placeholder vertex. Missing property TYPE") raise ValueError('Missing property TYPE') if VProps.ID not in kwargs: LOG.error("Can't create placeholder vertex. Missing property ID") raise ValueError('Missing property ID') key_fields = self._key_values(kwargs[VProps.TYPE], kwargs[VProps.ID]) return graph_utils.create_vertex( tbase.build_key(key_fields), entity_id=kwargs[VProps.ID], entity_category=EntityCategory.RESOURCE, entity_type=kwargs[VProps.TYPE], sample_timestamp=kwargs[VProps.SAMPLE_TIMESTAMP], is_placeholder=True)
def _create_vertex(self, entity_event): entity_type = entity_event[VProps.TYPE] entity_id = entity_event[VProps.ID] sample_timestamp = entity_event[DSProps.SAMPLE_DATE] update_timestamp = self._format_update_timestamp( update_timestamp=None, sample_timestamp=sample_timestamp) state = entity_event[VProps.STATE] entity_key = self._create_entity_key(entity_event) return graph_utils.create_vertex( entity_key, entity_id=entity_id, entity_category=EntityCategory.RESOURCE, entity_type=entity_type, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, entity_state=state)
def test_aggregated_state_datasource_not_exists(self): # setup state_manager = DatasourceInfoMapper(self.conf) metadata = {VProps.VITRAGE_STATE: 'SUSPENDED'} new_vertex = create_vertex('12345', entity_state='ACTIVE', entity_category=EntityCategory.RESOURCE, entity_type='NON EXISTING DATASOURCE', metadata=metadata) # action state_manager.aggregated_state(new_vertex, None) # test assertions self.assertEqual(DatasourceInfoMapper.UNDEFINED_DATASOURCE, new_vertex[VProps.AGGREGATED_STATE]) self.assertEqual(DatasourceInfoMapper.UNDEFINED_DATASOURCE, new_vertex[VProps.OPERATIONAL_STATE])
def _create_vertex(self, entity_event, volume_name, volume_id, volume_state, update_timestamp): metadata = { VProps.NAME: volume_name } entity_key = self._create_entity_key(entity_event) sample_timestamp = entity_event[DSProps.SAMPLE_DATE] return graph_utils.create_vertex( entity_key, entity_id=volume_id, entity_category=EntityCategory.RESOURCE, entity_type=CINDER_VOLUME_DATASOURCE, entity_state=volume_state, sample_timestamp=sample_timestamp, update_timestamp=update_timestamp, metadata=metadata)
def _create_host_neighbor(self, zone_id, host_name, host_state, timestamp): host_transformer = self.transformers['nova.host'] host_vertex = graph_utils.create_vertex( base.build_key(host_transformer._key_values([host_name])), entity_id=host_name, entity_category=EntityTypes.RESOURCE, entity_type=self.ZONE_TYPE, entity_state=host_state, update_timestamp=timestamp, ) relation_edge = graph_utils.create_edge( source_id=zone_id, target_id=host_vertex.vertex_id, relationship_type=EdgeLabels.CONTAINS ) return base.Neighbor(host_vertex, relation_edge)
def _create_vertex(self, event): event_type = event[EVALUATOR_EVENT_TYPE] update_timestamp = transformer_base.convert_timestamp_format( '%Y-%m-%d %H:%M:%S.%f', event[VProps.UPDATE_TIMESTAMP] ) if event_type == UPDATE_VERTEX: properties = { VProps.UPDATE_TIMESTAMP: update_timestamp, VProps.SAMPLE_TIMESTAMP: event[VProps.SAMPLE_TIMESTAMP], VProps.IS_PLACEHOLDER: False, VProps.RESOURCE_ID: event.get(TFields.TARGET) } if VProps.VITRAGE_STATE in event: properties[VProps.VITRAGE_STATE] = \ event.get(VProps.VITRAGE_STATE) if VProps.IS_MARKED_DOWN in event: properties[VProps.IS_MARKED_DOWN] = \ event.get(VProps.IS_MARKED_DOWN) return Vertex(event[VProps.VITRAGE_ID], properties) if event_type in [ADD_VERTEX, REMOVE_VERTEX]: metadata = { VProps.NAME: event[TFields.ALARM_NAME], VProps.SEVERITY: event[TFields.SEVERITY], VProps.STATE: event[VProps.STATE], VProps.RESOURCE_ID: event.get(TFields.TARGET) } return graph_utils.create_vertex( self._create_entity_key(event), entity_category=EntityCategory.ALARM, entity_type=VITRAGE_TYPE, sample_timestamp=event[VProps.SAMPLE_TIMESTAMP], update_timestamp=update_timestamp, metadata=metadata) return None
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_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 )