def setUp(self):
super(TestRPCAlarmPartitionCoordination, self).setUp()
self.CONF = self.useFixture(fixture_config.Config()).conf
self.setup_messaging(self.CONF)
self.coordinator_server = FakeCoordinator(self.transport)
self.coordinator_server.rpc.start()
eventlet.sleep() # must be sure that fanout queue is created
self.coordination = rpc_alarm.RPCAlarmPartitionCoordination()
self.alarms = [
alarms.Alarm(None,
info={
'name': 'instance_running_hot',
'meter_name': 'cpu_util',
'comparison_operator': 'gt',
'threshold': 80.0,
'evaluation_periods': 5,
'statistic': 'avg',
'state': 'ok',
'ok_actions': ['http://host:8080/path'],
'user_id': 'foobar',
'project_id': 'snafu',
'period': 60,
'alarm_id': str(uuid.uuid4()),
'matching_metadata': {
'resource_id': 'my_instance'
}
}),
alarms.Alarm(None,
info={
'name':
'group_running_idle',
'meter_name':
'cpu_util',
'comparison_operator':
'le',
'threshold':
10.0,
'statistic':
'max',
'evaluation_periods':
4,
'state':
'insufficient data',
'insufficient_data_actions':
['http://other_host/path'],
'user_id':
'foobar',
'project_id':
'snafu',
'period':
300,
'alarm_id':
str(uuid.uuid4()),
'matching_metadata': {
'metadata.user_metadata.AS': 'my_group'
}
}),
]
def setUp(self):
super(TestRPCAlarmNotifier, self).setUp()
messaging.setup('fake://')
self.addCleanup(messaging.cleanup)
self.notifier_server = FakeNotifier()
self.notifier = rpc_alarm.RPCAlarmNotifier()
self.alarms = [
alarms.Alarm(None,
info={
'name': 'instance_running_hot',
'meter_name': 'cpu_util',
'comparison_operator': 'gt',
'threshold': 80.0,
'evaluation_periods': 5,
'statistic': 'avg',
'state': 'ok',
'ok_actions': ['http://host:8080/path'],
'user_id': 'foobar',
'project_id': 'snafu',
'period': 60,
'alarm_id': str(uuid.uuid4()),
'matching_metadata': {
'resource_id': 'my_instance'
}
}),
alarms.Alarm(None,
info={
'name':
'group_running_idle',
'meter_name':
'cpu_util',
'comparison_operator':
'le',
'threshold':
10.0,
'statistic':
'max',
'evaluation_periods':
4,
'state':
'insufficient data',
'insufficient_data_actions':
['http://other_host/path'],
'user_id':
'foobar',
'project_id':
'snafu',
'period':
300,
'alarm_id':
str(uuid.uuid4()),
'matching_metadata': {
'metadata.user_metadata.AS': 'my_group'
}
}),
]
def setUp(self):
super(TestRPCAlarmNotifier, self).setUp()
self.notified = []
self.useFixture(
mockpatch.PatchObject(rpc, 'cast', side_effect=self.fake_cast))
self.notifier = rpc_alarm.RPCAlarmNotifier()
self.alarms = [
alarms.Alarm(None,
info={
'name': 'instance_running_hot',
'meter_name': 'cpu_util',
'comparison_operator': 'gt',
'threshold': 80.0,
'evaluation_periods': 5,
'statistic': 'avg',
'state': 'ok',
'ok_actions': ['http://host:8080/path'],
'user_id': 'foobar',
'project_id': 'snafu',
'period': 60,
'alarm_id': str(uuid.uuid4()),
'matching_metadata': {
'resource_id': 'my_instance'
}
}),
alarms.Alarm(None,
info={
'name':
'group_running_idle',
'meter_name':
'cpu_util',
'comparison_operator':
'le',
'threshold':
10.0,
'statistic':
'max',
'evaluation_periods':
4,
'state':
'insufficient data',
'insufficient_data_actions':
['http://other_host/path'],
'user_id':
'foobar',
'project_id':
'snafu',
'period':
300,
'alarm_id':
str(uuid.uuid4()),
'matching_metadata': {
'metadata.user_metadata.AS': 'my_group'
}
}),
]
def test_query(self):
ret_alarm = [alarms.Alarm(mock.Mock(), alarm) for alarm in self.ALARM]
self.cc.query_alarms.query.return_value = ret_alarm
ceilometer_shell.do_query_alarms(self.cc, self.args)
self.assertEqual(
'''\
+--------------------------------------+------------------+-------+----------+\
---------+------------+-------------------------------------------------------\
-----------------------------------------------+-------------------------------\
-+
| Alarm ID | Name | State | Severity \
| Enabled | Continuous | Alarm condition \
| Time constraints \
|
+--------------------------------------+------------------+-------+----------+\
---------+------------+-------------------------------------------------------\
-----------------------------------------------+--------------------------------+
| 768ff714-8cfb-4db9-9753-d484cb33a1cc | SwiftObjectAlarm | ok | critical \
| True | False | combinated states (OR) of \
739e99cb-c2ec-4718-b900-332502355f38, 153462d0-a9b8-4b5b-8175-9e4b05e9b856 |\
test at 0 23 * * * for 10800s |
+--------------------------------------+------------------+-------+----------+\
---------+------------+-------------------------------------------------------\
-----------------------------------------------+------------------------------\
--+
''', sys.stdout.getvalue())
def test_time_constraints_compatibility(self):
# client should be backwards compatible
alarm_without_tc = dict(self.ALARM[0])
del alarm_without_tc['time_constraints']
# NOTE(nsaje): Since we're accessing a nonexisting key in the resource,
# the resource is looking it up with the manager (which is a mock).
manager_mock = mock.Mock()
del manager_mock.get
ret_alarm = [alarms.Alarm(manager_mock, alarm_without_tc)]
self.cc.query_alarms.query.return_value = ret_alarm
ceilometer_shell.do_query_alarms(self.cc, self.args)
self.assertEqual(
'''\
+--------------------------------------+------------------+-------+----------+\
---------+------------+-------------------------------------------------------\
-----------------------------------------------+------------------+
| Alarm ID | Name | State | Severity \
| Enabled | Continuous | Alarm condition \
| Time constraints |
+--------------------------------------+------------------+-------+----------+\
---------+------------+-------------------------------------------------------\
-----------------------------------------------+------------------+
| 768ff714-8cfb-4db9-9753-d484cb33a1cc | SwiftObjectAlarm | ok | critical \
| True | False | combinated states (OR) of \
739e99cb-c2ec-4718-b900-332502355f38, 153462d0-a9b8-4b5b-8175-9e4b05e9b856 \
| None |
+--------------------------------------+------------------+-------+----------+\
---------+------------+-------------------------------------------------------\
-----------------------------------------------+------------------+
''', sys.stdout.getvalue())
def test_alarm_create_time_constraints(self):
shell = base_shell.CeilometerShell()
argv = [
'alarm-threshold-create',
'--name',
'cpu_high',
'--meter-name',
'cpu_util',
'--threshold',
'70.0',
'--time-constraint',
'name=cons1;start="0 11 * * *";duration=300',
'--time-constraint',
'name=cons2;start="0 23 * * *";duration=600',
]
_, args = shell.parse_args(argv)
alarm = alarms.Alarm(mock.Mock(), self.ALARM)
self.cc.alarms.create.return_value = alarm
ceilometer_shell.do_alarm_threshold_create(self.cc, args)
_, kwargs = self.cc.alarms.create.call_args
time_constraints = [
dict(name='cons1', start='0 11 * * *', duration='300'),
dict(name='cons2', start='0 23 * * *', duration='600')
]
self.assertEqual(time_constraints, kwargs['time_constraints'])
def test_query(self):
ret_alarm = [alarms.Alarm(mock.Mock(), alarm) for alarm in self.ALARM]
self.cc.query_alarms.query.return_value = ret_alarm
org_stdout = sys.stdout
try:
sys.stdout = output = six.StringIO()
ceilometer_shell.do_query_alarms(self.cc, self.args)
finally:
sys.stdout = org_stdout
self.assertEqual(
'''\
+--------------------------------------+------------------+-------+---------\
+------------+--------------------------------------------------------------\
----------------------------------------+
| Alarm ID | Name | State | Enabled \
| Continuous | Alarm condition \
|
+--------------------------------------+------------------+-------+---------\
+------------+--------------------------------------------------------------\
----------------------------------------+
| 768ff714-8cfb-4db9-9753-d484cb33a1cc | SwiftObjectAlarm | ok | True \
| False | combinated states (OR) of 739e99cb-c2ec-4718-b900-332502355f3\
8, 153462d0-a9b8-4b5b-8175-9e4b05e9b856 |
+--------------------------------------+------------------+-------+---------\
+------------+--------------------------------------------------------------\
----------------------------------------+
''', output.getvalue())
def _test_alarm_threshold_action_args(self, action, argv):
shell = base_shell.CeilometerShell()
_, args = shell.parse_args(argv)
alarm = alarms.Alarm(mock.Mock(), self.ALARM)
getattr(self.cc.alarms, action).return_value = alarm
func = getattr(ceilometer_shell, 'do_alarm_threshold_' + action)
func(self.cc, args)
_, kwargs = getattr(self.cc.alarms, action).call_args
self._check_alarm_threshold_args(kwargs)
def _do_test_alarm_update_repeat_actions(self, method, repeat_actions):
self.args.threshold = 42.0
if repeat_actions is not None:
self.args.repeat_actions = repeat_actions
alarm = [alarms.Alarm(mock.Mock(), self.ALARM)]
self.cc.alarms.get.return_value = alarm
self.cc.alarms.update.return_value = alarm[0]
method(self.cc, self.args)
args, kwargs = self.cc.alarms.update.call_args
self.assertEqual(self.ALARM_ID, args[0])
self.assertEqual(42.0, kwargs.get('threshold'))
if repeat_actions is not None:
self.assertEqual(repeat_actions, kwargs.get('repeat_actions'))
else:
self.assertNotIn('repeat_actions', kwargs)
def test_notify_no_actions(self):
alarm = alarms.Alarm(None, info={
'name': 'instance_running_hot',
'meter_name': 'cpu_util',
'comparison_operator': 'gt',
'threshold': 80.0,
'evaluation_periods': 5,
'statistic': 'avg',
'state': 'ok',
'user_id': 'foobar',
'project_id': 'snafu',
'period': 60,
'ok_actions': [],
'alarm_id': str(uuid.uuid4()),
'matching_metadata': {'resource_id':
'my_instance'}
})
self.notifier.notify(alarm, 'alarm', "what?")
self.assertEqual(len(self.notified), 0)
def test_alarm_threshold_create_args(self):
shell = base_shell.CeilometerShell()
argv = [
'alarm-threshold-create', '--name', 'cpu_high', '--description',
'instance running hot', '--meter-name', 'cpu_util', '--threshold',
'70.0', '--comparison-operator', 'gt', '--statistic', 'avg',
'--period', '600', '--evaluation-periods', '3', '--alarm-action',
'log://', '--alarm-action', 'http://example.com/alarm/state',
'--query', 'resource_id=INSTANCE_ID'
]
_, args = shell.parse_args(argv)
orig = sys.stdout
sys.stdout = six.StringIO()
alarm = alarms.Alarm(mock.Mock(), self.ALARM)
self.cc.alarms.create.return_value = alarm
try:
ceilometer_shell.do_alarm_threshold_create(self.cc, args)
_, kwargs = self.cc.alarms.create.call_args
self.assertEqual('cpu_high', kwargs.get('name'))
self.assertEqual('instance running hot', kwargs.get('description'))
actions = ['log://', 'http://example.com/alarm/state']
self.assertEqual(actions, kwargs.get('alarm_actions'))
self.assertTrue('threshold_rule' in kwargs)
rule = kwargs['threshold_rule']
self.assertEqual('cpu_util', rule.get('meter_name'))
self.assertEqual(70.0, rule.get('threshold'))
self.assertEqual('gt', rule.get('comparison_operator'))
self.assertEqual('avg', rule.get('statistic'))
self.assertEqual(600, rule.get('period'))
self.assertEqual(3, rule.get('evaluation_periods'))
query = dict(field='resource_id',
type='',
value='INSTANCE_ID',
op='eq')
self.assertEqual([query], rule['query'])
finally:
sys.stdout.close()
sys.stdout = orig
def _do_test_alarm_update_repeat_actions(self, method, repeat_actions):
self.args.threshold = 42.0
if repeat_actions is not None:
self.args.repeat_actions = repeat_actions
orig = sys.stdout
sys.stdout = six.StringIO()
alarm = [alarms.Alarm(mock.Mock(), self.ALARM)]
self.cc.alarms.get.return_value = alarm
self.cc.alarms.update.return_value = alarm[0]
try:
method(self.cc, self.args)
args, kwargs = self.cc.alarms.update.call_args
self.assertEqual(self.ALARM_ID, args[0])
self.assertEqual(42.0, kwargs.get('threshold'))
if repeat_actions is not None:
self.assertEqual(repeat_actions, kwargs.get('repeat_actions'))
else:
self.assertFalse('repeat_actions' in kwargs)
finally:
sys.stdout.close()
sys.stdout = orig
def _get_alarm(state):
return alarms.Alarm(None, {'state': state})
def data(TEST):
TEST.ceilometer_users = utils.TestDataContainer()
TEST.ceilometer_tenants = utils.TestDataContainer()
TEST.resources = utils.TestDataContainer()
TEST.api_resources = utils.TestDataContainer()
TEST.samples = utils.TestDataContainer()
TEST.meters = utils.TestDataContainer()
TEST.alarms = utils.TestDataContainer()
TEST.statistics = utils.TestDataContainer()
TEST.global_disk_usages = utils.TestDataContainer()
TEST.global_network_usages = utils.TestDataContainer()
TEST.global_network_traffic_usages = utils.TestDataContainer()
TEST.global_object_store_usages = utils.TestDataContainer()
TEST.statistics_array = utils.TestDataContainer()
# users
ceilometer_user_dict1 = {
'id': "1",
'name': 'user',
'email': '*****@*****.**',
'password': '******',
'token': 'test_token',
'project_id': '1',
'enabled': True,
'domain_id': "1"
}
ceilometer_user_dict2 = {
'id': "2",
'name': 'user2',
'email': '*****@*****.**',
'password': '******',
'token': 'test_token',
'project_id': '2',
'enabled': True,
'domain_id': "2"
}
TEST.ceilometer_users.add(users.User(None, ceilometer_user_dict1))
TEST.ceilometer_users.add(users.User(None, ceilometer_user_dict2))
# Tenants.
tenant_dict = {
'id': "1",
'name': 'test_tenant',
'description': "a test tenant.",
'enabled': True,
'domain_id': '1'
}
tenant_dict_2 = {
'id': "2",
'name': 'disabled_tenant',
'description': "a disabled test tenant.",
'enabled': False,
'domain_id': '2'
}
tenant_dict_3 = {
'id': "3",
'name': u'\u4e91\u89c4\u5219',
'description': "an unicode-named tenant.",
'enabled': True,
'domain_id': '2'
}
ceilometer_tenant = tenants.Tenant(tenants.TenantManager, tenant_dict)
ceilometer_disabled_tenant = tenants.Tenant(tenants.TenantManager,
tenant_dict_2)
ceilometer_tenant_unicode = tenants.Tenant(tenants.TenantManager,
tenant_dict_3)
TEST.ceilometer_tenants.add(ceilometer_tenant, ceilometer_disabled_tenant,
ceilometer_tenant_unicode)
# resources
resource_dict_1 = dict(
resource_id='fake_resource_id',
project_id='fake_project_id',
user_id="fake_user_id",
timestamp='2012-07-02T10:42:00.000000',
metadata={
'tag': 'self.counter3',
'display_name': 'test-server'
},
links=[{
'url': 'test_url',
'rel': 'storage.objects'
}],
)
resource_dict_2 = dict(
resource_id='fake_resource_id2',
project_id='fake_project_id',
user_id="fake_user_id",
timestamp='2012-07-02T10:42:00.000000',
metadata={
'tag': 'self.counter3',
'display_name': 'test-server'
},
links=[{
'url': 'test_url',
'rel': 'storage.objects'
}],
)
resource_dict_3 = dict(
resource_id='fake_resource_id3',
project_id='fake_project_id',
user_id="fake_user_id",
timestamp='2012-07-02T10:42:00.000000',
metadata={
'tag': 'self.counter3',
'display_name': 'test-server'
},
links=[{
'url': 'test_url',
'rel': 'instance'
}],
)
resource_dict_4 = dict(
resource_id='fake_resource_id3',
project_id='fake_project_id',
user_id="fake_user_id",
timestamp='2012-07-02T10:42:00.000000',
metadata={
'tag': 'self.counter3',
'display_name': 'test-server'
},
links=[{
'url': 'test_url',
'rel': 'memory'
}],
)
resource_1 = resources.Resource(resources.ResourceManager(None),
resource_dict_1)
resource_2 = resources.Resource(resources.ResourceManager(None),
resource_dict_2)
resource_3 = resources.Resource(resources.ResourceManager(None),
resource_dict_3)
resource_4 = resources.Resource(resources.ResourceManager(None),
resource_dict_4)
TEST.resources.add(resource_1)
TEST.resources.add(resource_2)
TEST.resources.add(resource_3)
# Having a separate set of fake objects for openstack_dashboard
# api Resource class. This is required because of additional methods
# defined in openstack_dashboard.api.ceilometer.Resource
api_resource_1 = ceilometer.Resource(resource_1)
api_resource_2 = ceilometer.Resource(resource_2)
api_resource_3 = ceilometer.Resource(resource_3)
api_resource_4 = ceilometer.Resource(resource_4)
TEST.api_resources.add(api_resource_1)
TEST.api_resources.add(api_resource_2)
TEST.api_resources.add(api_resource_3)
TEST.api_resources.add(api_resource_4)
# samples
sample_dict_1 = {
'resource_id': 'fake_resource_id',
'project_id': 'fake_project_id',
'user_id': 'fake_user_id',
'counter_name': 'image',
'counter_type': 'gauge',
'counter_unit': 'image',
'counter_volume': 1,
'timestamp': '2012-12-21T11:00:55.000000',
'metadata': {
'name1': 'value1',
'name2': 'value2'
},
'message_id': 'fake_message_id'
}
sample_dict_2 = {
'resource_id': 'fake_resource_id2',
'project_id': 'fake_project_id',
'user_id': 'fake_user_id',
'counter_name': 'image',
'counter_type': 'gauge',
'counter_unit': 'image',
'counter_volume': 1,
'timestamp': '2012-12-21T11:00:55.000000',
'metadata': {
'name1': 'value1',
'name2': 'value2'
},
'message_id': 'fake_message_id'
}
sample_1 = samples.Sample(samples.SampleManager(None), sample_dict_1)
sample_2 = samples.Sample(samples.SampleManager(None), sample_dict_2)
TEST.samples.add(sample_1)
TEST.samples.add(sample_2)
# alarms
alarm_dict_1 = {
'alarm_actions': ['alarm_action1', 'alarm_action2'],
'ok_actions': ['ok_action_1', 'ok_action_2'],
'name': 'fake_alarm_name',
'timestamp': '2015-08-07T05:32:20.970341',
'description': 'fake_random_description',
'time_constraints': [],
'enabled': True,
'state_timestamp': '2015-08-07T17:59:11.351033',
'threshold_rule': {
'meter_name': 'fake_meter_name',
'evaluation_periods': 1,
'period': 300,
'statistic': 'avg',
'threshold': 2.0,
'query': [],
'comparison_operator': 'ge',
'exclude_outliers': False
},
'alarm_id': 'fake_alarm_id',
'state': 'ok',
'insufficient_data_actions': ['fake_action_1', 'fake_action_2'],
'repeat_actions': True,
'user_id': 'fake_user_id',
'project_id': 'fake_project_id',
'type': 'threshold',
'severity': 'low'
}
alarm_dict_2 = {
'alarm_actions': ['alarm_action1', 'alarm_action2'],
'ok_actions': ['ok_action_1', 'ok_action_2'],
'name': 'fake_alarm_name',
'timestamp': '2015-08-07T05:32:20.970341',
'description': 'New',
'time_constraints': [],
'enabled': True,
'state_timestamp': '2015-08-07T17:59:11.351033',
'threshold_rule': {
'meter_name': 'fake_meter_name',
'evaluation_periods': 1,
'period': 300,
'statistic': 'avg',
'threshold': 2.0,
'query': [],
'comparison_operator': 'ge',
'exclude_outliers': False
},
'alarm_id': 'fake_alarm_id2',
'state': 'ok',
'insufficient_data_actions': ['fake_action_1', 'fake_action_2'],
'repeat_actions': True,
'user_id': 'fake_user_id',
'project_id': 'fake_project_id',
'type': 'threshold',
'severity': 'low'
}
alarm_dict_3 = {
'alarm_actions': ['alarm_action1', 'alarm_action2'],
'ok_actions': ['ok_action_1', 'ok_action_2'],
'name': 'fake_alarm_name',
'timestamp': '2015-08-07T05:32:20.970341',
'description': 'fake_random_description',
'time_constraints': [],
'enabled': True,
'state_timestamp': '2015-08-07T17:59:11.351033',
'threshold_rule': {
'meter_name': 'fake_meter_name',
'evaluation_periods': 2,
'period': 300,
'statistic': 'avg',
'threshold': 2.0,
'query': [{
'field': 'resource_id',
'value': ''
}],
'comparison_operator': 'ge',
'exclude_outliers': False
},
'alarm_id': 'fake_alarm_id3',
'state': 'ok',
'insufficient_data_actions': ['fake_action_1', 'fake_action_2'],
'repeat_actions': True,
'user_id': '',
'project_id': '',
'type': 'threshold',
'severity': 'low'
}
alarm_dict_4 = {
'alarm_actions': ['alarm_action1', 'alarm_action2'],
'ok_actions': ['ok_action_1', 'ok_action_2'],
'name': 'fake_alarm_name4',
'timestamp': '2015-08-07T05:32:20.970341',
'description': 'fake_random_description',
'time_constraints': [],
'enabled': True,
'state_timestamp': '2015-08-07T17:59:11.351033',
'threshold_rule': {
'meter_name': '',
'evaluation_periods': -10,
'period': -1,
'statistic': 'avg',
'threshold': '',
'query': [{
'field': 'resource_id',
'value': ''
}],
'comparison_operator': 'ge',
'exclude_outliers': False
},
'alarm_id': 'fake_alarm_id4',
'state': 'ok',
'insufficient_data_actions': ['fake_action_1', 'fake_action_2'],
'repeat_actions': True,
'user_id': 'fake_user_id',
'project_id': 'fake_project_id',
'type': 'threshold',
'severity': 'low'
}
alarm_1 = alarms.Alarm(alarms.AlarmManager(None), alarm_dict_1)
alarm_2 = alarms.Alarm(alarms.AlarmManager(None), alarm_dict_2)
alarm_3 = alarms.Alarm(alarms.AlarmManager(None), alarm_dict_3)
alarm_4 = alarms.Alarm(alarms.AlarmManager(None), alarm_dict_4)
TEST.alarms.add(alarm_1)
TEST.alarms.add(alarm_2)
TEST.alarms.add(alarm_3)
TEST.alarms.add(alarm_4)
# meters
meter_dict_1 = {
'name': 'instance',
'type': 'gauge',
'unit': 'instance',
'resource_id': 'fake_resource_id',
'project_id': 'fake_project_id',
'user_id': 'fake_user_id'
}
meter_dict_2 = {
'name': 'instance',
'type': 'gauge',
'unit': 'instance',
'resource_id': 'fake_resource_id',
'project_id': 'fake_project_id',
'user_id': 'fake_user_id'
}
meter_dict_3 = {
'name': 'disk.read.bytes',
'type': 'gauge',
'unit': 'instance',
'resource_id': 'fake_resource_id',
'project_id': 'fake_project_id',
'user_id': 'fake_user_id'
}
meter_dict_4 = {
'name': 'disk.write.bytes',
'type': 'gauge',
'unit': 'instance',
'resource_id': 'fake_resource_id',
'project_id': 'fake_project_id',
'user_id': 'fake_user_id'
}
meter_1 = meters.Meter(meters.MeterManager(None), meter_dict_1)
meter_2 = meters.Meter(meters.MeterManager(None), meter_dict_2)
meter_3 = meters.Meter(meters.MeterManager(None), meter_dict_3)
meter_4 = meters.Meter(meters.MeterManager(None), meter_dict_4)
TEST.meters.add(meter_1)
TEST.meters.add(meter_2)
TEST.meters.add(meter_3)
TEST.meters.add(meter_4)
# statistic
statistic_dict_1 = {
'min': 1,
'max': 9,
'avg': 4.55,
'sum': 45,
'count': 10,
'duration_start': '2012-12-21T11:00:55.000000',
'duration_end': '2012-12-21T11:00:55.000000',
'period': 7200,
'period_start': '2012-12-21T11:00:55.000000',
'period_end': '2012-12-21T11:00:55.000000'
}
statistic_1 = statistics.Statistics(statistics.StatisticsManager(None),
statistic_dict_1)
TEST.statistics.add(statistic_1)
def setUp(self):
super(TestRPCAlarmNotifier, self).setUp()
conf = service.prepare_service(argv=[], config_files=[])
self.CONF = self.useFixture(fixture_config.Config(conf)).conf
self.setup_messaging(self.CONF)
self.notifier_server = FakeNotifier(self.CONF, self.transport)
self.notifier = rpc.RPCAlarmNotifier(self.CONF)
self.alarms = [
alarms.Alarm(None,
info={
'name': 'instance_running_hot',
'meter_name': 'cpu_util',
'comparison_operator': 'gt',
'threshold': 80.0,
'evaluation_periods': 5,
'statistic': 'avg',
'state': 'ok',
'ok_actions': ['http://host:8080/path'],
'user_id': 'foobar',
'project_id': 'snafu',
'period': 60,
'alarm_id': str(uuid.uuid4()),
'severity': 'critical',
'matching_metadata': {
'resource_id': 'my_instance'
}
}),
alarms.Alarm(None,
info={
'name':
'group_running_idle',
'meter_name':
'cpu_util',
'comparison_operator':
'le',
'threshold':
10.0,
'statistic':
'max',
'evaluation_periods':
4,
'state':
'insufficient data',
'insufficient_data_actions':
['http://other_host/path'],
'user_id':
'foobar',
'project_id':
'snafu',
'period':
300,
'alarm_id':
str(uuid.uuid4()),
'severity':
'critical',
'matching_metadata': {
'metadata.user_metadata.AS': 'my_group'
}
}),
]
