942 lines
40 KiB
Python
942 lines
40 KiB
Python
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
|
|
import datetime
|
|
|
|
import mox
|
|
from oslo_utils import timeutils
|
|
|
|
from heat.common import exception
|
|
from heat.engine import stack
|
|
from heat.engine import template
|
|
from heat.engine import watchrule
|
|
from heat.objects import watch_rule
|
|
from heat.tests import common
|
|
from heat.tests import utils
|
|
|
|
|
|
class WatchData(object):
|
|
def __init__(self, data, created_at):
|
|
self.created_at = created_at
|
|
self.data = {'test_metric': {'Value': data,
|
|
'Unit': 'Count'}}
|
|
|
|
|
|
class DummyAction(object):
|
|
signal = "DummyAction"
|
|
|
|
|
|
class WatchRuleTest(common.HeatTestCase):
|
|
stack_id = None
|
|
|
|
def setUpDatabase(self):
|
|
if self.stack_id is not None:
|
|
return
|
|
# Create a dummy stack in the DB as WatchRule instances
|
|
# must be associated with a stack
|
|
ctx = utils.dummy_context()
|
|
ctx.auth_token = 'abcd1234'
|
|
empty_tmpl = {'HeatTemplateFormatVersion': '2012-12-12'}
|
|
tmpl = template.Template(empty_tmpl)
|
|
stack_name = 'dummystack'
|
|
dummy_stack = stack.Stack(ctx, stack_name, tmpl)
|
|
dummy_stack.state_set(dummy_stack.CREATE, dummy_stack.COMPLETE,
|
|
'Testing')
|
|
dummy_stack.store()
|
|
|
|
self.stack_id = dummy_stack.id
|
|
|
|
def setUp(self):
|
|
super(WatchRuleTest, self).setUp()
|
|
self.setUpDatabase()
|
|
self.username = 'watchrule_test_user'
|
|
|
|
self.ctx = utils.dummy_context()
|
|
self.ctx.auth_token = 'abcd1234'
|
|
|
|
self.m.ReplayAll()
|
|
|
|
def _action_set_stubs(self, now, action_expected=True):
|
|
# Setup stubs for the action tests
|
|
timeutils.set_time_override(now)
|
|
self.addCleanup(timeutils.clear_time_override)
|
|
|
|
if action_expected:
|
|
dummy_action = DummyAction()
|
|
self.m.StubOutWithMock(stack.Stack, 'resource_by_refid')
|
|
stack.Stack.resource_by_refid(
|
|
mox.IgnoreArg()).MultipleTimes().AndReturn(dummy_action)
|
|
|
|
self.m.ReplayAll()
|
|
|
|
def test_minimum(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Minimum',
|
|
'ComparisonOperator': 'LessThanOrEqualToThreshold',
|
|
'Threshold': '50'}
|
|
|
|
now = timeutils.utcnow()
|
|
last = now - datetime.timedelta(seconds=320)
|
|
data = [WatchData(77, now - datetime.timedelta(seconds=100))]
|
|
data.append(WatchData(53, now - datetime.timedelta(seconds=150)))
|
|
|
|
# all > 50 -> NORMAL
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('NORMAL', new_state)
|
|
|
|
data.append(WatchData(25, now - datetime.timedelta(seconds=250)))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('ALARM', new_state)
|
|
|
|
def test_maximum(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
last = now - datetime.timedelta(seconds=320)
|
|
data = [WatchData(7, now - datetime.timedelta(seconds=100))]
|
|
data.append(WatchData(23, now - datetime.timedelta(seconds=150)))
|
|
|
|
# all < 30 -> NORMAL
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('NORMAL', new_state)
|
|
|
|
data.append(WatchData(35, now - datetime.timedelta(seconds=150)))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('ALARM', new_state)
|
|
|
|
def test_samplecount(self):
|
|
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'SampleCount',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '3'}
|
|
|
|
now = timeutils.utcnow()
|
|
last = now - datetime.timedelta(seconds=320)
|
|
data = [WatchData(1, now - datetime.timedelta(seconds=100))]
|
|
data.append(WatchData(1, now - datetime.timedelta(seconds=150)))
|
|
|
|
# only 2 samples -> NORMAL
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('NORMAL', new_state)
|
|
|
|
# only 3 samples -> ALARM
|
|
data.append(WatchData(1, now - datetime.timedelta(seconds=200)))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('ALARM', new_state)
|
|
|
|
# only 3 samples (one old) -> NORMAL
|
|
data.pop(0)
|
|
data.append(WatchData(1, now - datetime.timedelta(seconds=400)))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('NORMAL', new_state)
|
|
|
|
def test_sum(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Sum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '100'}
|
|
|
|
now = timeutils.utcnow()
|
|
last = now - datetime.timedelta(seconds=320)
|
|
data = [WatchData(17, now - datetime.timedelta(seconds=100))]
|
|
data.append(WatchData(23, now - datetime.timedelta(seconds=150)))
|
|
|
|
# all < 40 -> NORMAL
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('NORMAL', new_state)
|
|
|
|
# sum > 100 -> ALARM
|
|
data.append(WatchData(85, now - datetime.timedelta(seconds=150)))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('ALARM', new_state)
|
|
|
|
def test_ave(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Average',
|
|
'ComparisonOperator': 'GreaterThanThreshold',
|
|
'Threshold': '100'}
|
|
|
|
now = timeutils.utcnow()
|
|
last = now - datetime.timedelta(seconds=320)
|
|
data = [WatchData(117, now - datetime.timedelta(seconds=100))]
|
|
data.append(WatchData(23, now - datetime.timedelta(seconds=150)))
|
|
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('NORMAL', new_state)
|
|
|
|
data.append(WatchData(195, now - datetime.timedelta(seconds=250)))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=data,
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
self.wr.now = now
|
|
new_state = self.wr.get_alarm_state()
|
|
self.assertEqual('ALARM', new_state)
|
|
|
|
def test_load(self):
|
|
# Insert two dummy watch rules into the DB
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmActions': [u'WebServerRestartPolicy'],
|
|
u'AlarmDescription': u'Restart the WikiDatabase',
|
|
u'Namespace': u'system/linux',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'MetricName': u'ServiceFailure'}
|
|
self.wr = []
|
|
self.wr.append(watchrule.WatchRule(context=self.ctx,
|
|
watch_name='HttpFailureAlarm',
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
state='NORMAL'))
|
|
self.wr[0].store()
|
|
|
|
self.wr.append(watchrule.WatchRule(context=self.ctx,
|
|
watch_name='AnotherWatch',
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
state='NORMAL'))
|
|
self.wr[1].store()
|
|
|
|
# Then use WatchRule.load() to retrieve each by name
|
|
# and check that the object properties match the data above
|
|
for wn in ('HttpFailureAlarm', 'AnotherWatch'):
|
|
wr = watchrule.WatchRule.load(self.ctx, wn)
|
|
self.assertIsInstance(wr, watchrule.WatchRule)
|
|
self.assertEqual(wn, wr.name)
|
|
self.assertEqual('NORMAL', wr.state)
|
|
self.assertEqual(rule, wr.rule)
|
|
self.assertEqual(datetime.timedelta(seconds=int(rule['Period'])),
|
|
wr.timeperiod)
|
|
|
|
def test_store(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmActions': [u'WebServerRestartPolicy'],
|
|
u'AlarmDescription': u'Restart the WikiDatabase',
|
|
u'Namespace': u'system/linux',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'MetricName': u'ServiceFailure'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
dbwr = watch_rule.WatchRule.get_by_name(self.ctx, 'storetest')
|
|
self.assertIsNotNone(dbwr)
|
|
self.assertEqual('storetest', dbwr.name)
|
|
self.assertEqual(watchrule.WatchRule.NODATA, dbwr.state)
|
|
self.assertEqual(rule, dbwr.rule)
|
|
|
|
def test_evaluate(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
timeutils.set_time_override(now)
|
|
self.addCleanup(timeutils.clear_time_override)
|
|
|
|
# It's not time to evaluate, so should stay NODATA
|
|
last = now - datetime.timedelta(seconds=299)
|
|
data = WatchData(25, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('NODATA', self.wr.state)
|
|
self.assertEqual([], actions)
|
|
|
|
# now - last == Period, so should set NORMAL
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(25, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('NORMAL', self.wr.state)
|
|
self.assertEqual(now, self.wr.last_evaluated)
|
|
self.assertEqual([], actions)
|
|
|
|
# Now data breaches Threshold, so should set ALARM
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(35, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('ALARM', self.wr.state)
|
|
self.assertEqual(now, self.wr.last_evaluated)
|
|
self.assertEqual([], actions)
|
|
|
|
def test_evaluate_suspend(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
timeutils.set_time_override(now)
|
|
self.addCleanup(timeutils.clear_time_override)
|
|
|
|
# Now data breaches Threshold, but we're suspended
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(35, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
self.wr.state_set(self.wr.SUSPENDED)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual(self.wr.SUSPENDED, self.wr.state)
|
|
self.assertEqual([], actions)
|
|
|
|
def test_evaluate_ceilometer_controlled(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
timeutils.set_time_override(now)
|
|
self.addCleanup(timeutils.clear_time_override)
|
|
|
|
# Now data breaches Threshold, but we're suspended
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(35, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
self.wr.state_set(self.wr.CEILOMETER_CONTROLLED)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual(self.wr.CEILOMETER_CONTROLLED, self.wr.state)
|
|
self.assertEqual([], actions)
|
|
|
|
def test_rule_actions_alarm_normal(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
self._action_set_stubs(now, action_expected=False)
|
|
|
|
# Set data so rule evaluates to NORMAL state
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(25, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('NORMAL', self.wr.state)
|
|
self.assertEqual([], actions)
|
|
self.m.VerifyAll()
|
|
|
|
def test_rule_actions_alarm_alarm(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
self._action_set_stubs(now)
|
|
|
|
# Set data so rule evaluates to ALARM state
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(35, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('ALARM', self.wr.state)
|
|
self.assertEqual(['DummyAction'], actions)
|
|
|
|
# re-set last_evaluated so the rule will be evaluated again.
|
|
last = now - datetime.timedelta(seconds=300)
|
|
self.wr.last_evaluated = last
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('ALARM', self.wr.state)
|
|
self.assertEqual(['DummyAction'], actions)
|
|
self.m.VerifyAll()
|
|
|
|
def test_rule_actions_alarm_two_actions(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction', 'AnotherDummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
self._action_set_stubs(now)
|
|
|
|
# Set data so rule evaluates to ALARM state
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(35, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('ALARM', self.wr.state)
|
|
self.assertEqual(['DummyAction', 'DummyAction'], actions)
|
|
self.m.VerifyAll()
|
|
|
|
def test_rule_actions_ok_alarm(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'OKActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
self._action_set_stubs(now, action_expected=False)
|
|
|
|
# On creation the rule evaluates to NODATA state
|
|
last = now - datetime.timedelta(seconds=300)
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('NODATA', self.wr.state)
|
|
self.assertEqual([], actions)
|
|
|
|
# Move time forward and add data below threshold so we transition from
|
|
# ALARM -> NORMAL, so evaluate() should output a 'DummyAction'
|
|
now = now + datetime.timedelta(seconds=300)
|
|
self.m.VerifyAll()
|
|
self.m.UnsetStubs()
|
|
self._action_set_stubs(now)
|
|
|
|
data = WatchData(25, now - datetime.timedelta(seconds=150))
|
|
self.wr.watch_data = [data]
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('NORMAL', self.wr.state)
|
|
self.assertEqual(['DummyAction'], actions)
|
|
self.m.VerifyAll()
|
|
|
|
def test_rule_actions_nodata(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'InsufficientDataActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
self._action_set_stubs(now, action_expected=False)
|
|
|
|
# Set data so rule evaluates to ALARM state
|
|
last = now - datetime.timedelta(seconds=300)
|
|
data = WatchData(35, now - datetime.timedelta(seconds=150))
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[data],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('ALARM', self.wr.state)
|
|
self.assertEqual([], actions)
|
|
|
|
# Move time forward and don't add data so we transition from
|
|
# ALARM -> NODATA, so evaluate() should output a 'DummyAction'
|
|
now = now + datetime.timedelta(seconds=300)
|
|
self.m.VerifyAll()
|
|
self.m.UnsetStubs()
|
|
self._action_set_stubs(now)
|
|
|
|
actions = self.wr.evaluate()
|
|
self.assertEqual('NODATA', self.wr.state)
|
|
self.assertEqual(['DummyAction'], actions)
|
|
self.m.VerifyAll()
|
|
|
|
def test_to_ceilometer(self):
|
|
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'MetricName': u'CreateDataMetric'}
|
|
testdata = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1"}}
|
|
sample = dict()
|
|
sample['counter_type'] = 'gauge'
|
|
|
|
for k, d in iter(testdata.items()):
|
|
if k == 'Namespace':
|
|
continue
|
|
sample['counter_name'] = k
|
|
sample['counter_volume'] = d['Value']
|
|
sample['counter_unit'] = d['Unit']
|
|
dims = d.get('Dimensions', {})
|
|
if isinstance(dims, list):
|
|
dims = dims[0]
|
|
sample['resource_metadata'] = dims
|
|
sample['resource_id'] = dims.get('InstanceId')
|
|
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
self.m.StubOutWithMock(self.wr.context.clients.client('ceilometer').
|
|
samples, 'create', True)
|
|
|
|
# fake samples.create callback
|
|
def fake_create(counter_type, counter_name, counter_volume,
|
|
counter_unit, resource_metadata, resource_id):
|
|
pass
|
|
|
|
self.wr.context.clients.client('ceilometer').samples.\
|
|
create(**sample).MultipleTimes().WithSideEffects(fake_create)
|
|
self.m.ReplayAll()
|
|
try:
|
|
self.wr._to_ceilometer(testdata)
|
|
except mox.UnexpectedMethodCallError:
|
|
raise KeyError("Error input parameter")
|
|
|
|
def test_create_watch_data(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
|
|
self.wr.store()
|
|
|
|
data = {u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": []}}
|
|
self.wr.create_watch_data(data)
|
|
|
|
obj_wr = watch_rule.WatchRule.get_by_name(self.ctx, 'create_data_test')
|
|
obj_wds = [wd for wd in obj_wr.watch_data]
|
|
self.assertEqual(data, obj_wds[0].data)
|
|
|
|
# Note, would be good to write another datapoint and check it
|
|
# but sqlite seems to not interpret the backreference correctly
|
|
# so dbwr.watch_data is always a list containing only the latest
|
|
# datapoint. In non-test use on mysql this is not the case, we
|
|
# correctly get a list of all datapoints where watch_rule_id ==
|
|
# watch_rule.id, so leave it as a single-datapoint test for now.
|
|
|
|
def test_create_watch_data_suspended(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule,
|
|
state=watchrule.WatchRule.SUSPENDED)
|
|
|
|
self.wr.store()
|
|
|
|
data = {u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": []}}
|
|
self.wr.create_watch_data(data)
|
|
|
|
obj_wr = watch_rule.WatchRule.get_by_name(self.ctx, 'create_data_test')
|
|
obj_wds = [wd for wd in obj_wr.watch_data]
|
|
self.assertEqual([], obj_wds)
|
|
|
|
def test_create_watch_data_match(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'Dimensions': [{u'Name': 'AutoScalingGroupName',
|
|
u'Value': 'group_x'}],
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
data = {u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [{u'AutoScalingGroupName':
|
|
u'group_x'}]}}
|
|
self.assertTrue(watchrule.rule_can_use_sample(self.wr, data))
|
|
|
|
def test_create_watch_data_match_2(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'Dimensions': [{u'Name': 'AutoScalingGroupName',
|
|
u'Value': 'group_x'}],
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
data = {u'not_interesting': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'group_x'}]},
|
|
u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'group_x'}]}}
|
|
self.assertTrue(watchrule.rule_can_use_sample(self.wr, data))
|
|
|
|
def test_create_watch_data_match_3(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'Dimensions': [{u'Name': 'AutoScalingGroupName',
|
|
u'Value': 'group_x'}],
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
data = {u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'not_this'}]},
|
|
u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'group_x'}]}}
|
|
self.assertTrue(watchrule.rule_can_use_sample(self.wr, data))
|
|
|
|
def test_create_watch_data_not_match_metric(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'Dimensions': [{u'Name': 'AutoScalingGroupName',
|
|
u'Value': 'group_x'}],
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
data = {u'not_this': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'group_x'}]},
|
|
u'nor_this': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'group_x'}]}}
|
|
self.assertFalse(watchrule.rule_can_use_sample(self.wr, data))
|
|
|
|
def test_create_watch_data_not_match_dimensions(self):
|
|
rule = {u'EvaluationPeriods': u'1',
|
|
u'AlarmDescription': u'test alarm',
|
|
u'Period': u'300',
|
|
u'ComparisonOperator': u'GreaterThanThreshold',
|
|
u'Statistic': u'SampleCount',
|
|
u'Threshold': u'2',
|
|
u'Dimensions': [{u'Name': 'AutoScalingGroupName',
|
|
u'Value': 'group_x'}],
|
|
u'MetricName': u'CreateDataMetric'}
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name='create_data_test',
|
|
stack_id=self.stack_id, rule=rule)
|
|
self.wr.store()
|
|
|
|
data = {u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'AutoScalingGroupName':
|
|
u'not_this'}]},
|
|
u'CreateDataMetric': {"Unit": "Counter",
|
|
"Value": "1",
|
|
"Dimensions": [
|
|
{u'wrong_key':
|
|
u'group_x'}]}}
|
|
self.assertFalse(watchrule.rule_can_use_sample(self.wr, data))
|
|
|
|
def test_destroy(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
last = timeutils.utcnow()
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch_destroy",
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
self.wr.store()
|
|
|
|
check = watchrule.WatchRule.load(context=self.ctx,
|
|
watch_name="testwatch_destroy")
|
|
self.assertIsInstance(check, watchrule.WatchRule)
|
|
|
|
self.wr.destroy()
|
|
self.assertRaises(exception.WatchRuleNotFound,
|
|
watchrule.WatchRule.load, context=self.ctx,
|
|
watch_name="testwatch_destroy")
|
|
|
|
def test_state_set(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
last = timeutils.utcnow()
|
|
watcher = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch_set_state",
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
watcher.state_set(watcher.SUSPENDED)
|
|
self.assertEqual(watcher.SUSPENDED, watcher.state)
|
|
|
|
check = watchrule.WatchRule.load(context=self.ctx,
|
|
watch_name="testwatch_set_state")
|
|
self.assertEqual(watchrule.WatchRule.SUSPENDED, check.state)
|
|
|
|
def test_set_watch_state(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
self._action_set_stubs(now)
|
|
|
|
# Set data so rule evaluates to ALARM state
|
|
last = now - datetime.timedelta(seconds=200)
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
actions = self.wr.set_watch_state(watchrule.WatchRule.NODATA)
|
|
self.assertEqual([], actions)
|
|
|
|
actions = self.wr.set_watch_state(watchrule.WatchRule.NORMAL)
|
|
self.assertEqual([], actions)
|
|
|
|
actions = self.wr.set_watch_state(watchrule.WatchRule.ALARM)
|
|
self.assertEqual(['DummyAction'], actions)
|
|
self.m.VerifyAll()
|
|
|
|
def test_set_watch_state_invalid(self):
|
|
rule = {'EvaluationPeriods': '1',
|
|
'MetricName': 'test_metric',
|
|
'AlarmActions': ['DummyAction'],
|
|
'Period': '300',
|
|
'Statistic': 'Maximum',
|
|
'ComparisonOperator': 'GreaterThanOrEqualToThreshold',
|
|
'Threshold': '30'}
|
|
|
|
now = timeutils.utcnow()
|
|
|
|
last = now - datetime.timedelta(seconds=200)
|
|
self.wr = watchrule.WatchRule(context=self.ctx,
|
|
watch_name="testwatch",
|
|
rule=rule,
|
|
watch_data=[],
|
|
stack_id=self.stack_id,
|
|
last_evaluated=last)
|
|
|
|
self.assertRaises(ValueError, self.wr.set_watch_state, None)
|
|
|
|
self.assertRaises(ValueError, self.wr.set_watch_state, "BADSTATE")
|