def test_update_transform(self):
LOG.debug('Aodh update alarm transformer test:'
'transform entity event update')
# Test setup
spec_list = \
mock_sync.simple_aodh_update_alarm_generators(alarm_num=5,
update_events=5)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
# convert neighbor from dict to vertex object
neighbors = event[TransformerBase.QUERY_RESULT]
vertices = []
for neighbor in neighbors:
neighbor_vertex = self._convert_dist_to_vertex(neighbor)
vertices.append(
self.transformers[AODH_DATASOURCE].update_uuid_in_vertex(
neighbor_vertex))
event[TransformerBase.QUERY_RESULT] = vertices
# Test action
wrapper = self.transformers[AODH_DATASOURCE].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_aodh_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_neighbors(neighbors, vertex.vertex_id, event)
self._validate_action(event, wrapper)
def test_snapshot_transform(self):
LOG.debug('Ceilometer alarm transformer test: '
'transform entity event snapshot')
# Test setup
spec_list = mock_sync.simple_aodh_alarm_generators(alarm_num=3,
snapshot_events=3)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
# convert neighbor from dict to vertex object
neighbors = event[TransformerBase.QUERY_RESULT]
vertices = []
for neighbor in neighbors:
neighbor_vertex = self._convert_dist_to_vertex(neighbor)
vertices.append(self.transformers[CEILOMETER_DATASOURCE].
update_uuid_in_vertex(neighbor_vertex))
event[TransformerBase.QUERY_RESULT] = vertices
# Test action
wrapper = self.transformers[CEILOMETER_DATASOURCE].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_aodh_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertThat(neighbors, matchers.HasLength(1))
self._validate_neighbors(neighbors, vertex.vertex_id, event)
self._validate_action(event, wrapper)
def test_snapshot_transform(self):
LOG.debug('Aodh alarm transformer test: transform entity event '
'snapshot')
# Test setup
spec_list = mock_sync.simple_aodh_alarm_generators(alarm_num=3,
snapshot_events=3)
static_events = mock_sync.generate_random_events_list(spec_list)
for event in static_events:
# convert neighbor from dict to vertex object
neighbors = event[TransformerBase.QUERY_RESULT]
vertices = []
for neighbor in neighbors:
vertices.append(self._convert_dist_to_vertex(neighbor))
event[TransformerBase.QUERY_RESULT] = vertices
# Test action
wrapper = self.transformers[AODH_DATASOURCE].transform(event)
# Test assertions
vertex = wrapper.vertex
self._validate_aodh_vertex_props(vertex, event)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
self._validate_neighbors(neighbors, vertex.vertex_id, event)
self._validate_action(event, wrapper)
def _generate_event(time, hostname, severity):
update_vals = {
CProps.HOST: hostname,
CProps.SEVERITY: severity,
CProps.TIME: time,
DSProps.SAMPLE_DATE: format_unix_timestamp(time),
CProps.RESOURCE_NAME: hostname
}
generators = mock_transformer.simple_collectd_alarm_generators(
update_vals=update_vals)
return mock_transformer.generate_random_events_list(generators)[0]
def _generate_event(time, hostname, status):
details = {}
if hostname:
details[DoctorDetails.HOSTNAME] = hostname
if status:
details[DoctorDetails.STATUS] = status
update_vals = {EventProps.DETAILS: details}
if time:
update_vals[EventProps.TIME] = time
update_vals[DoctorProps.UPDATE_TIME] = time
generators = mock_transformer.simple_doctor_alarm_generators(
update_vals=update_vals)
return mock_transformer.generate_random_events_list(generators)[0]
def _create_collectd_event(time, resource_type, resource_name, host_name,
severity, message):
update_vals = {
CProps.TIME: time,
DSProps.SAMPLE_DATE: format_unix_timestamp(time),
CProps.HOST: host_name,
CProps.RESOURCE_TYPE: resource_type,
CProps.RESOURCE_NAME: resource_name,
CProps.MESSAGE: message,
CProps.SEVERITY: severity
}
spec_list = mock_transformer.simple_collectd_alarm_generators(
update_vals=update_vals)
static_events = mock_transformer.generate_random_events_list(spec_list)
return static_events[0]
def _generate_event(hostname):
# fake query result to be used by the transformer for determining
# the neighbor
query_result = [{
VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE,
VProps.ID: hostname
}]
labels = {PLabels.SEVERITY: 'critical', PLabels.INSTANCE: hostname}
update_vals = {
TransformerBase.QUERY_RESULT: query_result,
PProps.LABELS: labels
}
generators = mock_transformer.simple_prometheus_alarm_generators(
update_vals=update_vals)
return mock_transformer.generate_random_events_list(generators)[0]
def _generate_event(time, hostname, severity):
# fake query result to be used by the transformer for determining
# the neighbor
query_result = [{VProps.VITRAGE_TYPE: NOVA_HOST_DATASOURCE,
VProps.ID: hostname}]
update_vals = {CProps.HOST: hostname,
CProps.SEVERITY: severity,
CProps.TIME: time,
DSProps.SAMPLE_DATE: format_unix_timestamp(time),
CProps.RESOURCE_NAME: hostname,
TransformerBase.QUERY_RESULT: query_result}
generators = mock_transformer.simple_collectd_alarm_generators(
update_vals=update_vals)
return mock_transformer.generate_random_events_list(generators)[0]
def test_ceilometer_alarms_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertThat(
processor.entity_graph,
matchers.HasLength(self._num_total_expected_vertices()))
detail = {
TransformerBase.QUERY_RESULT: '',
DSProp.ENTITY_TYPE: CEILOMETER_DATASOURCE
}
spec_list = \
mock_transformer.simple_aodh_alarm_generators(alarm_num=1,
snapshot_events=1,
snap_vals=detail)
static_events = mock_transformer.generate_random_events_list(spec_list)
aodh_event = static_events[0]
aodh_event[CeilProps.RESOURCE_ID] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
# Action
processor.process_event(aodh_event)
# Test assertions
self.assertThat(
processor.entity_graph,
matchers.HasLength(self._num_total_expected_vertices() + 1))
aodh_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: CEILOMETER_DATASOURCE
})
self.assertThat(aodh_vertices, matchers.HasLength(1))
aodh_neighbors = processor.entity_graph.neighbors(
aodh_vertices[0].vertex_id)
self.assertThat(aodh_neighbors, matchers.HasLength(1))
self.assertEqual(NOVA_HOST_DATASOURCE,
aodh_neighbors[0][VProps.VITRAGE_TYPE])
def test_aodh_alarms_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf, uuid=True)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
detail = {TransformerBase.QUERY_RESULT: ''}
spec_list = \
mock_transformer.simple_aodh_alarm_generators(alarm_num=1,
snapshot_events=1,
snap_vals=detail)
static_events = mock_transformer.generate_random_events_list(spec_list)
aodh_event = static_events[0]
aodh_event[AodhProps.RESOURCE_ID] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
# Action
processor.process_event(aodh_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
aodh_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: AODH_DATASOURCE
})
self.assertEqual(1, len(aodh_vertices))
aodh_neighbors = processor.entity_graph.neighbors(
aodh_vertices[0].vertex_id)
self.assertEqual(1, len(aodh_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
aodh_neighbors[0][VProps.TYPE])
def test_aodh_alarms_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
detail = {TransformerBase.QUERY_RESULT: ''}
spec_list = \
mock_transformer.simple_aodh_alarm_generators(alarm_num=1,
snapshot_events=1,
snap_vals=detail)
static_events = mock_transformer.generate_random_events_list(spec_list)
aodh_event = static_events[0]
aodh_event[AodhProps.RESOURCE_ID] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
# Action
processor.process_event(aodh_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
aodh_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: AODH_DATASOURCE
})
self.assertEqual(1, len(aodh_vertices))
aodh_neighbors = processor.entity_graph.neighbors(
aodh_vertices[0].vertex_id)
self.assertEqual(1, len(aodh_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
aodh_neighbors[0][VProps.TYPE])
def _generate_event(update_vals):
generators = mock_transformer.simple_kapacitor_alarm_generators(
update_vals=update_vals)
return mock_transformer.generate_random_events_list(generators)[0]
