def test_overlapping_deduced_alarm_1(self):
event_queue, processor, evaluator = self._init_system()
# generate WARNING nagios alarm
vals = {'status': 'WARNING', 'service': 'cause_warning_deduced_alarm'}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# generate CRITICAL nagios alarm to trigger
vals = {'status': 'CRITICAL',
'service': 'cause_critical_deduced_alarm'}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
critical_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(2, len(causes))
# remove WARNING nagios alarm, leaving only CRITICAL one
warning_test['status'] = 'OK'
warning_test[DSProps.EVENT_TYPE] = GraphAction.DELETE_ENTITY
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
critical_test['status'] = 'OK'
critical_test[DSProps.EVENT_TYPE] = GraphAction.DELETE_ENTITY
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_overlapping_deduced_alarm_1(self):
event_queue, processor, evaluator = self._init_system()
# generate WARNING nagios alarm
vals = {'status': 'WARNING', 'service': 'cause_warning_deduced_alarm'}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# generate CRITICAL nagios alarm to trigger
vals = {
'status': 'CRITICAL',
'service': 'cause_critical_deduced_alarm'
}
vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, vals)
critical_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(2, len(causes))
# remove WARNING nagios alarm, leaving only CRITICAL one
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
critical_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_nagios_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf, uuid=True)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_nagios_alarm_generators(host_num=1,
events_num=1)
static_events = mock_driver.generate_random_events_list(spec_list)
nagios_event = static_events[0]
nagios_event['resource_name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
nagios_event['status'] = 'critical'
# Action
processor.process_event(nagios_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
nagios_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: NAGIOS_DATASOURCE
})
self.assertEqual(1, len(nagios_vertices))
nagios_neighbors = processor.entity_graph.neighbors(
nagios_vertices[0].vertex_id)
self.assertEqual(1, len(nagios_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
nagios_neighbors[0][VProps.TYPE])
def test_nagios_alarm_transform(self):
LOG.debug('Nagios alarm transformer test: transform entity event')
# Test setup
spec_list = mock_sync.simple_nagios_alarm_generators(host_num=4,
events_num=10)
nagios_alarms = mock_sync.generate_sequential_events_list(spec_list)
transformer = NagiosTransformer(self.transformers, self.conf)
for alarm in nagios_alarms:
cur_alarm_uuid = None
if alarm.get(NagiosProperties.STATUS) == NagiosTestStatus.OK:
alarm_key = transformer._create_entity_key(alarm)
cur_alarm_uuid = \
TransformerBase.uuid_from_deprecated_vitrage_id(
alarm_key)
# Test action
wrapper = transformer.transform(alarm)
self._validate_vertex(wrapper.vertex, alarm)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
neighbor = neighbors[0]
# Right now we are support only host as a resource
if neighbor.vertex[VProps.VITRAGE_TYPE] == NOVA_HOST_DATASOURCE:
self._validate_host_neighbor(neighbors[0], alarm,
cur_alarm_uuid)
self._validate_action(alarm, wrapper)
def test_deduced_alarm(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate CRITICAL nagios alarm to trigger
test_vals = {
'status': 'WARNING',
'service': 'cause_warning_deduced_alarm'
}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_deduced_state(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate nagios alarm to trigger template scenario
test_vals = {'status': 'WARNING', 'service': 'cause_suboptimal_state'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE],
'host should be SUBOPTIMAL with warning alarm')
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when alarm disabled')
def test_deduced_alarm(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate CRITICAL nagios alarm to trigger
test_vals = {'status': 'WARNING',
'service': 'cause_warning_deduced_alarm'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
causes = self._get_alarm_causes(alarms[0], processor.entity_graph)
self.assertEqual(1, len(causes))
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(0, len(alarms))
def test_deduced_state(self):
event_queue, processor, evaluator = self._init_system()
host_v = self._get_host_from_graph(_TARGET_HOST,
processor.entity_graph)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when starting')
# generate nagios alarm to trigger template scenario
test_vals = {'status': 'WARNING', 'service': 'cause_suboptimal_state'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('SUBOPTIMAL', host_v[VProps.AGGREGATED_STATE],
'host should be SUBOPTIMAL with warning alarm')
# next disable the alarm
warning_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
self.assertEqual('AVAILABLE', host_v[VProps.AGGREGATED_STATE],
'host should be AVAILABLE when alarm disabled')
def _get_alarms(self):
alarms = []
for service_data in self.service_datas:
generators = mock_driver.simple_nagios_alarm_generators(
host_num=1, events_num=1, snap_vals=service_data)
alarms.append(
mock_driver.generate_sequential_events_list(generators)[0])
return alarms
def _get_alarms(self):
alarms = []
for service_data in self.service_datas:
generators = mock_driver.simple_nagios_alarm_generators(
host_num=1,
events_num=1,
snap_vals=service_data)
alarms.append(
mock_driver.generate_sequential_events_list(generators)[0])
return alarms
def test_overlapping_deduced_alarm_2(self):
event_queue, processor, evaluator = self._init_system()
# generate CRITICAL nagios alarm to trigger
test_vals = {'status': 'CRITICAL',
'service': 'cause_critical_deduced_alarm'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
critical_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
# generate WARNING nagios alarm to trigger
test_vals = {'status': 'WARNING',
'service': 'cause_warning_deduced_alarm'}
test_vals.update(_NAGIOS_TEST_INFO)
generator = mock_driver.simple_nagios_alarm_generators(1, 1, test_vals)
warning_test = mock_driver.generate_random_events_list(generator)[0]
host_v = self.get_host_after_event(event_queue, warning_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('CRITICAL', alarms[0]['severity'])
# remove CRITICAL nagios alarm, leaving only WARNING one
critical_test['status'] = 'OK'
host_v = self.get_host_after_event(event_queue, critical_test,
processor, _TARGET_HOST)
alarms = \
self._get_deduced_alarms_on_host(host_v, processor.entity_graph)
self.assertEqual(1, len(alarms))
self.assertEqual('WARNING', alarms[0]['severity'])
def test_nagios_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices())
)
spec_list = mock_driver.simple_nagios_alarm_generators(
host_num=1,
events_num=1)
static_events = mock_driver.generate_random_events_list(spec_list)
nagios_event = static_events[0]
nagios_event['resource_name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
nagios_event['status'] = NagiosTestStatus.CRITICAL
# Action
processor.process_event(nagios_event)
# Test assertions
self.assertThat(processor.entity_graph,
matchers.HasLength(
self._num_total_expected_vertices() + 1)
)
nagios_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.VITRAGE_CATEGORY: EntityCategory.ALARM,
VProps.VITRAGE_TYPE: NAGIOS_DATASOURCE
})
self.assertThat(nagios_vertices, matchers.HasLength(1))
nagios_neighbors = processor.entity_graph.neighbors(
nagios_vertices[0].vertex_id)
self.assertThat(nagios_neighbors, matchers.HasLength(1))
self.assertEqual(NOVA_HOST_DATASOURCE,
nagios_neighbors[0][VProps.VITRAGE_TYPE])
def test_extract_key(self):
LOG.debug('Test get key from nova instance transformer')
# Test setup
spec_list = mock_sync.simple_nagios_alarm_generators(host_num=1,
events_num=1)
nagios_alarms = mock_sync.generate_sequential_events_list(spec_list)
transformer = NagiosTransformer(self.transformers, self.conf)
event = nagios_alarms[0]
# Test action
observed_key = transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.ALARM, observed_key_fields[0])
self.assertEqual(event[DSProps.ENTITY_TYPE], observed_key_fields[1])
self.assertEqual(event[NagiosProperties.RESOURCE_NAME],
observed_key_fields[2])
self.assertEqual(event[NagiosProperties.SERVICE],
observed_key_fields[3])
def test_nagios_alarm_transform(self):
LOG.debug('Nagios alarm transformer test: transform entity event')
# Test setup
spec_list = mock_sync.simple_nagios_alarm_generators(host_num=4,
events_num=10)
nagios_alarms = mock_sync.generate_sequential_events_list(spec_list)
for alarm in nagios_alarms:
# Test action
wrapper = NagiosTransformer(self.transformers).transform(alarm)
self._validate_vertex(wrapper.vertex, alarm)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
neighbor = neighbors[0]
# Right now we are support only host as a resource
if neighbor.vertex[VProps.TYPE] == NOVA_HOST_DATASOURCE:
self._validate_host_neighbor(neighbors[0], alarm)
self._validate_action(alarm, wrapper)
def test_nagios_alarm_transform(self):
LOG.debug('Nagios alarm transformer test: transform entity event')
# Test setup
spec_list = mock_sync.simple_nagios_alarm_generators(host_num=4,
events_num=10)
nagios_alarms = mock_sync.generate_sequential_events_list(spec_list)
for alarm in nagios_alarms:
# Test action
wrapper = NagiosTransformer(self.transformers).transform(alarm)
self._validate_vertex(wrapper.vertex, alarm)
neighbors = wrapper.neighbors
self.assertEqual(1, len(neighbors))
neighbor = neighbors[0]
# Right now we are support only host as a resource
if neighbor.vertex[VProps.TYPE] == NOVA_HOST_DATASOURCE:
self._validate_host_neighbor(neighbors[0], alarm)
self._validate_action(alarm, wrapper)
def test_extract_key(self):
LOG.debug('Test get key from nova instance transformer')
# Test setup
spec_list = mock_sync.simple_nagios_alarm_generators(host_num=1,
events_num=1)
nagios_alarms = mock_sync.generate_sequential_events_list(spec_list)
transformer = NagiosTransformer(self.transformers)
event = nagios_alarms[0]
# Test action
observed_key = transformer._create_entity_key(event)
# Test assertions
observed_key_fields = observed_key.split(
TransformerBase.KEY_SEPARATOR)
self.assertEqual(EntityCategory.ALARM, observed_key_fields[0])
self.assertEqual(event[DSProps.SYNC_TYPE], observed_key_fields[1])
self.assertEqual(event[NagiosProperties.RESOURCE_NAME],
observed_key_fields[2])
self.assertEqual(event[NagiosProperties.SERVICE],
observed_key_fields[3])
def test_nagios_validity(self):
# Setup
processor = self._create_processor_with_graph(self.conf)
self.assertEqual(self._num_total_expected_vertices(),
len(processor.entity_graph))
spec_list = mock_driver.simple_nagios_alarm_generators(
host_num=1,
events_num=1)
static_events = mock_driver.generate_random_events_list(spec_list)
nagios_event = static_events[0]
nagios_event['resource_name'] = \
self._find_entity_id_by_type(processor.entity_graph,
NOVA_HOST_DATASOURCE)
nagios_event['status'] = 'critical'
# Action
processor.process_event(nagios_event)
# Test assertions
self.assertEqual(self._num_total_expected_vertices() + 1,
len(processor.entity_graph))
nagios_vertices = processor.entity_graph.get_vertices(
vertex_attr_filter={
VProps.CATEGORY: EntityCategory.ALARM,
VProps.TYPE: NAGIOS_DATASOURCE
})
self.assertEqual(1, len(nagios_vertices))
nagios_neighbors = processor.entity_graph.neighbors(
nagios_vertices[0].vertex_id)
self.assertEqual(1, len(nagios_neighbors))
self.assertEqual(NOVA_HOST_DATASOURCE,
nagios_neighbors[0][VProps.TYPE])
