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_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_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 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 _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,
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_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_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 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
)
