162 lines
6.4 KiB
Python
162 lines
6.4 KiB
Python
# Copyright 2014 Hewlett-Packard
|
|
#
|
|
# 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 json
|
|
|
|
import falcon
|
|
|
|
import collections
|
|
|
|
from monasca_events_api.api import monasca_events_api_v2
|
|
from monasca_events_api.common.messaging import exceptions as message_queue_exceptions
|
|
from monasca_events_api.common.messaging.message_formats import events_transform_factory
|
|
from monasca_events_api.common import resource_api
|
|
from monasca_events_api.openstack.common import log
|
|
from monasca_events_api.v2.common.schemas import (
|
|
events_request_body_schema as schemas_event)
|
|
from monasca_events_api.v2.common.schemas import exceptions as schemas_exceptions
|
|
from monasca_events_api.v2.common import utils
|
|
from monasca_events_api.v2.reference import helpers
|
|
from monasca_events_api.v2.reference import resource
|
|
|
|
from oslo.config import cfg
|
|
|
|
LOG = log.getLogger(__name__)
|
|
|
|
|
|
class Events(monasca_events_api_v2.EventsV2API):
|
|
|
|
def __init__(self, global_conf):
|
|
|
|
super(Events, self).__init__(global_conf)
|
|
|
|
self._region = cfg.CONF.region
|
|
self._default_authorized_roles = (
|
|
cfg.CONF.security.default_authorized_roles)
|
|
self._delegate_authorized_roles = (
|
|
cfg.CONF.security.delegate_authorized_roles)
|
|
self._post_events_authorized_roles = (
|
|
cfg.CONF.security.default_authorized_roles +
|
|
cfg.CONF.security.agent_authorized_roles)
|
|
self._event_transform = (
|
|
events_transform_factory.create_events_transform())
|
|
self._message_queue = (
|
|
resource_api.init_driver('monasca_events_api.messaging',
|
|
cfg.CONF.messaging.driver,
|
|
['raw-events']))
|
|
self._events_repo = resource_api.init_driver(
|
|
'monasca_events_api.repositories', cfg.CONF.repositories.events_driver)
|
|
|
|
def _validate_event(self, event):
|
|
"""Validates the event
|
|
|
|
:param event: An event object.
|
|
:raises falcon.HTTPBadRequest
|
|
"""
|
|
try:
|
|
schemas_event.validate(event)
|
|
except schemas_exceptions.ValidationException as ex:
|
|
LOG.debug(ex)
|
|
raise falcon.HTTPBadRequest('Bad request', ex.message)
|
|
|
|
def _send_event(self, event):
|
|
"""Send the event using the message queue.
|
|
|
|
:param metrics: An event object.
|
|
:raises: falcon.HTTPServiceUnavailable
|
|
"""
|
|
try:
|
|
str_msg = json.dumps(event, default=utils.date_handler,
|
|
ensure_ascii=False).encode('utf8')
|
|
self._message_queue.send_message(str_msg)
|
|
except message_queue_exceptions.MessageQueueException as ex:
|
|
LOG.exception(ex)
|
|
raise falcon.HTTPInternalServerError('Service unavailable',
|
|
ex.message)
|
|
|
|
@resource.resource_try_catch_block
|
|
def _list_events(self, tenant_id, uri, offset, limit):
|
|
rows = self._events_repo.list_events(tenant_id, offset, limit)
|
|
return helpers.paginate(self._build_events(rows), uri, offset)
|
|
|
|
@resource.resource_try_catch_block
|
|
def _list_event(self, tenant_id, event_id, uri):
|
|
rows = self._events_repo.list_event(tenant_id, event_id)
|
|
return self._build_events(rows)
|
|
|
|
def _build_events(self, rows):
|
|
result = collections.OrderedDict()
|
|
for row in rows:
|
|
event_id, event_data = self._build_event_data(row)
|
|
|
|
if event_id['id'] in result:
|
|
result[event_id['id']]['data'].update(event_data)
|
|
else:
|
|
result[event_id['id']] = {'id': event_id['id'],
|
|
'description': event_id['desc'],
|
|
'generated': event_id['generated'],
|
|
'data': event_data}
|
|
return result.values()
|
|
|
|
def _build_event_data(self, event_row):
|
|
event_data = {}
|
|
name = event_row['name']
|
|
|
|
if event_row['t_string']:
|
|
event_data[name] = event_row['t_string']
|
|
if event_row['t_int']:
|
|
event_data[name] = event_row['t_int']
|
|
if event_row['t_float']:
|
|
event_data[name] = event_row['t_float']
|
|
if event_row['t_datetime']:
|
|
event_data[name] = float(event_row['t_datetime'])
|
|
|
|
event_id = {'id': event_row['message_id'],
|
|
'desc': event_row['desc'],
|
|
'generated': float(event_row['generated'])}
|
|
|
|
return event_id, event_data
|
|
|
|
@resource_api.Restify('/v2.0/events', method='post')
|
|
def do_post_events(self, req, res):
|
|
helpers.validate_json_content_type(req)
|
|
helpers.validate_authorization(req, self._post_events_authorized_roles)
|
|
event = helpers.read_http_resource(req)
|
|
self._validate_event(event)
|
|
tenant_id = helpers.get_tenant_id(req)
|
|
transformed_event = self._event_transform(event, tenant_id,
|
|
self._region)
|
|
self._send_event(transformed_event)
|
|
res.status = falcon.HTTP_204
|
|
|
|
@resource_api.Restify('/v2.0/events', method='get')
|
|
def do_get_events(self, req, res):
|
|
helpers.validate_authorization(req, self._default_authorized_roles)
|
|
tenant_id = helpers.get_tenant_id(req)
|
|
offset = helpers.normalize_offset(helpers.get_query_param(req,
|
|
'offset'))
|
|
limit = helpers.get_query_param(req, 'limit')
|
|
|
|
result = self._list_events(tenant_id, req.uri, offset, limit)
|
|
res.body = helpers.dumpit_utf8(result)
|
|
res.status = falcon.HTTP_200
|
|
|
|
@resource_api.Restify('/v2.0/events/{id}', method='get')
|
|
def do_get_event(self, req, res, id):
|
|
helpers.validate_authorization(req, self._default_authorized_roles)
|
|
tenant_id = helpers.get_tenant_id(req)
|
|
result = self._list_event(tenant_id, id, req.uri)
|
|
res.body = helpers.dumpit_utf8(result)
|
|
res.status = falcon.HTTP_200
|