def on_put(self, req, res, alarm_id):
helpers.validate_authorization(req, ['api:alarms:put'])
alarm = helpers.from_json(req)
schema_alarm.validate(alarm)
# Validator makes state optional, so check it here
if 'state' not in alarm or not alarm['state']:
raise HTTPUnprocessableEntityError('Unprocessable Entity',
"Field 'state' is required")
if 'lifecycle_state' not in alarm or not alarm['lifecycle_state']:
raise HTTPUnprocessableEntityError(
'Unprocessable Entity', "Field 'lifecycle_state' is required")
if 'link' not in alarm or not alarm['link']:
raise HTTPUnprocessableEntityError('Unprocessable Entity',
"Field 'link' is required")
self._alarm_update(req.project_id, alarm_id, alarm['state'],
alarm['lifecycle_state'], alarm['link'])
result = self._alarm_show(req.uri, req.project_id, alarm_id)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
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
def on_put(self, req, res, alarm_id):
helpers.validate_authorization(req, ['api:alarms:put'])
alarm = helpers.from_json(req)
schema_alarm.validate(alarm)
# Validator makes state optional, so check it here
if 'state' not in alarm or not alarm['state']:
raise HTTPUnprocessableEntityError('Unprocessable Entity',
"Field 'state' is required")
if 'lifecycle_state' not in alarm or not alarm['lifecycle_state']:
raise HTTPUnprocessableEntityError('Unprocessable Entity',
"Field 'lifecycle_state' is required")
if 'link' not in alarm or not alarm['link']:
raise HTTPUnprocessableEntityError('Unprocessable Entity',
"Field 'link' is required")
self._alarm_update(req.project_id, alarm_id, alarm['state'],
alarm['lifecycle_state'], alarm['link'])
result = self._alarm_show(req.uri, req.project_id, alarm_id)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def on_post(self, req, res):
helpers.validate_authorization(req, ['api:alarms:definition:post'])
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
def on_post(self, req, res):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, self._default_authorized_roles)
notification = helpers.from_json(req)
self._parse_and_validate_notification(notification)
result = self._create_notification(req.project_id, notification, req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_201
def on_post(self, req, res):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, self._default_authorized_roles)
notification = helpers.from_json(req)
self._parse_and_validate_notification(notification)
result = self._create_notification(req.project_id, notification,
req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_201
def on_put(self, req, res, notification_method_id):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, self._default_authorized_roles)
notification = helpers.from_json(req)
self._parse_and_validate_notification(notification, require_all=True)
result = self._update_notification(notification_method_id, req.project_id,
notification, req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def on_put(self, req, res, notification_method_id):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, self._default_authorized_roles)
notification = helpers.from_json(req)
self._parse_and_validate_notification(notification, require_all=True)
result = self._update_notification(notification_method_id,
req.project_id, notification,
req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def on_patch(self, req, res, notification_method_id):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, ['api:notifications:patch'])
notification = helpers.from_json(req)
self._patch_get_notification(req.project_id, notification_method_id, notification)
self._parse_and_validate_notification(notification, require_all=True)
result = self._update_notification(notification_method_id, req.project_id,
notification, req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def on_patch(self, req, res, notification_method_id):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, ['api:notifications:patch'])
notification = helpers.from_json(req)
self._patch_get_notification(req.project_id, notification_method_id,
notification)
self._parse_and_validate_notification(notification, require_all=True)
result = self._update_notification(notification_method_id,
req.project_id, notification,
req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def on_post(self, req, res):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req, ['api:metrics:post'])
metrics = helpers.from_json(req)
try:
metric_validation.validate(metrics)
except Exception as ex:
LOG.exception(ex)
raise HTTPUnprocessableEntityError("Unprocessable Entity", str(ex))
tenant_id = helpers.get_x_tenant_or_tenant_id(req, ['api:delegate'])
transformed_metrics = metrics_message.transform(
metrics, tenant_id, self._region)
self._send_metrics(transformed_metrics)
res.status = falcon.HTTP_204
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, ['api:alarms:definition:patch'])
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
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, ['api:alarms:definition:patch'])
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
def on_post(self, req, res):
helpers.validate_json_content_type(req)
helpers.validate_authorization(req,
self._post_metrics_authorized_roles)
metrics = helpers.from_json(req)
try:
metric_validation.validate(metrics)
except Exception as ex:
LOG.exception(ex)
raise HTTPUnprocessableEntityError("Unprocessable Entity", str(ex))
tenant_id = (
helpers.get_x_tenant_or_tenant_id(req,
self._delegate_authorized_roles))
transformed_metrics = metrics_message.transform(
metrics, tenant_id, self._region)
self._send_metrics(transformed_metrics)
res.status = falcon.HTTP_204
def on_put(self, req, res, alarm_definition_id=None):
if not alarm_definition_id:
raise HTTPUnprocessableEntityError(
'Unprocessable Entity', '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, req.uri)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def process_on_post_request(self, req, res):
try:
request_body = helpers.from_json(req)
log_list = self._get_logs(request_body)
global_dimensions = self._get_global_dimensions(request_body)
except Exception as ex:
LOG.error('Entire bulk package has been rejected')
LOG.exception(ex)
raise ex
tenant_id = (req.cross_project_id
if req.cross_project_id else req.project_id)
try:
self._processor.send_message(logs=log_list,
global_dimensions=global_dimensions,
log_tenant_id=tenant_id)
except Exception as ex:
res.status = getattr(ex, 'status', falcon.HTTP_500)
return
res.status = falcon.HTTP_204
def on_patch(self, req, res, alarm_id):
helpers.validate_authorization(req, ['api:alarms:patch'])
alarm = helpers.from_json(req)
schema_alarm.validate(alarm)
old_alarm = self._alarms_repo.get_alarm(req.project_id, alarm_id)[0]
# if a field is not present or is None, replace it with the old value
if 'state' not in alarm or not alarm['state']:
alarm['state'] = old_alarm['state']
if 'lifecycle_state' not in alarm or alarm['lifecycle_state'] is None:
alarm['lifecycle_state'] = old_alarm['lifecycle_state']
if 'link' not in alarm or alarm['link'] is None:
alarm['link'] = old_alarm['link']
self._alarm_patch(req.project_id, alarm_id, alarm['state'],
alarm['lifecycle_state'], alarm['link'])
result = self._alarm_show(req.uri, req.project_id, alarm_id)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def on_patch(self, req, res, alarm_id):
helpers.validate_authorization(req, ['api:alarms:patch'])
alarm = helpers.from_json(req)
schema_alarm.validate(alarm)
old_alarm = self._alarms_repo.get_alarm(req.project_id, alarm_id)[0]
# if a field is not present or is None, replace it with the old value
if 'state' not in alarm or not alarm['state']:
alarm['state'] = old_alarm['state']
if 'lifecycle_state' not in alarm or alarm['lifecycle_state'] is None:
alarm['lifecycle_state'] = old_alarm['lifecycle_state']
if 'link' not in alarm or alarm['link'] is None:
alarm['link'] = old_alarm['link']
self._alarm_patch(req.project_id, alarm_id, alarm['state'],
alarm['lifecycle_state'], alarm['link'])
result = self._alarm_show(req.uri, req.project_id, alarm_id)
res.body = helpers.to_json(result)
res.status = falcon.HTTP_200
def test_from_json(self):
body_json = {'test_body': 'test'}
req = request.Request(
testing.create_environ(body=rest_utils.as_json(body_json), ))
response = helpers.from_json(req)
self.assertEqual(body_json, response)
