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) dbwr = db_api.watch_rule_get_by_name(self.ctx, "create_data_test") self.assertEqual(dbwr.watch_data, [])
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'} wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) wr.store() data = {u'CreateDataMetric': {"Unit": "Counter", "Value": "1", "Dimensions": []}} wr.create_watch_data(data) dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test') self.assertEqual(dbwr.watch_data[0].data, 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. # Cleanup db_api.watch_rule_delete(self.ctx, 'create_data_test')
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' } wr = watchrule.WatchRule(context=self.ctx, watch_name='storetest', stack_id=self.stack_id, rule=rule) wr.store() dbwr = db_api.watch_rule_get_by_name(self.ctx, 'storetest') self.assertNotEqual(dbwr, None) self.assertEqual(dbwr.name, 'storetest') self.assertEqual(dbwr.state, watchrule.WatchRule.NODATA) self.assertEqual(dbwr.rule, rule) # Cleanup db_api.watch_rule_delete(self.ctx, 'storetest')
def load(cls, context, watch_name=None, watch=None): ''' Load the watchrule object, either by name or via an existing DB object ''' if watch is None: try: watch = db_api.watch_rule_get_by_name(context, watch_name) except Exception as ex: LOG.warn( _('WatchRule.load (%(watch_name)s) db error ' '%(ex)s') % { 'watch_name': watch_name, 'ex': ex }) if watch is None: raise exception.WatchRuleNotFound(watch_name=watch_name) else: return cls(context=context, watch_name=watch.name, rule=watch.rule, stack_id=watch.stack_id, state=watch.state, wid=watch.id, watch_data=watch.watch_data, last_evaluated=watch.last_evaluated)
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) dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test') self.assertEqual([], dbwr.watch_data)
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.eng.show_watch_metric(self.ctx, metric_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.eng.show_watch_metric(self.ctx, metric_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_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.eng.show_watch_metric(self.ctx, metric_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.eng.show_watch_metric(self.ctx, metric_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_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 = db_api.watch_rule_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_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 = db_api.watch_rule_get_by_name(self.ctx, "storetest") self.assertNotEqual(dbwr, None) self.assertEqual(dbwr.name, "storetest") self.assertEqual(dbwr.state, watchrule.WatchRule.NODATA) self.assertEqual(dbwr.rule, rule)
def load(cls, context, watch_name): ''' Load the watchrule from the DB by name ''' dbwr = None try: dbwr = db_api.watch_rule_get_by_name(context, watch_name) except Exception as ex: logger.warn('show_watch (%s) db error %s' % (watch_name, str(ex))) if not dbwr: raise AttributeError('Unknown watch name %s' % watch_name) else: return cls(context=context, watch_name=dbwr.name, rule=dbwr.rule, stack_name=dbwr.stack_name, state=dbwr.state, wid=dbwr.id, watch_data=dbwr.watch_data, last_evaluated=dbwr.last_evaluated)
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) dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test') self.assertEqual(data, dbwr.watch_data[0].data)
def load(cls, context, watch_name): ''' Load the watchrule from the DB by name ''' dbwr = None try: dbwr = db_api.watch_rule_get_by_name(context, watch_name) except Exception as ex: logger.warn('show_watch (%s) db error %s' % (watch_name, str(ex))) if not dbwr: raise AttributeError('Unknown watch name %s' % watch_name) else: return cls(context=context, watch_name=dbwr.name, rule=dbwr.rule, stack_name=dbwr.stack_name, state=dbwr.state, wid=dbwr.id, watch_data=dbwr.watch_data, last_evaluated=dbwr.last_evaluated)
def load(cls, context, watch_name=None, watch=None): ''' Load the watchrule object, either by name or via an existing DB object ''' if watch is None: try: watch = db_api.watch_rule_get_by_name(context, watch_name) except Exception as ex: logger.warn('WatchRule.load (%s) db error %s' % (watch_name, str(ex))) if watch is None: raise exception.WatchRuleNotFound(watch_name=watch_name) else: return cls(context=context, watch_name=watch.name, rule=watch.rule, stack_id=watch.stack_id, state=watch.state, wid=watch.id, watch_data=watch.watch_data, last_evaluated=watch.last_evaluated)
def load(cls, context, watch_name=None, watch=None): ''' Load the watchrule object, either by name or via an existing DB object ''' if watch == None: try: watch = db_api.watch_rule_get_by_name(context, watch_name) except Exception as ex: logger.warn('WatchRule.load (%s) db error %s' % (watch_name, str(ex))) if watch == None: raise AttributeError('Unknown watch name %s' % watch_name) else: return cls(context=context, watch_name=watch.name, rule=watch.rule, stack_id=watch.stack_id, state=watch.state, wid=watch.id, watch_data=watch.watch_data, last_evaluated=watch.last_evaluated)
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' } wr = watchrule.WatchRule(context=self.ctx, watch_name='create_data_test', stack_id=self.stack_id, rule=rule) wr.store() data = { u'CreateDataMetric': { "Unit": "Counter", "Value": "1", "Dimensions": [] } } wr.create_watch_data(data) dbwr = db_api.watch_rule_get_by_name(self.ctx, 'create_data_test') self.assertEqual(dbwr.watch_data[0].data, 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. # Cleanup db_api.watch_rule_delete(self.ctx, 'create_data_test')
def get_by_name(cls, context, watch_rule_name): db_rule = db_api.watch_rule_get_by_name(context, watch_rule_name) return cls._from_db_object(context, cls(), db_rule)
def get_by_name(cls, context, watch_rule_name): db_rule = db_api.watch_rule_get_by_name(context, watch_rule_name) return cls._from_db_object(context, cls(), db_rule)