def test_fmtd_sub_expr(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.fmtd_sub_expr_str for x in sub_exprs], [
'MAX(cpu.idle_perc{hostname=fred}) <= 3.0 times 4',
'AVG(CPU.PERCENT{}) < 5.0', 'MIN(cpu.percent{}) gte 3.0'
])
def test_should_create(self):
expression = ('AVG(hpcs.compute{flavor_id=777, image_id=888,'
' metric_name=cpu}) > 10')
description = ''
match_by = ['flavor_id', 'image_id']
sub_expr_list = (
alarm_expr_parser.AlarmExprParser(expression).sub_expr_list)
alarm_actions = ['29387234', '77778687']
alarmA_id = self.repo.create_alarm_definition(
'555', '90% CPU', expression, sub_expr_list, description, 'LOW',
match_by, alarm_actions, None, None)
alarmB = self.repo.get_alarm_definition('555', alarmA_id)
self.assertEqual(alarmA_id, alarmB['id'])
query_sad = (select([self.sad.c.id]).select_from(
self.sad).where(self.sad.c.alarm_definition_id == alarmA_id))
query_sadd = (select([func.count()]).select_from(self.sadd).where(
self.sadd.c.sub_alarm_definition_id == bindparam('id')))
with self.engine.connect() as conn:
count_sad = conn.execute(query_sad).fetchall()
self.assertEqual(len(count_sad), 1)
count_sadd = conn.execute(query_sadd,
id=count_sad[0][0]).fetchone()
self.assertEqual(count_sadd[0], 3)
def test_build_expression_all_parameters(self):
expression = 'avg(darth.vader{over=9000}, deterministic, 60) GT 10.0 times 1'
sub_expr_list = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
sub_alarm_d = sub_alarm_definition.SubAlarmDefinition(sub_expr=sub_expr_list[0])
self.assertEqual(expression, sub_alarm_d.expression)
sub_alarm_d.dimensions_str = None
sub_alarm_d.dimensions = None
sub_alarm_d.deterministic = False
sub_alarm_d.period = None
sub_alarm_d.periods = None
self.assertEqual('avg(darth.vader) GT 10.0', sub_alarm_d.expression)
def test_init_from_both_row_and_sub_expr(self):
sub_alarm_d_dict = {'id': '111',
'alarm_definition_id': '123',
'function': 'AVG',
'metric_name': 'darth.vader',
'operator': 'GT',
'threshold': 10,
'period': 60,
'periods': 1,
'is_deterministic': 0,
'dimensions': 'device=1,image_id=888'}
expression = 'avg(darth.vader.compute{device=1,image_id=888}, 60) GT 10.0 times 1'
sub_expr_list = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertRaises(Exception, sub_alarm_definition.SubAlarmDefinition,
sub_alarm_d_dict, sub_expr_list) # noqa: E202
def test_should_try_to_create_with_wrong_alarm_action(self):
expression = ('AVG(hpcs.compute{flavor_id=777, image_id=888,'
' metric_name=cpu}) > 10')
description = ''
match_by = ['flavor_id', 'image_id']
sub_expr_list = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
alarm_actions = ['66666666']
args = ('555',
'90% CPU',
expression,
sub_expr_list,
description,
'LOW',
match_by,
alarm_actions,
None,
None)
self.assertRaises(exceptions.InvalidUpdateException,
self.repo.create_alarm_definition, *args)
def test_init_from_sub_expr(self):
sub_alarm_d_dict = {'function': 'AVG',
'metric_name': 'darth.vader',
'operator': 'GT',
'threshold': 10.0,
'period': 60,
'periods': 1,
'is_deterministic': 0,
'dimensions': 'device=1,image_id=888'}
dimension_dict = {'device': '1',
'image_id': '888'}
expression = 'avg(darth.vader{device=1,image_id=888}, 60) GT 10.0 times 1'
sub_expr_list = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
sub_alarm_d = sub_alarm_definition.SubAlarmDefinition(sub_expr=sub_expr_list[0])
self.assertEqual(sub_alarm_d_dict['metric_name'], sub_alarm_d.metric_name)
self.assertEqual(sub_alarm_d_dict['dimensions'], sub_alarm_d.dimensions_str)
self.assertEqual(dimension_dict, sub_alarm_d.dimensions)
self.assertEqual(sub_alarm_d_dict['function'], sub_alarm_d.function)
self.assertEqual(sub_alarm_d_dict['operator'], sub_alarm_d.operator)
self.assertEqual(sub_alarm_d_dict['period'], sub_alarm_d.period)
self.assertEqual(sub_alarm_d_dict['periods'], sub_alarm_d.periods)
self.assertEqual(sub_alarm_d_dict['threshold'], sub_alarm_d.threshold)
self.assertEqual(False, sub_alarm_d.deterministic)
def test_dimensions_as_list(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
print([x.dimensions_as_list for x in sub_exprs].__str__())
self.assertEqual([x.dimensions_as_list for x in sub_exprs].__str__(),
"[(['hostname=fred'], {}), [], []]")
def _ensure_parse_fails(self, expression):
parser = alarm_expr_parser.AlarmExprParser(expression)
self.assertRaises(
(pyparsing.ParseException, pyparsing.ParseFatalException), getattr,
parser, "sub_expr_list")
def test_good_expression(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual(1, len(sub_exprs))
def test_normalized_operator(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.normalized_operator for x in sub_exprs],
['LTE', 'LT', 'GTE'])
def test_id(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.id for x in sub_exprs], [None, None, None])
def test_threshold(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.threshold for x in sub_exprs], [3.0, 5.0, 3.0])
def test_periods(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.periods for x in sub_exprs], [4, 1, 1])
def test_should_update(self):
expression = ''.join([
'AVG(hpcs.compute{flavor_id=777, image_id=888,',
' metric_name=mem}) > 20 and', ' AVG(hpcs.compute) < 100'
])
description = ''
match_by = ['flavor_id', 'image_id']
sub_expr_list = (
alarm_expr_parser.AlarmExprParser(expression).sub_expr_list)
alarm_actions = ['29387234', '77778687']
self.repo.update_or_patch_alarm_definition('bob', '234', '90% CPU',
expression, sub_expr_list,
False, description,
alarm_actions, None, None,
match_by, 'LOW')
alarm = self.repo.get_alarm_definition('bob', '234')
expected = {
'actions_enabled':
False,
'alarm_actions':
'29387234,77778687',
'description':
'',
'expression':
'AVG(hpcs.compute{flavor_id=777, '
'image_id=888, metric_name=mem}) > 20 and'
' AVG(hpcs.compute) < 100',
'id':
'234',
'match_by':
'flavor_id,image_id',
'name':
'90% CPU',
'ok_actions':
None,
'severity':
'LOW',
'undetermined_actions':
None
}
self.assertEqual(alarm, expected)
sub_alarms = self.repo.get_sub_alarm_definitions('234')
expected = [{
'alarm_definition_id': '234',
'dimensions': 'flavor_id=777,image_id=888,'
'metric_name=mem',
'function': 'AVG',
'id': '222',
'metric_name': 'hpcs.compute',
'operator': 'GT',
'period': 60,
'periods': 1,
'is_deterministic': False,
'threshold': 20.0
}, {
'alarm_definition_id': '234',
'dimensions': None,
'function': 'AVG',
'id': '223',
'metric_name': 'hpcs.compute',
'operator': 'LT',
'period': 60,
'periods': 1,
'is_deterministic': False,
'threshold': 100.0
}]
self.assertEqual(len(sub_alarms), len(expected))
for s, e in zip(sub_alarms, expected):
e['created_at'] = s['created_at']
e['updated_at'] = s['updated_at']
self.assertEqual(sub_alarms, expected)
am = self.repo.get_alarm_metrics('bob', '234')
self.assertEqual(am, [])
sub_alarms = self.repo.get_sub_alarms('bob', '234')
self.assertEqual(sub_alarms, [])
ads = self.repo.get_alarm_definitions('bob', '90% CPU',
{'image_id': '888'}, None, None,
0, 100)
expected = [{
'actions_enabled': False,
'alarm_actions': '29387234,77778687',
'description': None,
'expression': 'AVG(hpcs.compute{flavor_id=777, '
'image_id=888, metric_name=cpu, device=1}) > 10',
'id': '123',
'match_by': 'flavor_id,image_id',
'name': '90% CPU',
'ok_actions': None,
'severity': 'LOW',
'undetermined_actions': None
}, {
'actions_enabled':
False,
'alarm_actions':
'29387234,77778687',
'description':
'',
'expression':
'AVG(hpcs.compute{flavor_id=777, '
'image_id=888, metric_name=mem}) > 20 and'
' AVG(hpcs.compute) < 100',
'id':
'234',
'match_by':
'flavor_id,image_id',
'name':
'90% CPU',
'ok_actions':
None,
'severity':
'LOW',
'undetermined_actions':
None
}]
self.assertEqual(ads, expected)
ads = self.repo.get_alarm_definitions('bob', '90% CPU',
{'image_id': '888'}, 'LOW', None,
0, 100)
expected = [{
'actions_enabled': False,
'alarm_actions': '29387234,77778687',
'description': None,
'expression': 'AVG(hpcs.compute{flavor_id=777, '
'image_id=888, metric_name=cpu, device=1}) > 10',
'id': '123',
'match_by': 'flavor_id,image_id',
'name': '90% CPU',
'ok_actions': None,
'severity': 'LOW',
'undetermined_actions': None
}, {
'actions_enabled':
False,
'alarm_actions':
'29387234,77778687',
'description':
'',
'expression':
'AVG(hpcs.compute{flavor_id=777, '
'image_id=888, metric_name=mem}) > 20 and'
' AVG(hpcs.compute) < 100',
'id':
'234',
'match_by':
'flavor_id,image_id',
'name':
'90% CPU',
'ok_actions':
None,
'severity':
'LOW',
'undetermined_actions':
None
}]
self.assertEqual(ads, expected)
ads = self.repo.get_alarm_definitions('bob', '90% CPU',
{'image_id': '888'}, 'CRITICAL',
None, 0, 100)
expected = []
self.assertEqual(ads, expected)
self.repo.update_or_patch_alarm_definition('bob', '234', '90% CPU',
None, sub_expr_list, False,
description, alarm_actions,
None, None, match_by, 'LOW')
self.repo.update_or_patch_alarm_definition('bob', '234', None, None,
None, True, None, None,
None, None, None, None,
True)
self.repo.update_or_patch_alarm_definition('bob', '234', None, None,
None, None, None, None,
None, None, None, None,
True)
self.repo.update_or_patch_alarm_definition('bob', '234', None, None,
None, None, None, [], [],
[], None, None, True)
self.repo.update_or_patch_alarm_definition('bob', '234', None, None,
None, False, None, None,
None, None, match_by, None,
False)
self.assertRaises(exceptions.InvalidUpdateException,
self.repo.update_or_patch_alarm_definition, 'bob',
'234', None, None, None, False, None, None, None,
None, None, None, False)
self.assertRaises(exceptions.InvalidUpdateException,
self.repo.update_or_patch_alarm_definition, 'bob',
'234', '90% CPU', None, sub_expr_list, False,
description, alarm_actions, None, None,
'update_match_by', 'LOW')
self.repo.delete_alarm_definition('bob', '234')
self.assertRaises(exceptions.DoesNotExistException,
self.repo.get_alarm_definition, 'bob', '234')
def test_deterministic(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.deterministic for x in sub_exprs],
[False, False, True])
def test_dimensions(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.dimensions for x in sub_exprs],
['hostname=fred', '', ''])
def test_normalized_metric_name(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.normalized_metric_name for x in sub_exprs],
['cpu.idle_perc', 'cpu.percent', 'cpu.percent'])
def test_normalized_function(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.normalized_func for x in sub_exprs],
['MAX', 'AVG', 'MIN'])
def test_function(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.func for x in sub_exprs], ['max', 'avg', 'min'])
def test_set_id(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
for x in sub_exprs:
x.id = 88
self.assertEqual([x.id for x in sub_exprs], [88, 88, 88])
def run_patch_test(self,
name=None,
expression=None,
description=None,
actions_enabled=None,
alarm_actions=None,
ok_actions=None,
undetermined_actions=None,
match_by=None,
severity=None):
if expression:
sub_expr_list = (
alarm_expr_parser.AlarmExprParser(expression).sub_expr_list)
else:
sub_expr_list = None
updates = self.repo.update_or_patch_alarm_definition(
TENANT_ID,
'123',
name,
expression,
sub_expr_list,
actions_enabled,
description,
alarm_actions,
ok_actions,
undetermined_actions,
match_by,
severity,
patch=True)
alarm_def_row = (
ALARM_DEF_123_FIELDS['id'],
name if name else ALARM_DEF_123_FIELDS['name'],
description
if description else ALARM_DEF_123_FIELDS['description'],
expression if expression else ALARM_DEF_123_FIELDS['expression'],
ALARM_DEF_123_FIELDS['match_by'], # match-by can't change
severity if severity else ALARM_DEF_123_FIELDS['severity'],
actions_enabled
if actions_enabled else ALARM_DEF_123_FIELDS['actions_enabled'],
u','.join(alarm_actions)
if alarm_actions else ALARM_DEF_123_FIELDS['alarm_actions'],
u','.join(ok_actions)
if ok_actions else ALARM_DEF_123_FIELDS['ok_actions'],
(u','.join(undetermined_actions) if undetermined_actions else
ALARM_DEF_123_FIELDS['undetermined_actions']))
sad = self.default_sads[0]
if expression and ALARM_DEF_123_FIELDS['expression'] != expression:
sub_expr = sub_expr_list[0]
sub_alarm_def = sub_alarm_definition.SubAlarmDefinition(
row={
'id': '',
'alarm_definition_id': sad['alarm_definition_id'],
'function': sub_expr.normalized_func,
'metric_name': sub_expr.metric_name,
'dimensions':
u'device=1,image_id=888,flavor_id=777,metric_name=cpu',
'operator': sub_expr.normalized_operator,
'threshold': sub_expr.threshold,
'period': sub_expr.period,
'is_deterministic': sub_expr.deterministic,
'periods': sub_expr.periods
})
expected_sub_alarm_maps = {
'changed': {
u'111': sub_alarm_def
},
'new': {},
'old': {},
'unchanged': {}
}
else:
sub_alarm_def = sub_alarm_definition.SubAlarmDefinition(
row={
'id': sad['id'],
'alarm_definition_id': sad['alarm_definition_id'],
'function': sad['function'],
'metric_name': sad['metric_name'],
'dimensions':
u'device=1,image_id=888,flavor_id=777,metric_name=cpu',
'operator': sad['operator'],
'threshold': sad['threshold'],
'period': sad['period'],
'is_deterministic': sad['is_deterministic'],
'periods': sad['periods']
})
expected_sub_alarm_maps = {
'changed': {},
'new': {},
'old': {},
'unchanged': {
u'111': sub_alarm_def
}
}
self.assertEqual((alarm_def_row, expected_sub_alarm_maps), updates)
def test_operator(self):
expression = self.good_simple_expression
sub_exprs = alarm_expr_parser.AlarmExprParser(expression).sub_expr_list
self.assertEqual([x.operator for x in sub_exprs], ['<=', '<', 'gte'])
