def test_list_alarm_definitions_multiple_sort_by(self):
key = data_utils.rand_name('key')
value = data_utils.rand_name('value')
expression = 'avg(cpu_utilization{' + str(key) + '=' + str(value) + \
'}) >= 1000'
alarm_definitions = [
helpers.create_alarm_definition(name='alarm def sort by 11',
expression=expression,
severity='MEDIUM'),
helpers.create_alarm_definition(name='alarm def sort by 14',
expression=expression,
severity='MEDIUM'),
helpers.create_alarm_definition(name='alarm def sort by 12',
expression=expression,
severity='LOW'),
helpers.create_alarm_definition(name='alarm def sort by 13',
expression=expression,
severity='MEDIUM')
]
for definition in alarm_definitions:
resp, response_body = self.monasca_client.create_alarm_definitions(
definition)
definition['id'] = response_body['id']
resp, response_body = self.monasca_client.list_alarm_definitions(
'?dimensions=' + str(key) + ':' + str(value) + '&sort_by=' +
urlparse.quote('severity asc,name desc,id'))
self.assertEqual(200, resp.status)
expected_order = [2, 1, 3, 0]
for i, element in enumerate(response_body['elements']):
self.assertEqual(alarm_definitions[expected_order[i]]['id'],
element['id'])
def test_list_alarm_definitions_with_severity(self):
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="LOW")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="MEDIUM")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
query_param = '?severity=MEDIUM'
resp, response_body = self.monasca_client.\
list_alarm_definitions(query_param)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_list_get_alarm_definitions_elements(
elements, 1, res_body_create_alarm_def)
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def test_list_alarm_definitions_with_severity(self):
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="LOW")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="MEDIUM")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
query_param = '?severity=MEDIUM'
resp, response_body = self.monasca_client.\
list_alarm_definitions(query_param)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_list_get_alarm_definitions_elements(
elements, 1, res_body_create_alarm_def)
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def test_list_alarms_by_severity(self):
metric_name = data_utils.rand_name("severity-metric")
alarm_defs = []
alarm_defs.append(helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='LOW'
))
alarm_defs.append(helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='MEDIUM'
))
alarm_defs.append(helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='HIGH'
))
alarm_defs.append(helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='CRITICAL'
))
alarm_def_ids = []
for definition in alarm_defs:
resp, response_body = self.monasca_client.create_alarm_definitions(definition)
self.assertEqual(201, resp.status)
alarm_def_ids.append(response_body['id'])
metric = helpers.create_metric(name=metric_name,
value=14)
resp, response_body = self.monasca_client.create_metrics(metric)
self.assertEqual(204, resp.status)
for def_id in alarm_def_ids:
self._wait_for_alarms(1, def_id)
query_parms = '?severity=LOW'
resp, response_body = self.monasca_client.list_alarms(query_parms)
self.assertEqual(200, resp.status)
for alarm in response_body['elements']:
self.assertEqual('LOW', alarm['alarm_definition']['severity'])
query_parms = '?severity=HIGH'
resp, response_body = self.monasca_client.list_alarms(query_parms)
self.assertEqual(200, resp.status)
for alarm in response_body['elements']:
self.assertEqual('HIGH', alarm['alarm_definition']['severity'])
query_parms = '?severity=CRITICAL'
resp, response_body = self.monasca_client.list_alarms(query_parms)
self.assertEqual(200, resp.status)
for alarm in response_body['elements']:
self.assertEqual('CRITICAL', alarm['alarm_definition']['severity'])
def test_list_alarms_by_severity(self):
metric_name = data_utils.rand_name("severity-metric")
alarm_defs = []
alarm_defs.append(
helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='LOW'))
alarm_defs.append(
helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='MEDIUM'))
alarm_defs.append(
helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='HIGH'))
alarm_defs.append(
helpers.create_alarm_definition(
name=data_utils.rand_name("alarm-severity"),
expression=metric_name + " > 12",
severity='CRITICAL'))
alarm_def_ids = []
for definition in alarm_defs:
resp, response_body = self.monasca_client.create_alarm_definitions(
definition)
self.assertEqual(201, resp.status)
alarm_def_ids.append(response_body['id'])
metric = helpers.create_metric(name=metric_name, value=14)
resp, response_body = self.monasca_client.create_metrics(metric)
self.assertEqual(204, resp.status)
for def_id in alarm_def_ids:
self._wait_for_alarms(1, def_id)
query_parms = '?severity=LOW'
resp, response_body = self.monasca_client.list_alarms(query_parms)
self.assertEqual(200, resp.status)
for alarm in response_body['elements']:
self.assertEqual('LOW', alarm['alarm_definition']['severity'])
query_parms = '?severity=HIGH'
resp, response_body = self.monasca_client.list_alarms(query_parms)
self.assertEqual(200, resp.status)
for alarm in response_body['elements']:
self.assertEqual('HIGH', alarm['alarm_definition']['severity'])
query_parms = '?severity=CRITICAL'
resp, response_body = self.monasca_client.list_alarms(query_parms)
self.assertEqual(200, resp.status)
for alarm in response_body['elements']:
self.assertEqual('CRITICAL', alarm['alarm_definition']['severity'])
def resource_setup(cls):
super(TestAlarmsStateHistory, cls).resource_setup()
start_timestamp = int(time.time() * 1000)
end_timestamp = int(time.time() * 1000) + 1000
# create an alarm definition
expression = "avg(name-1) > 0"
name = data_utils.rand_name('alarm_definition')
alarm_definition = helpers.create_alarm_definition(
name=name,
expression=expression)
resp, response_body = cls.monasca_client.create_alarm_definitions(
alarm_definition)
# create another alarm definition
name1 = data_utils.rand_name('alarm_definition1')
expression1 = "max(cpu.system_perc) > 0"
alarm_definition1 = helpers.create_alarm_definition(
name=name1,
expression=expression1)
resp, response_body1 = cls.monasca_client.create_alarm_definitions(
alarm_definition1)
# create another alarm definition
name2 = data_utils.rand_name('alarm_definition2')
expression1 = "avg(mysql.performance.slow_queries) > 10.0"
alarm_definition2 = helpers.create_alarm_definition(
name=name2,
expression=expression1)
resp, response_body2 = cls.monasca_client.create_alarm_definitions(
alarm_definition2)
# create some metrics
for i in xrange(180):
metric = helpers.create_metric()
resp, body = cls.monasca_client.create_metrics(metric)
cls._start_timestamp = start_timestamp + i
cls._end_timestamp = end_timestamp + i
time.sleep(1)
resp, response_body = cls.monasca_client.\
list_alarms_state_history()
elements = response_body['elements']
if len(elements) > 4:
break
if len(elements) < 3:
cls.assertEqual(1, False)
def test_create_alarm_definition_with_special_chars_in_expression(self):
notification_name = data_utils.rand_name("notification-")
notification_type = "EMAIL"
address = "root@localhost"
resp, response_body = self.monasca_client.create_notification_method(
notification_name, type=notification_type, address=address
)
notification_id = self._verify_create_notification_method(
resp, response_body, notification_name, notification_type, address
)
# Create an alarm definition
alarm_def_name = data_utils.rand_name("monitoring_alarm")
alarm_definition = helpers.create_alarm_definition(
name=alarm_def_name,
expression="avg(mem_total_mb{dev=\usr\local\bin}) " "gt 0",
alarm_actions=[notification_id],
ok_actions=[notification_id],
undetermined_actions=[notification_id],
severity="LOW",
)
self.assertRaises(
exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition
)
def test_alarm_max_function(self):
metric_def = {
'name': data_utils.rand_name("max_test"),
'dimensions': {
'dim_to_match': data_utils.rand_name("max_match")
}
}
expression = "max(" + metric_def['name'] + ") > 14"
definition = helpers.create_alarm_definition(name="Test Max Function",
description="",
expression=expression,
match_by=["dim_to_match"])
resp, resp_body = (self.monasca_client
.create_alarm_definitions(definition))
self.assertEqual(201, resp.status)
definition_id = resp_body['id']
time.sleep(1)
self._send_measurement(metric_def, 1)
alarm_id, initial_state = self._wait_for_alarm_creation(definition_id)
self.assertEqual("UNDETERMINED", initial_state)
self._send_measurement(metric_def, 20)
self._wait_for_alarm_transition(alarm_id, "ALARM")
def resource_setup(cls):
super(TestAlarmsStateHistoryOneTransition, cls).resource_setup()
for i in range(MIN_HISTORY):
alarm_definition = helpers.create_alarm_definition(
name=data_utils.rand_name('alarm_state_history' + str(i + 1)),
expression="min(name-" + str(i + 1) + ") < " + str(i + 1))
cls.monasca_client.create_alarm_definitions(alarm_definition)
# Ensure the new Alarm Definitions get to the Threshold Engine
time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT)
num_transitions = 0
for timer in range(constants.MAX_RETRIES):
for i in range(MIN_HISTORY):
# Create some metrics to prime the system and waiting for the
# alarms to be created and then for them to change state.
# MIN_HISTORY number of Alarms State History are needed.
metric = helpers.create_metric(name="name-" + str(i + 1))
cls.monasca_client.create_metrics(metric)
# Ensure alarms transition at different times
time.sleep(0.1)
resp, response_body = cls.monasca_client.\
list_alarms_state_history()
elements = response_body['elements']
if len(elements) >= MIN_HISTORY:
return
else:
num_transitions = len(elements)
time.sleep(constants.RETRY_WAIT_SECS)
assert False, "Required {} alarm state transitions, but found {}".\
format(MIN_HISTORY, num_transitions)
def test_alarm_metric_mixcase(self):
metric_def = {
'name': data_utils.rand_name("MixCase_Test"),
'dimensions': {
'dim_to_match': data_utils.rand_name("max_match")
}
}
expression = "max(" + metric_def['name'] + ") > 14"
definition = helpers.create_alarm_definition(
name="Metric Mixcase Test",
description="",
expression=expression,
match_by=["dim_to_match"])
resp, resp_body = self.monasca_client.create_alarm_definitions(
definition)
self.assertEqual(201, resp.status)
definition_id = resp_body['id']
# Ensure the new Alarm Definition gets to the Threshold Engine
time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT)
self._send_measurement(metric_def, 20)
alarm_id, initial_state = self._wait_for_alarm_creation(definition_id)
self.assertEqual("ALARM", initial_state)
def test_create_alarm_definition_with_notification(self):
notification_name = data_utils.rand_name('notification-')
notification_type = 'EMAIL'
notification_address = 'root@localhost'
resp, response_body = self.monasca_client.create_notification_method(
name=notification_name, type=notification_type,
address=notification_address)
notification_id = self._verify_create_notification_method(
resp, response_body, notification_name, notification_type,
notification_address)
# Create an alarm definition
alarm_def_name = data_utils.rand_name('monitoring_alarm_definition')
expression = "mem_total_mb > 0"
alarm_definition = helpers.create_alarm_definition(
name=alarm_def_name,
expression=expression,
alarm_actions=[notification_id],
ok_actions=[notification_id],
undetermined_actions=[notification_id],
severity="LOW")
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self._verify_create_alarm_definitions(resp, response_body,
alarm_definition)
self.assertEqual(notification_id, response_body['ok_actions'][0])
self.assertEqual(notification_id, response_body['alarm_actions'][0])
self.assertEqual(notification_id,
response_body['undetermined_actions'][0])
self._delete_notification(notification_id)
def test_list_alarm_definitions_with_multiple_dimensions(self):
# Create an alarm definition with random dimensions
name = data_utils.rand_name('alarm_definition')
dimensions = {
data_utils.rand_name('key-1'): data_utils.rand_name('value-1'),
data_utils.rand_name('key-2'): data_utils.rand_name('value-2')
}
dimension_strings = [
key + '=' + value for key, value in dimensions.items()
]
expression = 'avg(cpu_utilization{' + ','.join(
dimension_strings) + '}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression)
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
# List alarms
query_dimensions = [
key + ':' + value for key, value in dimensions.items()
]
query_parms = '?dimensions=' + ','.join(query_dimensions)
resp, response_body = self.monasca_client.list_alarm_definitions(
query_parms)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_list_get_alarm_definitions_elements(
elements, 1, res_body_create_alarm_def)
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def resource_setup(cls):
super(TestAlarmsStateHistoryOneTransition, cls).resource_setup()
for i in xrange(MIN_HISTORY):
alarm_definition = helpers.create_alarm_definition(
name=data_utils.rand_name('alarm_state_history' + str(i + 1)),
expression="min(name-" + str(i + 1) + ") < " + str(i + 1))
cls.monasca_client.create_alarm_definitions(alarm_definition)
num_transitions = 0
for timer in xrange(constants.MAX_RETRIES):
for i in xrange(MIN_HISTORY):
# Create some metrics to prime the system and waiting for the
# alarms to be created and then for them to change state.
# MIN_HISTORY number of Alarms State History are needed.
metric = helpers.create_metric(name="name-" + str(i + 1))
cls.monasca_client.create_metrics(metric)
# sleep 0.05 second between metrics to make sure timestamps
# are different
time.sleep(0.05)
resp, response_body = cls.monasca_client.\
list_alarms_state_history()
elements = response_body['elements']
if len(elements) >= MIN_HISTORY:
return
else:
num_transitions = len(elements)
time.sleep(constants.RETRY_WAIT_SECS)
assert False, "Required {} alarm state transitions, but found {}".\
format(MIN_HISTORY, num_transitions)
def _create_alarms_for_test_alarms(self, num):
metric_name = data_utils.rand_name('name')
key = data_utils.rand_name('key')
value = data_utils.rand_name('value')
alarm_definition_ids = []
for i in xrange(num):
# create an alarm definition
expression = "max(" + metric_name + ") > 0"
name = data_utils.rand_name('name-1')
alarm_definition = helpers.create_alarm_definition(
name=name, expression=expression)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_ids.append(response_body['id'])
expected_metric = helpers.create_metric(name=metric_name,
dimensions={key: value})
# create some metrics
for j in xrange(num):
for i in xrange(constants.MAX_RETRIES):
self.monasca_client.create_metrics(expected_metric)
time.sleep(constants.RETRY_WAIT_SECS)
query_param = '?alarm_definition_id=' + \
str(alarm_definition_ids[j])
resp, response_body = self.monasca_client.list_alarms(
query_param)
elements = response_body['elements']
if len(elements) >= 1:
break
return alarm_definition_ids, expected_metric
def create_alarm_definition(cls):
# Create an alarm definition
name = data_utils.rand_name('alarm_definition')
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression)
return alarm_definition
def test_create_alarms_with_sub_expressions_and_match_by(self):
# Create an alarm definition with sub-expressions and match_by
name = data_utils.rand_name('alarm_definition_3')
expression = "max(cpu.idle_perc{service=monitoring}) < 10 or " \
"max(cpu.user_perc{service=monitoring}) > 60"
match_by = ['hostname']
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
self._create_metrics_for_match_by_sub_expressions(
num=2, alarm_definition_id=alarm_definition_id)
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp,
response_body,
expect_num_elements=2)
elements = response_body['elements']
hostnames = []
for i in xrange(2):
self.assertEqual(len(elements[i]['metrics']), 2)
for i in xrange(2):
for j in xrange(2):
hostnames.append(
elements[i]['metrics'][j]['dimensions']['hostname'])
self.assertEqual(hostnames[0], hostnames[1])
self.assertEqual(hostnames[2], hostnames[3])
self.assertNotEqual(hostnames[0], hostnames[2])
def test_create_alarm_definition_with_notification(self):
notification_name = data_utils.rand_name('notification-')
notification_type = 'EMAIL'
notification_address = 'root@localhost'
resp, response_body = self.monasca_client.create_notification_method(
name=notification_name, type=notification_type,
address=notification_address)
notification_id = self._verify_create_notification_method(
resp, response_body, notification_name, notification_type,
notification_address)
# Create an alarm definition
alarm_def_name = data_utils.rand_name('monitoring_alarm_definition')
expression = "mem_total_mb > 0"
alarm_definition = helpers.create_alarm_definition(
name=alarm_def_name,
expression=expression,
alarm_actions=[notification_id],
ok_actions=[notification_id],
undetermined_actions=[notification_id],
severity="LOW")
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self._verify_create_alarm_definitions(resp, response_body,
alarm_definition)
self.assertEqual(notification_id, response_body['ok_actions'][0])
self.assertEqual(notification_id, response_body['alarm_actions'][0])
self.assertEqual(notification_id,
response_body['undetermined_actions'][0])
self._delete_notification(notification_id)
def _create_alarms_for_test_alarms(self, num):
metric_name = data_utils.rand_name('name')
key = data_utils.rand_name('key')
value = data_utils.rand_name('value')
alarm_definition_ids = []
for i in xrange(num):
# create an alarm definition
expression = "max(" + metric_name + ") > 0"
name = data_utils.rand_name('name-1')
alarm_definition = helpers.create_alarm_definition(
name=name, expression=expression)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_ids.append(response_body['id'])
expected_metric = helpers.create_metric(name=metric_name,
dimensions={key: value})
# create some metrics
for j in xrange(num):
for i in xrange(constants.MAX_RETRIES):
self.monasca_client.create_metrics(expected_metric)
time.sleep(constants.RETRY_WAIT_SECS)
query_param = '?alarm_definition_id=' + \
str(alarm_definition_ids[j])
resp, response_body = self.monasca_client.list_alarms(
query_param)
elements = response_body['elements']
if len(elements) >= 1:
break
return alarm_definition_ids, expected_metric
def test_create_alarms_with_sub_expressions_and_match_by(self):
# Create an alarm definition with sub-expressions and match_by
name = data_utils.rand_name('alarm_definition_3')
expression = "max(cpu.idle_perc{service=monitoring}) < 10 or " \
"max(cpu.user_perc{service=monitoring}) > 60"
match_by = ['hostname']
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression,
match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
self._create_metrics_for_match_by_sub_expressions(
num=2, alarm_definition_id=alarm_definition_id)
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=2)
elements = response_body['elements']
hostnames = []
for i in xrange(2):
self.assertEqual(len(elements[i]['metrics']), 2)
for i in xrange(2):
for j in xrange(2):
hostnames.append(elements[i]['metrics'][j]['dimensions'][
'hostname'])
self.assertEqual(hostnames[0], hostnames[1])
self.assertEqual(hostnames[2], hostnames[3])
self.assertNotEqual(hostnames[0], hostnames[2])
def test_list_alarms_by_multiple_metric_dimensions(self):
metric = helpers.create_metric(
name=data_utils.rand_name("multi-dimension"),
dimensions={data_utils.rand_name("key-1"): data_utils.rand_name("value-1"),
data_utils.rand_name("key-2"): data_utils.rand_name("value-2")},
value=20
)
dimension_strings = [key + '=' + value for key, value in metric['dimensions'].items()]
alarm_def = helpers.create_alarm_definition(
name=data_utils.rand_name("multi-dimensions"),
expression=metric['name'] + "{" + ','.join(dimension_strings) + '} > 15'
)
resp, response_body = self.monasca_client.create_alarm_definitions(alarm_def)
self.assertEqual(201, resp.status)
alarm_def_id = response_body['id']
resp, response_body = self.monasca_client.create_metrics(metric)
self.assertEqual(204, resp.status)
self._wait_for_alarms(1, alarm_def_id)
query_dimensions = [key + ':' + value for key, value in metric['dimensions'].items()]
query_parms="?metric_dimensions=" + ','.join(query_dimensions)
resp, response_body = self.monasca_client.list_alarms(query_parms)
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=1)
element = response_body['elements'][0]
metric = element['metrics'][0]
self._verify_metric_in_alarm(metric, metric)
self.assertEqual(alarm_def_id,
element['alarm_definition']['id'])
def test_alarm_max_function(self):
metric_def = {
'name': data_utils.rand_name("max_test"),
'dimensions': {
'dim_to_match': data_utils.rand_name("max_match")
}
}
expression = "max(" + metric_def['name'] + ") > 14"
definition = helpers.create_alarm_definition(name="Test Max Function",
description="",
expression=expression,
match_by=["dim_to_match"])
resp, resp_body = (
self.monasca_client.create_alarm_definitions(definition))
self.assertEqual(201, resp.status)
definition_id = resp_body['id']
time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT)
self._send_measurement(metric_def, 1)
alarm_id, initial_state = self._wait_for_alarm_creation(definition_id)
self.assertEqual("UNDETERMINED", initial_state)
self._send_measurement(metric_def, 20)
self._wait_for_alarm_transition(alarm_id, "ALARM")
def test_alarm_max_with_deterministic(self):
metric_def = {
'name': data_utils.rand_name("max_deterministic_test"),
'dimensions': {
'dim_to_match': data_utils.rand_name("max_match")
}
}
expression = "max(" + metric_def['name'] + ",deterministic) > 14"
definition = helpers.create_alarm_definition(
name="Test Max Deterministic Function",
description="",
expression=expression,
match_by=["dim_to_match"])
resp, resp_body = self.monasca_client.create_alarm_definitions(
definition)
self.assertEqual(201, resp.status)
definition_id = resp_body['id']
time.sleep(1)
self._send_measurement(metric_def, 1)
alarm_id, initial_state = self._wait_for_alarm_creation(definition_id)
self.assertEqual("OK", initial_state)
self._send_measurement(metric_def, 20)
self._wait_for_alarm_transition(alarm_id, "ALARM")
def test_list_alarm_definitions_with_multiple_dimensions(self):
# Create an alarm definition with random dimensions
name = data_utils.rand_name('alarm_definition')
dimensions = {data_utils.rand_name('key-1'): data_utils.rand_name('value-1'),
data_utils.rand_name('key-2'): data_utils.rand_name('value-2')}
dimension_strings = [key + '=' + value for key, value in dimensions.items()]
expression = 'avg(cpu_utilization{' + ','.join(dimension_strings) + '}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression)
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
# List alarms
query_dimensions = [key + ':' + value for key, value in dimensions.items()]
query_parms = '?dimensions=' + ','.join(query_dimensions)
resp, response_body = self.monasca_client.list_alarm_definitions(query_parms)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_list_get_alarm_definitions_elements(
elements, 1, res_body_create_alarm_def)
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def test_alarm_last_with_deterministic(self):
metric_def = {'name': data_utils.rand_name("last_deterministic_test"),
'dimensions': {
'dim_to_match': data_utils.rand_name("last_match")
}}
expression = "last(" + metric_def['name'] + ",deterministic) > 14"
definition = helpers.create_alarm_definition(name="Test Last Deterministic Function",
description="",
expression=expression,
match_by=["dim_to_match"])
resp, resp_body = self.monasca_client.create_alarm_definitions(definition)
self.assertEqual(201, resp.status)
definition_id = resp_body['id']
time.sleep(1)
self._send_measurement(metric_def, 1)
alarm_id, initial_state = self._wait_for_alarm_creation(definition_id)
self.assertEqual("OK", initial_state)
self._send_measurement(metric_def, 20)
self._wait_for_alarm_transition(alarm_id, "ALARM")
self._send_measurement(metric_def, 3)
self._wait_for_alarm_transition(alarm_id, "OK")
def test_create_alarms_with_match_by_list(self):
# Create an alarm definition with match_by as a list
name = data_utils.rand_name('alarm_definition')
expression = "max(cpu.idle_perc{service=monitoring}) < 10"
match_by = ['hostname', 'device']
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
# create some metrics
self._create_metrics_for_match_by_sub_expressions_list(
num=4, alarm_definition_id=alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp,
response_body,
expect_num_elements=4)
elements = response_body['elements']
dimensions = []
for i in xrange(4):
self.assertEqual(len(elements[i]['metrics']), 1)
dimensions.append(elements[i]['metrics'][0]['dimensions'])
for i in xrange(4):
for j in xrange(4):
if i != j:
self.assertNotEqual(dimensions[i], dimensions[j])
def test_create_alarms_with_match_by_list(self):
# Create an alarm definition with match_by as a list
name = data_utils.rand_name('alarm_definition')
expression = "max(cpu.idle_perc{service=monitoring}) < 10"
match_by = ['hostname', 'device']
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression,
match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
# create some metrics
self._create_metrics_for_match_by_sub_expressions_list(
num=4, alarm_definition_id=alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=4)
elements = response_body['elements']
dimensions = []
for i in xrange(4):
self.assertEqual(len(elements[i]['metrics']), 1)
dimensions.append(elements[i]['metrics'][0]['dimensions'])
for i in xrange(4):
for j in xrange(4):
if i != j:
self.assertNotEqual(dimensions[i], dimensions[j])
def test_create_alarm_definition_with_name_exceeds_max_length(self):
long_name = "x" * (constants.MAX_ALARM_DEFINITION_NAME_LENGTH + 1)
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=long_name, description="description", expression=expression)
self.assertRaises(exceptions.UnprocessableEntity,
self.monasca_client.create_alarm_definitions,
alarm_definition)
def test_create_alarm_definition_with_name_exceeds_max_length(self):
long_name = "x" * (constants.MAX_ALARM_DEFINITION_NAME_LENGTH + 1)
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=long_name, description="description", expression=expression)
self.assertRaises(exceptions.UnprocessableEntity,
self.monasca_client.create_alarm_definitions,
alarm_definition)
def resource_setup(cls):
super(TestAlarmsStateHistory, cls).resource_setup()
start_timestamp = int(time.time() * 1000)
end_timestamp = int(time.time() * 1000) + 1000
# create an alarm definition
expression = "avg(name-1) > 0"
name = data_utils.rand_name('alarm_definition')
alarm_definition = helpers.create_alarm_definition(
name=name, expression=expression)
resp, response_body = cls.monasca_client.create_alarm_definitions(
alarm_definition)
# create another alarm definition
name1 = data_utils.rand_name('alarm_definition1')
expression1 = "max(cpu.system_perc) > 0"
alarm_definition1 = helpers.create_alarm_definition(
name=name1, expression=expression1)
resp, response_body1 = cls.monasca_client.create_alarm_definitions(
alarm_definition1)
# create another alarm definition
name2 = data_utils.rand_name('alarm_definition2')
expression1 = "avg(mysql.performance.slow_queries) > 10.0"
alarm_definition2 = helpers.create_alarm_definition(
name=name2, expression=expression1)
resp, response_body2 = cls.monasca_client.create_alarm_definitions(
alarm_definition2)
# create some metrics
for i in xrange(180):
metric = helpers.create_metric()
resp, body = cls.monasca_client.create_metrics(metric)
cls._start_timestamp = start_timestamp + i
cls._end_timestamp = end_timestamp + i
time.sleep(1)
resp, response_body = cls.monasca_client.\
list_alarms_state_history()
elements = response_body['elements']
if len(elements) > 4:
break
if len(elements) < 3:
cls.assertEqual(1, False)
def test_create_alarms_with_match_by(self):
# Create an alarm definition with no match_by
name = data_utils.rand_name('alarm_definition_1')
expression = "max(cpu.idle_perc{service=monitoring}) < 20"
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
self._create_metrics_for_match_by(
num=1, alarm_definition_id=alarm_definition_id)
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp,
response_body,
expect_num_elements=1)
elements = response_body['elements']
metrics = elements[0]['metrics']
self.assertEqual(len(metrics), 2)
self.assertNotEqual(metrics[0], metrics[1])
# Create an alarm definition with match_by
name = data_utils.rand_name('alarm_definition_2')
expression = "max(cpu.idle_perc{service=monitoring}) < 20"
match_by = ['hostname']
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
# create some metrics
self._create_metrics_for_match_by(
num=2, alarm_definition_id=alarm_definition_id)
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp,
response_body,
expect_num_elements=2)
elements = response_body['elements']
self.assertEqual(len(elements[0]['metrics']), 1)
self.assertEqual(len(elements[1]['metrics']), 1)
self.assertNotEqual(elements[0]['metrics'], elements[1]['metrics'])
def test_create_alarm_definition(self):
# Create an alarm definition
name = data_utils.rand_name("alarm_definition")
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression, match_by=["hostname"], severity="MEDIUM"
)
resp, response_body = self.monasca_client.create_alarm_definitions(alarm_definition)
self._verify_create_alarm_definitions(resp, response_body, alarm_definition)
def resource_setup(cls):
super(TestAlarmDefinitions, cls).resource_setup()
cls.rule = {'expression': 'mem_total_mb > 0'}
for i in range(NUM_ALARM_DEFINITIONS):
alarm_definition = helpers.create_alarm_definition(
name='alarm-definition-' + str(i),
description='alarm definition description',
expression='avg(cpu_utilization{service=compute}) >= 1000')
cls.monasca_client.create_alarm_definitions(alarm_definition)
def test_list_alarm_definitions_with_multiple_severity(self):
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization{alarm=severity}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="LOW")
resp, res_body_create_alarm_def_low = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization{alarm=severity}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="MEDIUM")
resp, res_body_create_alarm_def_medium = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization{alarm=severity}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="HIGH")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
query_param = '?severity=MEDIUM|LOW&dimensions=alarm:severity&sort_by=severity'
resp, response_body = self.monasca_client.\
list_alarm_definitions(query_param)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_alarm_definitions_list(elements, [res_body_create_alarm_def_low,
res_body_create_alarm_def_medium])
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def test_list_alarm_definitions_with_multiple_severity(self):
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization{alarm=severity}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="LOW")
resp, res_body_create_alarm_def_low = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization{alarm=severity}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="MEDIUM")
resp, res_body_create_alarm_def_medium = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
name = data_utils.rand_name('alarm_definition')
expression = 'avg(cpu_utilization{alarm=severity}) >= 1000'
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity="HIGH")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
query_param = '?severity=MEDIUM|LOW&dimensions=alarm:severity&sort_by=severity'
resp, response_body = self.monasca_client.\
list_alarm_definitions(query_param)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_alarm_definitions_list(
elements,
[res_body_create_alarm_def_low, res_body_create_alarm_def_medium])
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def test_verify_deterministic_alarm(self):
metric_name = data_utils.rand_name('log.fancy')
metric_dimensions = {'service': 'monitoring',
'hostname': 'mini-mon'}
name = data_utils.rand_name('alarm_definition')
expression = ('count(%s{service=monitoring},deterministic) > 10'
% metric_name)
match_by = ['hostname', 'device']
description = 'deterministic'
alarm_definition = helpers.create_alarm_definition(
name=name, description=description,
expression=expression, match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
# 1. ensure alarm was not created
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body, 0)
# 2. put some metrics here to create it, should be in ok
metrics_count = 5
for it in range(0, metrics_count):
metric = helpers.create_metric(name=metric_name,
value=1.0,
dimensions=metric_dimensions)
self.monasca_client.create_metrics(metric)
self._wait_for_alarms(1, alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body, 1)
element = response_body['elements'][0]
self.assertEqual('OK', element['state'])
# 3. exceed threshold
metrics_count = 20
for it in range(0, metrics_count):
metric = helpers.create_metric(name=metric_name,
value=1.0,
dimensions=metric_dimensions)
self.monasca_client.create_metrics(metric)
self._wait_for_alarms(1, alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body, 1)
element = response_body['elements'][0]
self.assertEqual('ALARM', element['state'])
def test_create_alarm_definition_with_undeterm_actions_exceeds_max_length(self):
name = data_utils.rand_name("alarm_definition")
expression = "max(cpu.system_perc) > 0"
undetermined_actions = ["x" * (constants.MAX_ALARM_DEFINITION_ACTIONS_LENGTH + 1)]
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression, undetermined_actions=undetermined_actions
)
self.assertRaises(
exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition
)
def test_create_alarm_definition_with_description_exceeds_max_length(self):
name = data_utils.rand_name('alarm_definition')
long_description = "x" * (constants.
MAX_ALARM_DEFINITION_DESCRIPTION_LENGTH + 1)
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name, description=long_description, expression=expression)
self.assertRaises(exceptions.UnprocessableEntity,
self.monasca_client.create_alarm_definitions,
alarm_definition)
def test_create_alarm_definition_with_invalid_severity(self):
invalid_severity = "INVALID"
name = data_utils.rand_name("alarm_definition")
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression, severity=invalid_severity
)
self.assertRaises(
exceptions.UnprocessableEntity, self.monasca_client.create_alarm_definitions, alarm_definition
)
def test_create_alarm_definition_with_description_exceeds_max_length(self):
name = data_utils.rand_name('alarm_definition')
long_description = "x" * (constants.
MAX_ALARM_DEFINITION_DESCRIPTION_LENGTH + 1)
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name, description=long_description, expression=expression)
self.assertRaises(exceptions.UnprocessableEntity,
self.monasca_client.create_alarm_definitions,
alarm_definition)
def test_create_alarm_definition(self):
# Create an alarm definition
name = data_utils.rand_name('alarm_definition')
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression,
match_by=['hostname'], severity="MEDIUM")
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self._verify_create_alarm_definitions(resp, response_body,
alarm_definition)
def test_create_alarms_with_match_by(self):
# Create an alarm definition with no match_by
name = data_utils.rand_name('alarm_definition_1')
expression = "max(cpu.idle_perc{service=monitoring}) < 20"
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
self._create_metrics_for_match_by(
num=1, alarm_definition_id=alarm_definition_id)
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=1)
elements = response_body['elements']
metrics = elements[0]['metrics']
self.assertEqual(len(metrics), 2)
self.assertNotEqual(metrics[0], metrics[1])
# Create an alarm definition with match_by
name = data_utils.rand_name('alarm_definition_2')
expression = "max(cpu.idle_perc{service=monitoring}) < 20"
match_by = ['hostname']
alarm_definition = helpers.create_alarm_definition(
name=name, description="description", expression=expression,
match_by=match_by)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
alarm_definition_id = response_body['id']
# create some metrics
self._create_metrics_for_match_by(
num=2, alarm_definition_id=alarm_definition_id)
query_param = '?alarm_definition_id=' + str(alarm_definition_id)
resp, response_body = self.monasca_client.list_alarms(query_param)
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=2)
elements = response_body['elements']
self.assertEqual(len(elements[0]['metrics']), 1)
self.assertEqual(len(elements[1]['metrics']), 1)
self.assertNotEqual(elements[0]['metrics'], elements[1]['metrics'])
def test_create_alarm_definition_with_invalid_severity(self):
invalid_severity = "INVALID"
name = data_utils.rand_name('alarm_definition')
expression = "max(cpu.system_perc) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
severity=invalid_severity)
self.assertRaises(exceptions.UnprocessableEntity,
self.monasca_client.create_alarm_definitions,
alarm_definition)
def test_list_alarms_by_metric_dimensions_multi_value(self):
metric_name = data_utils.rand_name('metric')
match_by_key = data_utils.rand_name('key')
dim_key = data_utils.rand_name('key')
dim_value_1 = data_utils.rand_name('value')
dim_value_2 = data_utils.rand_name('value')
alarm_def = helpers.create_alarm_definition(
name=data_utils.rand_name('definition'),
expression=metric_name + " > 1",
match_by=[match_by_key])
metric_1 = helpers.create_metric(
metric_name, {
match_by_key: data_utils.rand_name('value'),
dim_key: dim_value_1
})
metric_2 = helpers.create_metric(
metric_name, {
match_by_key: data_utils.rand_name('value'),
dim_key: dim_value_2
})
metric_3 = helpers.create_metric(
metric_name, {match_by_key: data_utils.rand_name('value')})
metrics = [metric_1, metric_2, metric_3]
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_def)
self.assertEqual(201, resp.status)
for i in xrange(constants.MAX_RETRIES):
resp, alarm_def_result = self.monasca_client.create_metrics(
metrics)
self.assertEqual(204, resp.status)
resp, response_body = self.monasca_client.list_alarms(
'?metric_name=' + metric_name)
self.assertEqual(200, resp.status)
if len(response_body['elements']) >= 3:
break
time.sleep(constants.RETRY_WAIT_SECS)
if i >= constants.MAX_RETRIES - 1:
self.fail(
"Timeout creating alarms, required 3 but found {}".format(
len(response_body['elements'])))
query_parms = '?metric_dimensions=' + dim_key + ':' + dim_value_1 + '|' + dim_value_2
resp, response_body = self.monasca_client.list_alarms(query_parms)
self._verify_list_alarms_elements(resp,
response_body,
expect_num_elements=2)
dimension_sets = []
for element in response_body['elements']:
self.assertEqual(metric_name, element['metrics'][0]['name'])
dimension_sets.append(element['metrics'][0]['dimensions'])
self.assertIn(metric_1['dimensions'], dimension_sets)
self.assertIn(metric_2['dimensions'], dimension_sets)
self.assertNotIn(metric_3['dimensions'], dimension_sets)
def test_create_alarm_definition_with_multiple_notifications(self):
notification_name1 = data_utils.rand_name('notification-')
notification_type1 = 'EMAIL'
address1 = 'root@localhost'
notification_name2 = data_utils.rand_name('notification-')
notification_type2 = 'PAGERDUTY'
address2 = 'http://localhost.com'
resp, body = self.monasca_client.create_notification_method(
notification_name1, type=notification_type1, address=address1)
self.assertEqual(201, resp.status)
self.assertEqual(notification_name1, body['name'])
notification_id1 = body['id']
resp, body = self.monasca_client.create_notification_method(
notification_name2, type=notification_type2, address=address2)
self.assertEqual(201, resp.status)
self.assertEqual(notification_name2, body['name'])
notification_id2 = body['id']
# Create an alarm definition
alarm_def_name = data_utils.rand_name('monitoring_alarm_definition')
alarm_definition = helpers.create_alarm_definition(
name=alarm_def_name,
expression="mem_total_mb > 0",
alarm_actions=[notification_id1, notification_id2],
ok_actions=[notification_id1, notification_id2],
severity="LOW")
resp, body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self.assertEqual(201, resp.status)
self.assertEqual(alarm_def_name, body['name'])
alarm_def_id = body['id']
self.assertEqual("mem_total_mb > 0", body['expression'])
# Delete alarm definition and validate if deleted
resp, body = self.monasca_client.delete_alarm_definition(alarm_def_id)
self.assertEqual(204, resp.status)
self.assertRaises(exceptions.NotFound,
self.monasca_client.get_alarm_definition,
alarm_def_id)
# Delete notification 1
resp, body = self.monasca_client.delete_notification_method(
notification_id1)
self.assertEqual(204, resp.status)
# Delete notification 2
resp, body = self.monasca_client.delete_notification_method(
notification_id2)
self.assertEqual(204, resp.status)
def test_list_alarm_definitions_multiple_sort_by(self):
key = data_utils.rand_name('key')
value = data_utils.rand_name('value')
expression = 'avg(cpu_utilization{' + str(key) + '=' + str(value) + \
'}) >= 1000'
alarm_definitions = [helpers.create_alarm_definition(
name='alarm def sort by 11',
expression=expression,
severity='MEDIUM'
), helpers.create_alarm_definition(
name='alarm def sort by 14',
expression=expression,
severity='MEDIUM'
), helpers.create_alarm_definition(
name='alarm def sort by 12',
expression=expression,
severity='LOW'
), helpers.create_alarm_definition(
name='alarm def sort by 13',
expression=expression,
severity='MEDIUM'
)]
for definition in alarm_definitions:
resp, response_body = self.monasca_client.create_alarm_definitions(definition)
definition['id'] = response_body['id']
resp, response_body = self.monasca_client.list_alarm_definitions(
'?dimensions=' + str(key) + ':' + str(value) +
'&sort_by=' + urlparse.quote('severity asc,name desc,id'))
self.assertEqual(200, resp.status)
expected_order = [2, 1, 3, 0]
for i, element in enumerate(response_body['elements']):
self.assertEqual(alarm_definitions[expected_order[i]]['id'], element['id'])
def test_create_alarm_definition_with_undeterm_actions_exceeds_max_length(
self):
name = data_utils.rand_name('alarm_definition')
expression = "max(cpu.system_perc) > 0"
undetermined_actions = ["x" * (constants.
MAX_ALARM_DEFINITION_ACTIONS_LENGTH +
1)]
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
undetermined_actions=undetermined_actions)
self.assertRaises(exceptions.UnprocessableEntity,
self.monasca_client.create_alarm_definitions,
alarm_definition)
def test_list_alarm_definitions_with_name(self):
name = data_utils.rand_name("alarm_definition")
alarm_definition = helpers.create_alarm_definition(
name=name, description=data_utils.rand_name("description"), expression="max(cpu.system_perc) > 0"
)
resp, res_body_create_alarm_def = self.monasca_client.create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
query_parms = "?name=" + str(name)
resp, response_body = self.monasca_client.list_alarm_definitions(query_parms)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body["elements"]
self._verify_list_get_alarm_definitions_elements(elements, 1, res_body_create_alarm_def)
links = response_body["links"]
self._verify_list_alarm_definitions_links(links)
def _create_alarm_definitions(self, expression, number_of_definitions):
self.rule = {'expression': 'mem_total_mb > 0'}
if expression is None:
expression = "max(cpu.system_perc) > 0"
response_body_list = []
for i in xrange(number_of_definitions):
alarm_definition = helpers.create_alarm_definition(
name=data_utils.rand_name('alarm_definition'),
description=data_utils.rand_name('description'),
expression=expression,
match_by=['device'])
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self.assertEqual(201, resp.status)
response_body_list.append(response_body)
return response_body_list
def test_create_deterministic_alarm_definition(self):
name = data_utils.rand_name('log.error')
expression = "count(log.error{},deterministic) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=['hostname'],
severity="MEDIUM")
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self._verify_create_alarm_definitions(resp,
response_body,
alarm_definition,
deterministic=True)
def _create_alarm_definitions(self, expression, number_of_definitions):
self.rule = {'expression': 'mem_total_mb > 0'}
if expression is None:
expression = "max(cpu.system_perc) > 0"
response_body_list = []
for i in xrange(number_of_definitions):
alarm_definition = helpers.create_alarm_definition(
name=data_utils.rand_name('alarm_definition'),
description=data_utils.rand_name('description'),
expression=expression,
match_by=['device'])
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self.assertEqual(201, resp.status)
response_body_list.append(response_body)
return response_body_list
def create_alarms_for_test_alarms(cls):
# create an alarm definition
expression = "avg(name-1) > 0"
name = data_utils.rand_name('name-1')
alarm_definition = helpers.create_alarm_definition(
name=name, expression=expression)
resp, response_body = cls.monasca_client.create_alarm_definitions(
alarm_definition)
# create some metrics
for i in xrange(30):
metric = helpers.create_metric()
resp, response_body = cls.monasca_client.create_metrics(metric)
time.sleep(1)
resp, response_body = cls.monasca_client.list_alarms()
elements = response_body['elements']
if len(elements) > 0:
break
def create_alarms_for_test_alarms(cls):
# create an alarm definition
expression = "avg(name-1) > 0"
name = data_utils.rand_name('name-1')
alarm_definition = helpers.create_alarm_definition(
name=name, expression=expression)
resp, response_body = cls.monasca_client.create_alarm_definitions(
alarm_definition)
# create some metrics
for i in xrange(30):
metric = helpers.create_metric()
resp, response_body = cls.monasca_client.create_metrics(metric)
time.sleep(1)
resp, response_body = cls.monasca_client.list_alarms()
elements = response_body['elements']
if len(elements) > 0:
break
def resource_setup(cls):
super(TestAlarmStateHistoryMultipleTransitions, cls).resource_setup()
alarm_definition = helpers.create_alarm_definition(
name=data_utils.rand_name('alarm_state_history'),
expression="min(name-1) < 1.0")
cls.monasca_client.create_alarm_definitions(alarm_definition)
for timer in xrange(constants.MAX_RETRIES):
# create some metrics to prime the system and create
# MIN_HISTORY alarms
metric = helpers.create_metric(name="name-1",
dimensions={'key1': 'value1'},
value=0.0)
cls.monasca_client.create_metrics(metric)
# sleep 1 second between metrics to make sure timestamps
# are different in the second field. Influxdb has a bug
# where it does not sort properly by milliseconds. .014
# is sorted as greater than .138
time.sleep(1.0)
resp, response_body = cls.monasca_client.\
list_alarms_state_history()
elements = response_body['elements']
if len(elements) >= 1:
break
time.sleep(constants.RETRY_WAIT_SECS)
time.sleep(constants.MAX_RETRIES)
for timer in xrange(constants.MAX_RETRIES * 2):
metric = helpers.create_metric(name="name-1",
dimensions={'key2': 'value2'},
value=2.0)
cls.monasca_client.create_metrics(metric)
# sleep 0.05 second between metrics to make sure timestamps
# are different
time.sleep(0.05)
resp, response_body = \
cls.monasca_client.list_alarms_state_history()
elements = response_body['elements']
if len(elements) >= 2:
return
else:
num_transitions = len(elements)
time.sleep(constants.RETRY_WAIT_SECS)
assert False, "Required {} alarm state transitions, but found {}".\
format(MIN_HISTORY, num_transitions)
def test_create_deterministic_alarm_definition(self):
name = data_utils.rand_name('log.error')
expression = "count(log.error{},deterministic) > 0"
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=['hostname'],
severity="MEDIUM"
)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition
)
self._verify_create_alarm_definitions(resp,
response_body,
alarm_definition,
deterministic=True)
def test_create_non_deterministic_alarm_definition_compound_mixed_expr(
self):
name = data_utils.rand_name('log.error.and.disk.used_perc')
expression = ('max(disk.used_perc{hostname=node_1}) > 99.0 AND '
'count(log.error{hostname=node_1},deterministic) > 0')
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=['hostname'],
severity="MEDIUM")
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition)
self._verify_create_alarm_definitions(resp,
response_body,
alarm_definition,
deterministic=False)
def test_list_alarm_definitions_with_dimensions(self):
# Create an alarm definition with random dimensions
name = data_utils.rand_name("alarm_definition")
key = data_utils.rand_name("key")
value = data_utils.rand_name("value")
expression = "avg(cpu_utilization{" + str(key) + "=" + str(value) + "}) >= 1000"
alarm_definition = helpers.create_alarm_definition(name=name, description="description", expression=expression)
resp, res_body_create_alarm_def = self.monasca_client.create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
# List alarms
query_parms = "?dimensions=" + str(key) + ":" + str(value)
resp, response_body = self.monasca_client.list_alarm_definitions(query_parms)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body["elements"]
self._verify_list_get_alarm_definitions_elements(elements, 1, res_body_create_alarm_def)
links = response_body["links"]
self._verify_list_alarm_definitions_links(links)
def test_create_non_deterministic_alarm_definition_compound_mixed_expr(self):
name = data_utils.rand_name('log.error.and.disk.used_perc')
expression = ('max(disk.used_perc{hostname=node_1}) > 99.0 AND '
'count(log.error{hostname=node_1},deterministic) > 0')
alarm_definition = helpers.create_alarm_definition(
name=name,
description="description",
expression=expression,
match_by=['hostname'],
severity="MEDIUM"
)
resp, response_body = self.monasca_client.create_alarm_definitions(
alarm_definition
)
self._verify_create_alarm_definitions(resp,
response_body,
alarm_definition,
deterministic=False)
def resource_setup(cls):
super(TestAlarmsStateHistory, cls).resource_setup()
for i in xrange(1, NUM_ALARM_DEFINITIONS + 1):
alarm_definition = helpers.create_alarm_definition(
name=data_utils.rand_name('alarm_state_history' + str(i)),
expression="min(name-1) < " + str(i))
cls.monasca_client.create_alarm_definitions(alarm_definition)
# create some metrics to prime the system and create three alarms
for i in xrange(60):
metric = helpers.create_metric()
cls.monasca_client.create_metrics(metric)
resp, response_body = cls.monasca_client.\
list_alarms_state_history()
elements = response_body['elements']
if len(elements) >= MIN_HISTORY:
break
time.sleep(5)
def test_list_alarm_definitions_with_name(self):
name = data_utils.rand_name('alarm_definition')
alarm_definition = helpers.create_alarm_definition(
name=name,
description=data_utils.rand_name('description'),
expression="max(cpu.system_perc) > 0")
resp, res_body_create_alarm_def = self.monasca_client.\
create_alarm_definitions(alarm_definition)
self.assertEqual(201, resp.status)
query_parms = "?name=" + str(name)
resp, response_body = self.monasca_client.list_alarm_definitions(
query_parms)
self._verify_list_alarm_definitions_response_body(resp, response_body)
elements = response_body['elements']
self._verify_list_get_alarm_definitions_elements(
elements, 1, res_body_create_alarm_def)
links = response_body['links']
self._verify_list_alarm_definitions_links(links)
def test_list_alarms_by_metric_dimensions_no_value(self):
metric_name = data_utils.rand_name('metric')
match_by_key = data_utils.rand_name('key')
dim_key = data_utils.rand_name('key')
alarm_def = helpers.create_alarm_definition(
name=data_utils.rand_name('definition'),
expression=metric_name + " > 1",
match_by=[match_by_key])
metric_1 = helpers.create_metric(metric_name,
{match_by_key: data_utils.rand_name('value'),
dim_key: data_utils.rand_name('value')})
metric_2 = helpers.create_metric(metric_name,
{match_by_key: data_utils.rand_name('value'),
dim_key: data_utils.rand_name('value')})
metric_3 = helpers.create_metric(metric_name,
{match_by_key: data_utils.rand_name('value')})
metrics = [metric_1, metric_2, metric_3]
resp, response_body = self.monasca_client.create_alarm_definitions(alarm_def)
self.assertEqual(201, resp.status)
for i in xrange(constants.MAX_RETRIES):
resp, alarm_def_result = self.monasca_client.create_metrics(metrics)
self.assertEqual(204, resp.status)
resp, response_body = self.monasca_client.list_alarms('?metric_name=' + metric_name)
self.assertEqual(200, resp.status)
if len(response_body['elements']) >= 3:
break
time.sleep(constants.RETRY_WAIT_SECS)
if i >= constants.MAX_RETRIES - 1:
self.fail("Timeout creating alarms, required 3 but found {}".format(
len(response_body['elements'])))
query_parms = '?metric_dimensions=' + dim_key
resp, response_body = self.monasca_client.list_alarms(query_parms)
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=2)
dimension_sets = []
for element in response_body['elements']:
self.assertEqual(metric_name, element['metrics'][0]['name'])
dimension_sets.append(element['metrics'][0]['dimensions'])
self.assertIn(metric_1['dimensions'], dimension_sets)
self.assertIn(metric_2['dimensions'], dimension_sets)
self.assertNotIn(metric_3['dimensions'], dimension_sets)
