Exemple #1
0
    def test_load(self):
        # Insert two dummy watch rules into the DB
        values = {'stack_id': self.stack_id,
                  'state': 'NORMAL',
                  'name': u'HttpFailureAlarm',
                  '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)
        values['name'] = 'AnotherWatch'
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # 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.assertEqual(type(wr), watchrule.WatchRule)
            self.assertEqual(wr.name, wn)
            self.assertEqual(wr.state, values['state'])
            self.assertEqual(wr.rule, values['rule'])
            self.assertEqual(wr.timeperiod, datetime.timedelta(
                             seconds=int(values['rule']['Period'])))

        # Cleanup
        db_api.watch_rule_delete(self.ctx, 'HttpFailureAlarm')
        db_api.watch_rule_delete(self.ctx, 'AnotherWatch')
Exemple #2
0
    def test_load(self):
        # Insert two dummy watch rules into the DB
        values = {'stack_id': self.stack_id,
                  'state': 'NORMAL',
                  'name': u'HttpFailureAlarm',
                  '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)
        values['name'] = 'AnotherWatch'
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # 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.assertEqual(type(wr), watchrule.WatchRule)
            self.assertEqual(wr.name, wn)
            self.assertEqual(wr.state, values['state'])
            self.assertEqual(wr.rule, values['rule'])
            self.assertEqual(wr.timeperiod, datetime.timedelta(
                             seconds=int(values['rule']['Period'])))

        # Cleanup
        db_api.watch_rule_delete(self.ctx, 'HttpFailureAlarm')
        db_api.watch_rule_delete(self.ctx, 'AnotherWatch')
Exemple #3
0
    def test_set_watch_state_badstate(self):
        # Insert dummy watch rule into the DB
        values = {
            'stack_id': self.stack.id,
            'state': 'NORMAL',
            'name': u'OverrideAlarm2',
            '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'
            }
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        for state in ["HGJHGJHG", "1234", "!\*(&%"]:
            self.assertRaises(ValueError,
                              self.man.set_watch_state,
                              self.ctx,
                              watch_name="OverrideAlarm2",
                              state=state)

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm2")
Exemple #4
0
    def test_set_watch_state_badstate(self):
        # Insert dummy watch rule into the DB
        values = {'stack_name': u'wordpress_ha', 'state': 'NORMAL',
                  'name': u'OverrideAlarm2',
                   '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        for state in ["HGJHGJHG", "1234", "!\*(&%"]:
            self.assertRaises(AttributeError,
                              self.man.set_watch_state,
                              self.ctx, watch_name="OverrideAlarm2",
                              state=state)

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm2")
Exemple #5
0
    def test_set_watch_state(self):
        # Insert dummy watch rule into the DB
        values = {'stack_name': u'wordpress_ha', 'state': 'NORMAL',
                  'name': u'OverrideAlarm',
                   '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        for state in watchrule.WatchRule.WATCH_STATES:
            result = self.man.set_watch_state(self.ctx,
                                              watch_name="OverrideAlarm",
                                              state=state)
            self.assertNotEqual(result, None)
            self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm")
    def test_set_watch_state_badstate(self):
        # Insert dummy watch rule into the DB
        values = {
            "stack_name": u"wordpress_ha",
            "state": "NORMAL",
            "name": u"OverrideAlarm2",
            "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",
            },
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        for state in ["HGJHGJHG", "1234", "!\*(&%"]:
            self.assertRaises(
                AttributeError, self.man.set_watch_state, self.ctx, watch_name="OverrideAlarm2", state=state
            )

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm2")
    def test_set_watch_state(self):
        # Insert dummy watch rule into the DB
        values = {
            "stack_name": u"wordpress_ha",
            "state": "NORMAL",
            "name": u"OverrideAlarm",
            "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",
            },
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        for state in watchrule.WatchRule.WATCH_STATES:
            result = self.man.set_watch_state(self.ctx, watch_name="OverrideAlarm", state=state)
            self.assertNotEqual(result, None)
            self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm")
Exemple #8
0
    def test_set_watch_state(self):
        # Insert dummy watch rule into the DB
        values = {
            'stack_id': self.stack.id,
            'state': 'NORMAL',
            'name': u'OverrideAlarm',
            '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'
            }
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        class DummyAction:
            alarm = "dummyfoo"

        dummy_action = DummyAction()
        self.m.StubOutWithMock(parser.Stack, '__getitem__')
        parser.Stack.__getitem__('WebServerRestartPolicy').AndReturn(
            dummy_action)

        # Replace the real stack threadgroup with a dummy one, so we can
        # check the function returned on ALARM is correctly scheduled
        self.man.stg[self.stack.id] = DummyThreadGroup()

        self.m.ReplayAll()

        state = watchrule.WatchRule.NODATA
        result = self.man.set_watch_state(self.ctx,
                                          watch_name="OverrideAlarm",
                                          state=state)
        self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)
        self.assertEqual(self.man.stg[self.stack.id].threads, [])

        state = watchrule.WatchRule.NORMAL
        result = self.man.set_watch_state(self.ctx,
                                          watch_name="OverrideAlarm",
                                          state=state)
        self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)
        self.assertEqual(self.man.stg[self.stack.id].threads, [])

        state = watchrule.WatchRule.ALARM
        result = self.man.set_watch_state(self.ctx,
                                          watch_name="OverrideAlarm",
                                          state=state)
        self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)
        self.assertEqual(self.man.stg[self.stack.id].threads,
                         [DummyAction.alarm])

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm")
Exemple #9
0
    def test_show_watch(self):
        # Insert two dummy watch rules into the DB
        values = {
            'stack_id': self.stack.id,
            'state': 'NORMAL',
            'name': u'HttpFailureAlarm',
            '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'
            }
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)
        values['name'] = "AnotherWatch"
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # watch_name=None should return both watches
        result = self.man.show_watch(self.ctx, watch_name=None)
        self.assertEqual(2, len(result))

        # watch_name="HttpFailureAlarm" should return only one
        result = self.man.show_watch(self.ctx, watch_name="HttpFailureAlarm")
        self.assertEqual(1, len(result))

        self.assertRaises(exception.WatchRuleNotFound,
                          self.man.show_watch,
                          self.ctx,
                          watch_name="nonexistent")

        # Check the response has all keys defined in the engine API
        for key in engine_api.WATCH_KEYS:
            self.assertTrue(key in result[0])

        # Cleanup, delete the dummy rules
        db_api.watch_rule_delete(self.ctx, "HttpFailureAlarm")
        db_api.watch_rule_delete(self.ctx, "AnotherWatch")
