def state_decrease(manager, alarm, state, event):
"""
Called when the system detects a state decrease on an alarm.
"""
step = {
'_t': 'statedec',
't': event['timestamp'],
'a': event.get("author", DEFAULT_AUTHOR),
'm': event['output'],
'val': state
}
if alarm[AlarmField.state.value] is None or not is_keeped_state(alarm):
alarm[AlarmField.state.value] = step
alarm[AlarmField.steps.value].append(step)
status = compute_status(manager, alarm)
return alarm, status
def state_decrease(manager, alarm, state, event):
"""
Called when the system detects a state decrease on an alarm.
"""
step = {
'_t': 'statedec',
't': event['timestamp'],
'a': event.get("author", DEFAULT_AUTHOR),
'm': event['output'],
'val': state
}
if alarm[AlarmField.state.value] is None or not is_keeped_state(alarm):
alarm[AlarmField.state.value] = step
alarm[AlarmField.steps.value].append(step)
status = compute_status(manager, alarm)
return alarm, status
def state_decrease(manager, alarm, state, event):
"""
Called when the system detects a state decrease on an alarm.
"""
step = {
'_t': 'statedec',
't': event['timestamp'],
'a': '{0}.{1}'.format(event['connector'], event['connector_name']),
'm': event['output'],
'val': state
}
if alarm[AlarmField.state.value] is None or not is_keeped_state(alarm):
alarm[AlarmField.state.value] = step
alarm[AlarmField.steps.value].append(step)
status = compute_status(manager, alarm)
return alarm, status
def test_change_state(self):
event = {
'timestamp': 0,
'state': 2
}
task = get_task('alerts.useraction.changestate')
alarm = task(
self.manager,
self.alarm,
'testauthor',
'test message',
event
)
self.assertTrue(alarm[AlarmField.state.value] is not None)
self.assertEqual(alarm[AlarmField.state.value]['t'], 0)
self.assertEqual(alarm[AlarmField.state.value]['a'], 'testauthor')
self.assertEqual(alarm[AlarmField.state.value]['m'], 'test message')
self.assertEqual(alarm[AlarmField.state.value]['val'], 2)
self.assertTrue(
alarm[AlarmField.state.value] is get_previous_step(alarm, States.changestate.value)
)
self.assertTrue(is_keeped_state(alarm))
def test_archive_state_changed(self):
alarm_id = 'ut-comp'
# Testing state creation
event0 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.MINOR,
}
self.manager.archive(event0)
alarm = self.manager.get_current_alarm(alarm_id)
expected_state = {
'a': DEFAULT_AUTHOR,
'_t': "stateinc",
'm': 'test message',
't': 0,
'role': None,
'val': 1,
}
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 2)
self.assertEqual(alarm['value'][AlarmField.steps.value][0],
expected_state)
self.assertEqual(alarm['value'][AlarmField.state.value],
expected_state)
self.event_publisher.publish_statcounterinc_event.assert_called_once_with(
alarm['value'][AlarmField.last_update_date.value],
StatCounters.alarms_created, {}, alarm['value'], None)
self.event_publisher.publish_statcounterinc_event.reset_mock()
# Testing state increase
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.MAJOR,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
expected_state = {
'a': DEFAULT_AUTHOR,
'_t': 'stateinc',
'm': 'test message',
't': 0,
'role': None,
'val': 2,
}
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 3)
self.assertEqual(alarm['value'][AlarmField.steps.value][2],
expected_state)
self.assertEqual(alarm['value'][AlarmField.state.value],
expected_state)
# Testing keeped state
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': States.changestate.value,
'state': Check.MINOR,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 4)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 1)
self.assertTrue(is_keeped_state(alarm['value']))
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.CRITICAL,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 4)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 1)
self.assertTrue(is_keeped_state(alarm['value']))
# Disengaging keepstate
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.OK,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 6)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 0)
self.assertFalse(is_keeped_state(alarm['value']))
self.event_publisher.publish_statcounterinc_event.assert_not_called()
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output':
'Stop of pbehavior. Name: {}. Type:{}'.format("pb1", "pbt1"),
'event_type': 'pbhleave',
'state': 0,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 7)
self.assertEqual(alarm['value'][AlarmField.steps.value][6]['_t'],
"pbhleave")
self.assertFalse(is_keeped_state(alarm['value']))
self.event_publisher.publish_statcounterinc_event.assert_not_called()
def test_archive_state_changed(self):
alarm_id = 'ut-comp'
# Testing state creation
event0 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.MINOR,
}
self.manager.archive(event0)
alarm = self.manager.get_current_alarm(alarm_id)
expected_state = {
'a': DEFAULT_AUTHOR,
'_t': "stateinc",
'm': 'test message',
't': 0,
'val': 1,
}
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 2)
self.assertEqual(alarm['value'][AlarmField.steps.value][0], expected_state)
self.assertEqual(alarm['value'][AlarmField.state.value], expected_state)
self.event_publisher.publish_statcounterinc_event.assert_called_once_with(
alarm['value'][AlarmField.last_update_date.value],
StatCounters.alarms_created,
{},
alarm['value'],
None)
self.event_publisher.publish_statcounterinc_event.reset_mock()
# Testing state increase
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.MAJOR,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
expected_state = {
'a': DEFAULT_AUTHOR,
'_t': 'stateinc',
'm': 'test message',
't': 0,
'val': 2,
}
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 3)
self.assertEqual(alarm['value'][AlarmField.steps.value][2], expected_state)
self.assertEqual(alarm['value'][AlarmField.state.value], expected_state)
# Testing keeped state
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': States.changestate.value,
'state': Check.MINOR,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 4)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 1)
self.assertTrue(is_keeped_state(alarm['value']))
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.CRITICAL,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 4)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 1)
self.assertTrue(is_keeped_state(alarm['value']))
# Disengaging keepstate
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.OK,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 6)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 0)
self.assertFalse(is_keeped_state(alarm['value']))
self.event_publisher.publish_statcounterinc_event.assert_not_called()
def change_of_state(self, alarm, old_state, state, event):
"""
Change state when ``update_state()`` detected a state change.
:param dict alarm: Associated alarm to state change event
:param int old_state: Previous state
:param int state: New state
:param dict event: Associated event
:return: alarm with changed state
:rtype: dict
"""
storage_value = self.alerts_storage.VALUE
# Check for a forced state on this alarm
if is_keeped_state(alarm['value']):
if state == Check.OK:
# Disengaging 'keepstate' flag
alarm[storage_value][AlarmField.state.value]['_t'] = None
else:
self.logger.info('Entity {} not allowed to change state: '
'ignoring'.format(alarm['data_id']))
return alarm
# Escalation
if state > old_state:
task = get_task('alerts.systemaction.state_increase',
cacheonly=True)
elif state < old_state:
task = get_task('alerts.systemaction.state_decrease',
cacheonly=True)
# Executing task
now = int(time())
value = alarm.get(self.alerts_storage.VALUE)
new_value, status = task(self, value, state, event)
new_value[AlarmField.last_update_date.value] = now
entity_id = alarm[self.alerts_storage.DATA_ID]
try:
entity = self.context_manager.get_entities_by_id(entity_id)[0]
except IndexError:
entity = {}
# Send statistics event
last_state_change = entity.get(Entity.LAST_STATE_CHANGE)
if last_state_change:
self.event_publisher.publish_statstateinterval_event(
now, StatStateIntervals.time_in_state, now - last_state_change,
old_state, entity, new_value)
if state == AlarmState.CRITICAL:
self.event_publisher.publish_statcounterinc_event(
now, StatCounters.downtimes, entity, new_value,
event.get(self.AUTHOR))
# Update entity's last_state_change
if entity:
entity[Entity.LAST_STATE_CHANGE] = now
self.context_manager.update_entity_body(entity)
alarm[storage_value] = new_value
return self.update_status(alarm, status, event)
def test_isnot_keeped_state(self):
self.alarm[AlarmField.state.value] = {}
self.alarm[AlarmField.state.value]['_t'] = None
self.assertFalse(is_keeped_state(self.alarm))
def test_is_keeped_state(self):
self.alarm[AlarmField.state.value] = {}
self.alarm[AlarmField.state.value]['_t'] = States.changestate.value
self.assertTrue(is_keeped_state(self.alarm))
def test_archive_state_changed(self):
alarm_id = 'ut-comp'
# Testing state creation
event0 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.MINOR,
}
self.manager.archive(event0)
alarm = self.manager.get_current_alarm(alarm_id)
expected_state = {
'a': 'test.test0',
'_t': 'stateinc',
'm': 'test message',
't': 0,
'val': 1,
}
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 2)
self.assertEqual(alarm['value'][AlarmField.steps.value][0],
expected_state)
self.assertEqual(alarm['value'][AlarmField.state.value],
expected_state)
self.event_publisher.publish_statcounterinc_event.assert_any_call(
alarm['value'][AlarmField.last_update_date.value],
StatCounters.alarms_created, {}, alarm['value'])
self.event_publisher.publish_statcounterinc_event.assert_any_call(
alarm['value'][AlarmField.last_update_date.value],
StatCounters.alarms_impacting, {}, alarm['value'])
self.assertEqual(
self.event_publisher.publish_statcounterinc_event.call_count, 2)
self.event_publisher.publish_statcounterinc_event.reset_mock()
# Testing state increase
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.MAJOR,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
expected_state = {
'a': 'test.test0',
'_t': 'stateinc',
'm': 'test message',
't': 0,
'val': 2,
}
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 3)
self.assertEqual(alarm['value'][AlarmField.steps.value][2],
expected_state)
self.assertEqual(alarm['value'][AlarmField.state.value],
expected_state)
# Testing keeped state
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': States.changestate.value,
'state': Check.MINOR,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 4)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 1)
self.assertTrue(is_keeped_state(alarm['value']))
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.CRITICAL,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 4)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 1)
self.assertTrue(is_keeped_state(alarm['value']))
# Disengaging keepstate
event1 = {
'source_type': 'component',
'connector': 'test',
'connector_name': 'test0',
'component': 'ut-comp',
'timestamp': 0,
'output': 'test message',
'event_type': 'check',
'state': Check.OK,
}
self.manager.archive(event1)
alarm = self.manager.get_current_alarm(alarm_id)
self.assertEqual(len(alarm['value'][AlarmField.steps.value]), 6)
self.assertEqual(alarm['value'][AlarmField.state.value]['val'], 0)
self.assertFalse(is_keeped_state(alarm['value']))
self.event_publisher.publish_statcounterinc_event.assert_not_called()
def change_of_state(self, alarm, old_state, state, event):
"""
Change state when ``update_state()`` detected a state change.
:param dict alarm: Associated alarm to state change event
:param int old_state: Previous state
:param int state: New state
:param dict event: Associated event
:return: alarm with changed state
:rtype: dict
"""
storage_value = self.alerts_storage.VALUE
# Check for a forced state on this alarm
if is_keeped_state(alarm['value']):
if state == Check.OK:
# Disengaging 'keepstate' flag
alarm[storage_value][AlarmField.state.value]['_t'] = None
else:
self.logger.info('Entity {} not allowed to change state: '
'ignoring'.format(alarm['data_id']))
return alarm
# Escalation
if state > old_state:
task = get_task(
'alerts.systemaction.state_increase', cacheonly=True
)
elif state < old_state:
task = get_task(
'alerts.systemaction.state_decrease', cacheonly=True
)
# Executing task
now = int(time())
value = alarm.get(self.alerts_storage.VALUE)
new_value, status = task(self, value, state, event)
new_value[AlarmField.last_update_date.value] = now
entity_id = alarm[self.alerts_storage.DATA_ID]
try:
entity = self.context_manager.get_entities_by_id(entity_id)[0]
except IndexError:
entity = {}
# Send statistics event
last_state_change = entity.get(Entity.LAST_STATE_CHANGE)
if last_state_change:
self.event_publisher.publish_statstateinterval_event(
now,
StatStateIntervals.time_in_state,
now - last_state_change,
old_state,
entity,
new_value)
if state == AlarmState.CRITICAL:
self.event_publisher.publish_statcounterinc_event(
now,
StatCounters.downtimes,
entity,
new_value,
event.get(self.AUTHOR))
# Update entity's last_state_change
if entity:
entity[Entity.LAST_STATE_CHANGE] = now
self.context_manager.update_entity_body(entity)
alarm[storage_value] = new_value
return self.update_status(alarm, status, event)
