# (C) Copyright 2014-2017 Hewlett Packard Enterprise Development LP # # 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 re import falcon from monasca_common.simport import simport from monasca_common.validation import metrics as metric_validation from oslo_config import cfg from oslo_log import log import pyparsing import six from monasca_api.api import alarm_definitions_api_v2 from monasca_api.common.repositories import exceptions import monasca_api.expression_parser.alarm_expr_parser from monasca_api.v2.common.exceptions import HTTPBadRequestError from monasca_api.v2.common.exceptions import HTTPUnprocessableEntityError from monasca_api.v2.common.schemas import ( alarm_definition_request_body_schema as schema_alarms) from monasca_api.v2.common import validation from monasca_api.v2.reference import alarming from monasca_api.v2.reference import helpers from monasca_api.v2.reference import resource LOG = log.getLogger(__name__) class AlarmDefinitions(alarm_definitions_api_v2.AlarmDefinitionsV2API, alarming.Alarming): def __init__(self): try: super(AlarmDefinitions, self).__init__() self._region = cfg.CONF.region self._default_authorized_roles = ( cfg.CONF.security.default_authorized_roles) self._get_alarmdefs_authorized_roles = ( cfg.CONF.security.default_authorized_roles + cfg.CONF.security.read_only_authorized_roles) self._alarm_definitions_repo = simport.load( cfg.CONF.repositories.alarm_definitions_driver)() except Exception as ex: LOG.exception(ex) raise exceptions.RepositoryException(ex) @resource.resource_try_catch_block def on_post(self, req, res): helpers.validate_authorization(req, self._default_authorized_roles) alarm_definition = helpers.from_json(req) self._validate_alarm_definition(alarm_definition) name = get_query_alarm_definition_name(alarm_definition) expression = get_query_alarm_definition_expression(alarm_definition) description = get_query_alarm_definition_description(alarm_definition) severity = get_query_alarm_definition_severity(alarm_definition) match_by = get_query_alarm_definition_match_by(alarm_definition) alarm_actions = get_query_alarm_definition_alarm_actions( alarm_definition) undetermined_actions = get_query_alarm_definition_undetermined_actions( alarm_definition) ok_actions = get_query_ok_actions(alarm_definition) result = self._alarm_definition_create(req.project_id, name, expression, description, severity, match_by, alarm_actions, undetermined_actions, ok_actions) helpers.add_links_to_resource(result, req.uri) res.body = helpers.to_json(result) res.status = falcon.HTTP_201 @resource.resource_try_catch_block def on_get(self, req, res, alarm_definition_id=None): if alarm_definition_id is None: helpers.validate_authorization(req, self._get_alarmdefs_authorized_roles) name = helpers.get_query_name(req) dimensions = helpers.get_query_dimensions(req) severity = helpers.get_query_param(req, "severity", default_val=None) if severity is not None: validation.validate_severity_query(severity) severity = severity.upper() sort_by = helpers.get_query_param(req, 'sort_by', default_val=None) if sort_by is not None: if isinstance(sort_by, six.string_types): sort_by = sort_by.split(',') allowed_sort_by = {'id', 'name', 'severity', 'updated_at', 'created_at'} validation.validate_sort_by(sort_by, allowed_sort_by) offset = helpers.get_query_param(req, 'offset') if offset is not None and not isinstance(offset, int): try: offset = int(offset) except Exception: raise HTTPUnprocessableEntityError('Unprocessable Entity', 'Offset value {} must be an integer'.format(offset)) result = self._alarm_definition_list(req.project_id, name, dimensions, severity, req.uri, sort_by, offset, req.limit) res.body = helpers.to_json(result) res.status = falcon.HTTP_200 else: helpers.validate_authorization(req, self._get_alarmdefs_authorized_roles) result = self._alarm_definition_show(req.project_id, alarm_definition_id) helpers.add_links_to_resource(result, re.sub('/' + alarm_definition_id, '', req.uri)) res.body = helpers.to_json(result) res.status = falcon.HTTP_200 @resource.resource_try_catch_block def on_put(self, req, res, alarm_definition_id=None): if not alarm_definition_id: raise HTTPBadRequestError('Bad Request', 'Alarm definition ID not provided') helpers.validate_authorization(req, self._default_authorized_roles) alarm_definition = helpers.from_json(req) self._validate_alarm_definition(alarm_definition, require_all=True) name = get_query_alarm_definition_name(alarm_definition) expression = get_query_alarm_definition_expression(alarm_definition) actions_enabled = ( get_query_alarm_definition_actions_enabled(alarm_definition)) description = get_query_alarm_definition_description(alarm_definition) alarm_actions = get_query_alarm_definition_alarm_actions(alarm_definition) ok_actions = get_query_ok_actions(alarm_definition) undetermined_actions = get_query_alarm_definition_undetermined_actions( alarm_definition) match_by = get_query_alarm_definition_match_by(alarm_definition) severity = get_query_alarm_definition_severity(alarm_definition) result = self._alarm_definition_update_or_patch(req.project_id, alarm_definition_id, name, expression, actions_enabled, description, alarm_actions, ok_actions, undetermined_actions, match_by, severity, patch=False) helpers.add_links_to_resource( result, re.sub('/' + alarm_definition_id, '', req.uri)) res.body = helpers.to_json(result) res.status = falcon.HTTP_200 @resource.resource_try_catch_block def on_patch(self, req, res, alarm_definition_id=None): if not alarm_definition_id: raise HTTPBadRequestError('Bad Request', 'Alarm definition ID not provided') helpers.validate_authorization(req, self._default_authorized_roles) alarm_definition = helpers.from_json(req) # Optional args name = get_query_alarm_definition_name(alarm_definition, return_none=True) expression = get_query_alarm_definition_expression(alarm_definition, return_none=True) actions_enabled = ( get_query_alarm_definition_actions_enabled(alarm_definition, return_none=True)) description = get_query_alarm_definition_description(alarm_definition, return_none=True) alarm_actions = get_query_alarm_definition_alarm_actions( alarm_definition, return_none=True) ok_actions = get_query_ok_actions(alarm_definition, return_none=True) undetermined_actions = get_query_alarm_definition_undetermined_actions( alarm_definition, return_none=True) match_by = get_query_alarm_definition_match_by(alarm_definition, return_none=True) severity = get_query_alarm_definition_severity(alarm_definition, return_none=True) result = self._alarm_definition_update_or_patch(req.project_id, alarm_definition_id, name, expression, actions_enabled, description, alarm_actions, ok_actions, undetermined_actions, match_by, severity, patch=True) helpers.add_links_to_resource( result, re.sub('/' + alarm_definition_id, '', req.uri)) res.body = helpers.to_json(result) res.status = falcon.HTTP_200 @resource.resource_try_catch_block def on_delete(self, req, res, alarm_definition_id=None): if not alarm_definition_id: raise HTTPBadRequestError('Bad Request', 'Alarm definition ID not provided') helpers.validate_authorization(req, self._default_authorized_roles) self._alarm_definition_delete(req.project_id, alarm_definition_id) res.status = falcon.HTTP_204 def _validate_name_not_conflicting(self, tenant_id, name, expected_id=None): definitions = self._alarm_definitions_repo.get_alarm_definitions(tenant_id=tenant_id, name=name, dimensions=None, severity=None, sort_by=None, offset=None, limit=0) if definitions: if not expected_id: LOG.warning("Found existing definition for {} with tenant_id {}".format(name, tenant_id)) raise exceptions.AlreadyExistsException("An alarm definition with the name {} already exists" .format(name)) found_definition_id = definitions[0]['id'] if found_definition_id != expected_id: LOG.warning("Found existing alarm definition for {} with tenant_id {} with unexpected id {}" .format(name, tenant_id, found_definition_id)) raise exceptions.AlreadyExistsException( "An alarm definition with the name {} already exists with id {}" .format(name, found_definition_id)) def _alarm_definition_show(self, tenant_id, id): alarm_definition_row = ( self._alarm_definitions_repo.get_alarm_definition(tenant_id, id)) return self._build_alarm_definition_show_result(alarm_definition_row) def _build_alarm_definition_show_result(self, alarm_definition_row): match_by = get_comma_separated_str_as_list( alarm_definition_row['match_by']) alarm_actions_list = get_comma_separated_str_as_list( alarm_definition_row['alarm_actions']) ok_actions_list = get_comma_separated_str_as_list( alarm_definition_row['ok_actions']) undetermined_actions_list = get_comma_separated_str_as_list( alarm_definition_row['undetermined_actions']) description = (alarm_definition_row['description'] if alarm_definition_row['description'] is not None else None) expression = alarm_definition_row['expression'] is_deterministic = is_definition_deterministic(expression) result = { u'actions_enabled': alarm_definition_row['actions_enabled'] == 1, u'alarm_actions': alarm_actions_list, u'undetermined_actions': undetermined_actions_list, u'ok_actions': ok_actions_list, u'description': description, u'expression': expression, u'deterministic': is_deterministic, u'id': alarm_definition_row['id'], u'match_by': match_by, u'name': alarm_definition_row['name'], u'severity': alarm_definition_row['severity'].upper() } return result def _alarm_definition_delete(self, tenant_id, id): sub_alarm_definition_rows = ( self._alarm_definitions_repo.get_sub_alarm_definitions(id)) alarm_metric_rows = self._alarm_definitions_repo.get_alarm_metrics( tenant_id, id) sub_alarm_rows = self._alarm_definitions_repo.get_sub_alarms( tenant_id, id) if not self._alarm_definitions_repo.delete_alarm_definition( tenant_id, id): raise falcon.HTTPNotFound self._send_alarm_definition_deleted_event(id, sub_alarm_definition_rows) self._send_alarm_event(u'alarm-deleted', tenant_id, id, alarm_metric_rows, sub_alarm_rows, None, None) def _alarm_definition_list(self, tenant_id, name, dimensions, severity, req_uri, sort_by, offset, limit): alarm_definition_rows = ( self._alarm_definitions_repo.get_alarm_definitions(tenant_id, name, dimensions, severity, sort_by, offset, limit)) result = [] for alarm_definition_row in alarm_definition_rows: match_by = get_comma_separated_str_as_list( alarm_definition_row['match_by']) alarm_actions_list = get_comma_separated_str_as_list( alarm_definition_row['alarm_actions']) ok_actions_list = get_comma_separated_str_as_list( alarm_definition_row['ok_actions']) undetermined_actions_list = get_comma_separated_str_as_list( alarm_definition_row['undetermined_actions']) expression = alarm_definition_row['expression'] is_deterministic = is_definition_deterministic(expression) ad = {u'id': alarm_definition_row['id'], u'name': alarm_definition_row['name'], u'description': alarm_definition_row['description'] if ( alarm_definition_row['description']) else u'', u'expression': alarm_definition_row['expression'], u'deterministic': is_deterministic, u'match_by': match_by, u'severity': alarm_definition_row['severity'].upper(), u'actions_enabled': alarm_definition_row['actions_enabled'] == 1, u'alarm_actions': alarm_actions_list, u'ok_actions': ok_actions_list, u'undetermined_actions': undetermined_actions_list} helpers.add_links_to_resource(ad, req_uri) result.append(ad) result = helpers.paginate_alarming(result, req_uri, limit) return result def _validate_alarm_definition(self, alarm_definition, require_all=False): try: schema_alarms.validate(alarm_definition, require_all=require_all) if 'match_by' in alarm_definition: for name in alarm_definition['match_by']: metric_validation.validate_dimension_key(name) except Exception as ex: LOG.debug(ex) raise HTTPUnprocessableEntityError('Unprocessable Entity', str(ex)) def _alarm_definition_update_or_patch(self, tenant_id, definition_id, name, expression, actions_enabled, description, alarm_actions, ok_actions, undetermined_actions, match_by, severity, patch): if expression: try: sub_expr_list = ( monasca_api.expression_parser.alarm_expr_parser. AlarmExprParser(expression).sub_expr_list) except (pyparsing.ParseException, pyparsing.ParseFatalException) as ex: LOG.exception(ex) title = "Invalid alarm expression".encode('utf8') msg = "parser failed on expression '{}' at column {}: {}".format( expression.encode('utf8'), str(ex.column).encode('utf8'), ex.msg.encode('utf8')) raise HTTPUnprocessableEntityError(title, msg) else: sub_expr_list = None if name: self._validate_name_not_conflicting(tenant_id, name, expected_id=definition_id) alarm_def_row, sub_alarm_def_dicts = ( self._alarm_definitions_repo.update_or_patch_alarm_definition( tenant_id, definition_id, name, expression, sub_expr_list, actions_enabled, description, alarm_actions, ok_actions, undetermined_actions, match_by, severity, patch)) old_sub_alarm_def_event_dict = ( self._build_sub_alarm_def_update_dict( sub_alarm_def_dicts['old'])) new_sub_alarm_def_event_dict = ( self._build_sub_alarm_def_update_dict(sub_alarm_def_dicts[ 'new'])) changed_sub_alarm_def_event_dict = ( self._build_sub_alarm_def_update_dict(sub_alarm_def_dicts[ 'changed'])) unchanged_sub_alarm_def_event_dict = ( self._build_sub_alarm_def_update_dict(sub_alarm_def_dicts[ 'unchanged'])) result = self._build_alarm_definition_show_result(alarm_def_row) # Not all of the passed in parameters will be set if this called # from on_patch vs on_update. The alarm-definition-updated event # MUST have all of the fields set so use the dict built from the # data returned from the database alarm_def_event_dict = ( {u'tenantId': tenant_id, u'alarmDefinitionId': definition_id, u'alarmName': result['name'], u'alarmDescription': result['description'], u'alarmExpression': result['expression'], u'severity': result['severity'], u'matchBy': result['match_by'], u'alarmActionsEnabled': result['actions_enabled'], u'oldAlarmSubExpressions': old_sub_alarm_def_event_dict, u'changedSubExpressions': changed_sub_alarm_def_event_dict, u'unchangedSubExpressions': unchanged_sub_alarm_def_event_dict, u'newAlarmSubExpressions': new_sub_alarm_def_event_dict}) alarm_definition_updated_event = ( {u'alarm-definition-updated': alarm_def_event_dict}) self.send_event(self.events_message_queue, alarm_definition_updated_event) return result def _build_sub_alarm_def_update_dict(self, sub_alarm_def_dict): sub_alarm_def_update_dict = {} for id, sub_alarm_def in sub_alarm_def_dict.items(): dimensions = {} for name, value in sub_alarm_def.dimensions.items(): dimensions[u'uname'] = value sub_alarm_def_update_dict[sub_alarm_def.id] = {} sub_alarm_def_update_dict[sub_alarm_def.id][u'function'] = ( sub_alarm_def.function) sub_alarm_def_update_dict[sub_alarm_def.id][ u'metricDefinition'] = ( {u'name': sub_alarm_def.metric_name, u'dimensions': dimensions}) sub_alarm_def_update_dict[sub_alarm_def.id][u'operator'] = ( sub_alarm_def.operator) sub_alarm_def_update_dict[sub_alarm_def.id][u'threshold'] = ( sub_alarm_def.threshold) sub_alarm_def_update_dict[sub_alarm_def.id][u'period'] = ( sub_alarm_def.period) sub_alarm_def_update_dict[sub_alarm_def.id][u'periods'] = ( sub_alarm_def.periods) sub_alarm_def_update_dict[sub_alarm_def.id][u'expression'] = ( sub_alarm_def.expression) return sub_alarm_def_update_dict def _alarm_definition_create(self, tenant_id, name, expression, description, severity, match_by, alarm_actions, undetermined_actions, ok_actions): try: sub_expr_list = ( monasca_api.expression_parser.alarm_expr_parser. AlarmExprParser(expression).sub_expr_list) except (pyparsing.ParseException, pyparsing.ParseFatalException) as ex: LOG.exception(ex) title = "Invalid alarm expression".encode('utf8') msg = "parser failed on expression '{}' at column {}: {}".format( expression.encode('utf8'), str(ex.column).encode('utf8'), ex.msg.encode('utf8')) raise HTTPUnprocessableEntityError(title, msg) self._validate_name_not_conflicting(tenant_id, name) alarm_definition_id = ( self._alarm_definitions_repo. create_alarm_definition(tenant_id, name, expression, sub_expr_list, description, severity, match_by, alarm_actions, undetermined_actions, ok_actions)) self._send_alarm_definition_created_event(tenant_id, alarm_definition_id, name, expression, sub_expr_list, description, match_by) result = ( {u'alarm_actions': alarm_actions, u'ok_actions': ok_actions, u'description': description, u'match_by': match_by, u'severity': severity, u'actions_enabled': True, u'undetermined_actions': undetermined_actions, u'expression': expression, u'id': alarm_definition_id, u'deterministic': is_definition_deterministic(expression), u'name': name}) return result def _send_alarm_definition_deleted_event(self, alarm_definition_id, sub_alarm_definition_rows): sub_alarm_definition_deleted_event_msg = {} alarm_definition_deleted_event_msg = {u"alarm-definition-deleted": { u"alarmDefinitionId": alarm_definition_id, u'subAlarmMetricDefinitions': sub_alarm_definition_deleted_event_msg}} for sub_alarm_definition in sub_alarm_definition_rows: sub_alarm_definition_deleted_event_msg[ sub_alarm_definition['id']] = { u'name': sub_alarm_definition['metric_name']} dimensions = {} sub_alarm_definition_deleted_event_msg[sub_alarm_definition['id']][ u'dimensions'] = dimensions if sub_alarm_definition['dimensions']: for dimension in sub_alarm_definition['dimensions'].split(','): parsed_dimension = dimension.split('=') dimensions[parsed_dimension[0]] = parsed_dimension[1] self.send_event(self.events_message_queue, alarm_definition_deleted_event_msg) def _send_alarm_definition_created_event(self, tenant_id, alarm_definition_id, name, expression, sub_expr_list, description, match_by): alarm_definition_created_event_msg = { u'alarm-definition-created': {u'tenantId': tenant_id, u'alarmDefinitionId': alarm_definition_id, u'alarmName': name, u'alarmDescription': description, u'alarmExpression': expression, u'matchBy': match_by}} sub_expr_event_msg = {} for sub_expr in sub_expr_list: sub_expr_event_msg[sub_expr.id] = { u'function': sub_expr.normalized_func} metric_definition = {u'name': sub_expr.normalized_metric_name} sub_expr_event_msg[sub_expr.id][ u'metricDefinition'] = metric_definition dimensions = {} for dimension in sub_expr.dimensions_as_list: parsed_dimension = dimension.split("=") dimensions[parsed_dimension[0]] = parsed_dimension[1] metric_definition[u'dimensions'] = dimensions sub_expr_event_msg[sub_expr.id][ u'operator'] = sub_expr.normalized_operator sub_expr_event_msg[sub_expr.id][u'threshold'] = sub_expr.threshold sub_expr_event_msg[sub_expr.id][u'period'] = sub_expr.period sub_expr_event_msg[sub_expr.id][u'periods'] = sub_expr.periods sub_expr_event_msg[sub_expr.id][ u'expression'] = sub_expr.fmtd_sub_expr_str alarm_definition_created_event_msg[u'alarm-definition-created'][ u'alarmSubExpressions'] = sub_expr_event_msg self.send_event(self.events_message_queue, alarm_definition_created_event_msg) def get_query_alarm_definition_name(alarm_definition, return_none=False): try: if 'name' in alarm_definition: name = alarm_definition['name'] return name else: if return_none: return None else: raise Exception("Missing name") except Exception as ex: LOG.debug(ex) raise HTTPUnprocessableEntityError('Unprocessable Entity', str(ex)) def get_query_alarm_definition_expression(alarm_definition, return_none=False): try: if 'expression' in alarm_definition: expression = alarm_definition['expression'] return expression else: if return_none: return None else: raise Exception("Missing expression") except Exception as ex: LOG.debug(ex) raise HTTPUnprocessableEntityError('Unprocessable Entity', str(ex)) def get_query_alarm_definition_description(alarm_definition, return_none=False): if 'description' in alarm_definition: return alarm_definition['description'] else: if return_none: return None else: return '' def get_query_alarm_definition_severity(alarm_definition, return_none=False): if 'severity' in alarm_definition: severity = alarm_definition['severity'] severity = severity.decode('utf8').upper() if severity not in ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']: raise HTTPUnprocessableEntityError('Unprocessable Entity', 'Invalid severity') return severity else: if return_none: return None else: return 'LOW' def get_query_alarm_definition_match_by(alarm_definition, return_none=False): if 'match_by' in alarm_definition: match_by = alarm_definition['match_by'] return match_by else: if return_none: return None else: return [] def get_query_alarm_definition_alarm_actions(alarm_definition, return_none=False): if 'alarm_actions' in alarm_definition: alarm_actions = alarm_definition['alarm_actions'] return alarm_actions else: if return_none: return None else: return [] def get_query_alarm_definition_undetermined_actions(alarm_definition, return_none=False): if 'undetermined_actions' in alarm_definition: undetermined_actions = alarm_definition['undetermined_actions'] return undetermined_actions else: if return_none: return None else: return [] def get_query_ok_actions(alarm_definition, return_none=False): if 'ok_actions' in alarm_definition: ok_actions = alarm_definition['ok_actions'] return ok_actions else: if return_none: return None else: return [] def get_query_alarm_definition_actions_enabled(alarm_definition, required=False, return_none=False): try: if 'actions_enabled' in alarm_definition: enabled_actions = alarm_definition['actions_enabled'] return enabled_actions else: if return_none: return None elif required: raise Exception("Missing actions-enabled") else: return '' except Exception as ex: LOG.debug(ex) raise HTTPUnprocessableEntityError('Unprocessable Entity', str(ex)) def get_comma_separated_str_as_list(comma_separated_str): if not comma_separated_str: return [] else: return comma_separated_str.decode('utf8').split(',') def is_definition_deterministic(expression): """Evaluates if found expression is deterministic or not. In order to do that expression is parsed into sub expressions. Each sub expression needs to be deterministic in order for entity expression to be such. Otherwise expression is non-deterministic. :param str expression: expression to be evaluated :return: true/false :rtype: bool """ expr_parser = (monasca_api.expression_parser .alarm_expr_parser.AlarmExprParser(expression)) sub_expressions = expr_parser.sub_expr_list for sub_expr in sub_expressions: if not sub_expr.deterministic: return False return True