Exemple #10
0
    def test_show_watch_metric(self):
        # Insert dummy watch rule into the DB
        values = {
            'stack_id': self.stack.id,
            'state': 'NORMAL',
            'name': u'HttpFailureAlarm',
            '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'
            }
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # And add a metric datapoint
        watch = db_api.watch_rule_get_by_name(self.ctx, "HttpFailureAlarm")
        self.assertNotEqual(watch, None)
        values = {
            'watch_rule_id': watch.id,
            'data': {
                u'Namespace': u'system/linux',
                u'ServiceFailure': {
                    u'Units': u'Counter',
                    u'Value': 1
                }
            }
        }
        watch = db_api.watch_data_create(self.ctx, values)

        # Check there is one result returned
        result = self.man.show_watch_metric(self.ctx,
                                            namespace=None,
                                            metric_name=None)
        self.assertEqual(1, len(result))

        # Create another metric datapoint and check we get two
        watch = db_api.watch_data_create(self.ctx, values)
        result = self.man.show_watch_metric(self.ctx,
                                            namespace=None,
                                            metric_name=None)
        self.assertEqual(2, len(result))

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "HttpFailureAlarm")

        # Check the response has all keys defined in the engine API
        for key in engine_api.WATCH_DATA_KEYS:
            self.assertTrue(key in result[0])
    def test_set_watch_state(self):
        # Insert dummy watch rule into the DB
        values = {'stack_id': self.stack.id,
                  'state': 'NORMAL',
                  'name': u'OverrideAlarm',
                  '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        class DummyAction:
            alarm = "dummyfoo"

        dummy_action = DummyAction()
        self.m.StubOutWithMock(parser.Stack, '__getitem__')
        parser.Stack.__getitem__(
            'WebServerRestartPolicy').AndReturn(dummy_action)

        # Replace the real stack threadgroup with a dummy one, so we can
        # check the function returned on ALARM is correctly scheduled
        self.man.stg[self.stack.id] = DummyThreadGroup()

        self.m.ReplayAll()

        state = watchrule.WatchRule.NODATA
        result = self.man.set_watch_state(self.ctx,
                                          watch_name="OverrideAlarm",
                                          state=state)
        self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)
        self.assertEqual(self.man.stg[self.stack.id].threads, [])

        state = watchrule.WatchRule.NORMAL
        result = self.man.set_watch_state(self.ctx,
                                          watch_name="OverrideAlarm",
                                          state=state)
        self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)
        self.assertEqual(self.man.stg[self.stack.id].threads, [])

        state = watchrule.WatchRule.ALARM
        result = self.man.set_watch_state(self.ctx,
                                          watch_name="OverrideAlarm",
                                          state=state)
        self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)
        self.assertEqual(self.man.stg[self.stack.id].threads,
                         [DummyAction.alarm])

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm")
    def test_show_watch(self):
        # Insert two dummy watch rules into the DB
        values = {'stack_id': self.stack.id,
                  'state': 'NORMAL',
                  'name': u'HttpFailureAlarm',
                   '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)
        values['name'] = "AnotherWatch"
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # watch_name=None should return both watches
        result = self.man.show_watch(self.ctx, watch_name=None)
        self.assertEqual(2, len(result))

        # watch_name="HttpFailureAlarm" should return only one
        result = self.man.show_watch(self.ctx, watch_name="HttpFailureAlarm")
        self.assertEqual(1, len(result))

        # watch_name="nonexistent" should raise an AttributeError
        self.assertRaises(AttributeError,
                          self.man.show_watch,
                          self.ctx, watch_name="nonexistent")

        # Check the response has all keys defined in the engine API
        for key in engine_api.WATCH_KEYS:
            self.assertTrue(key in result[0])

        # Cleanup, delete the dummy rules
        db_api.watch_rule_delete(self.ctx, "HttpFailureAlarm")
        db_api.watch_rule_delete(self.ctx, "AnotherWatch")
Exemple #13
0
    def test_show_watch(self):
        # Insert two dummy watch rules into the DB
        values = {
            "stack_name": u"wordpress_ha",
            "state": "NORMAL",
            "name": u"HttpFailureAlarm",
            "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",
            },
        }
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)
        values["name"] = "AnotherWatch"
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # watch_name=None should return both watches
        result = self.man.show_watch(self.ctx, watch_name=None)
        self.assertEqual(2, len(result))

        # watch_name="HttpFailureAlarm" should return only one
        result = self.man.show_watch(self.ctx, watch_name="HttpFailureAlarm")
        self.assertEqual(1, len(result))

        # watch_name="nonexistent" should raise an AttributeError
        self.assertRaises(AttributeError, self.man.show_watch, self.ctx, watch_name="nonexistent")

        # Check the response has all keys defined in the engine API
        for key in engine_api.WATCH_KEYS:
            self.assertTrue(key in result[0])
    def test_show_watch_metric(self):
        # Insert dummy watch rule into the DB
        values = {'stack_id': self.stack.id,
                  'state': 'NORMAL',
                  'name': u'HttpFailureAlarm',
                   '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        # And add a metric datapoint
        watch = db_api.watch_rule_get_by_name(self.ctx, "HttpFailureAlarm")
        self.assertNotEqual(watch, None)
        values = {'watch_rule_id': watch.id,
                  'data': {
                        u'Namespace': u'system/linux',
                        u'ServiceFailure': {
                            u'Units': u'Counter', u'Value': 1}}}
        watch = db_api.watch_data_create(self.ctx, values)

        # Check there is one result returned
        result = self.man.show_watch_metric(self.ctx, namespace=None,
                                            metric_name=None)
        self.assertEqual(1, len(result))

        # Create another metric datapoint and check we get two
        watch = db_api.watch_data_create(self.ctx, values)
        result = self.man.show_watch_metric(self.ctx, namespace=None,
                                            metric_name=None)
        self.assertEqual(2, len(result))

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "HttpFailureAlarm")

        # Check the response has all keys defined in the engine API
        for key in engine_api.WATCH_DATA_KEYS:
            self.assertTrue(key in result[0])
    def test_set_watch_state(self):
        # Insert dummy watch rule into the DB
        values = {'stack_id': self.stack.id,
                  'state': 'NORMAL',
                  'name': u'OverrideAlarm',
                   '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'}}
        db_ret = db_api.watch_rule_create(self.ctx, values)
        self.assertNotEqual(db_ret, None)

        class DummyAction:
            alarm = "dummyfoo"

        self.m.StubOutWithMock(parser.Stack, '__getitem__')
        parser.Stack.__getitem__(
            'WebServerRestartPolicy').AndReturn(DummyAction())

        self.m.StubOutWithMock(watchrule.greenpool, 'spawn_n')
        watchrule.greenpool.spawn_n("dummyfoo").AndReturn(None)
        self.m.ReplayAll()

        for state in watchrule.WatchRule.WATCH_STATES:

            result = self.man.set_watch_state(self.ctx,
                                              watch_name="OverrideAlarm",
                                              state=state)
            self.assertNotEqual(result, None)
            self.assertEqual(result[engine_api.WATCH_STATE_VALUE], state)

        # Cleanup, delete the dummy rule
        db_api.watch_rule_delete(self.ctx, "OverrideAlarm")