osm_mon/plugins/OpenStack/response.py

   1 # Copyright 2017 Intel Research and Development Ireland Limited
   2 # *************************************************************
   3
   4 # This file is part of OSM Monitoring module
   5 # All Rights Reserved to Intel Corporation
   6
   7 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   8 # not use this file except in compliance with the License. You may obtain
   9 # a copy of the License at
  10
  11 #         http://www.apache.org/licenses/LICENSE-2.0
  12
  13 # Unless required by applicable law or agreed to in writing, software
  14 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  16 # License for the specific language governing permissions and limitations
  17 # under the License.
  18
  19 # For those usages not covered by the Apache License, Version 2.0 please
  20 # contact: helena.mcgough@intel.com or adrian.hoban@intel.com
  21 ##
  22 """Generate valid responses to send back to the SO."""
  23
  24 import json
  25 import logging
  26 log = logging.getLogger(__name__)
  27
  28 __author__ = "Helena McGough"
  29
  30 schema_version = "1.0"
  31
  32
  33 class OpenStack_Response(object):
  34     """Generates responses for SO from OpenStaack plugins."""
  35
  36     def __init__(self):
  37         """Initialize OpenStack Response instance."""
  38
  39     def generate_response(self, key, **kwargs):
  40         """Make call to appropriate response function."""
  41         if key == "list_alarm_response":
  42             message = self.alarm_list_response(**kwargs)
  43         elif key == "create_alarm_response":
  44             message = self.create_alarm_response(**kwargs)
  45         elif key == "delete_alarm_response":
  46             message = self.delete_alarm_response(**kwargs)
  47         elif key == "update_alarm_response":
  48             message = self.update_alarm_response(**kwargs)
  49         elif key == "create_metric_response":
  50             message = self.metric_create_response(**kwargs)
  51         elif key == "read_metric_data_response":
  52             message = self.read_metric_data_response(**kwargs)
  53         elif key == "delete_metric_response":
  54             message = self.delete_metric_response(**kwargs)
  55         elif key == "update_metric_response":
  56             message = self.update_metric_response(**kwargs)
  57         elif key == "list_metric_response":
  58             message = self.list_metric_response(**kwargs)
  59         elif key == "notify_alarm":
  60             message = self.notify_alarm(**kwargs)
  61         else:
  62             log.warn("Failed to generate a valid response message.")
  63             message = None
  64
  65         return message
  66
  67     def alarm_list_response(self, **kwargs):
  68         """Generate the response for an alarm list request."""
  69         alarm_list_resp = {"schema_version": schema_version,
  70                            "schema_type": "list_alarm_response",
  71                            "correlation_id": kwargs['cor_id'],
  72                            "list_alarm_resp": kwargs['alarm_list']}
  73         return json.dumps(alarm_list_resp)
  74
  75     def create_alarm_response(self, **kwargs):
  76         """Generate a response for a create alarm request."""
  77         create_alarm_resp = {"schema_version": schema_version,
  78                              "schema_type": "create_alarm_response",
  79                              "alarm_create_response": {
  80                                  "correlation_id": kwargs['cor_id'],
  81                                  "alarm_uuid": kwargs['alarm_id'],
  82                                  "status": kwargs['status']}}
  83         return json.dumps(create_alarm_resp)
  84
  85     def delete_alarm_response(self, **kwargs):
  86         """Generate a response for a delete alarm request."""
  87         delete_alarm_resp = {"schema_version": schema_version,
  88                              "schema_type": "alarm_deletion_response",
  89                              "alarm_deletion_response": {
  90                                  "correlation_id": kwargs['cor_id'],
  91                                  "alarm_uuid": kwargs['alarm_id'],
  92                                  "status": kwargs['status']}}
  93         return json.dumps(delete_alarm_resp)
  94
  95     def update_alarm_response(self, **kwargs):
  96         """Generate a response for an update alarm request."""
  97         update_alarm_resp = {"schema_version": schema_version,
  98                              "schema_type": "update_alarm_response",
  99                              "alarm_update_response": {
 100                                  "correlation_id": kwargs['cor_id'],
 101                                  "alarm_uuid": kwargs['alarm_id'],
 102                                  "status": kwargs['status']}}
 103         return json.dumps(update_alarm_resp)
 104
 105     def metric_create_response(self, **kwargs):
 106         """Generate a response for a create metric request."""
 107         create_metric_resp = {"schema_version": schema_version,
 108                               "schema_type": "create_metric_response",
 109                               "correlation_id": kwargs['cor_id'],
 110                               "metric_create_response": {
 111                                   "metric_uuid": kwargs['metric_id'],
 112                                   "resource_uuid": kwargs['r_id'],
 113                                   "status": kwargs['status']}}
 114         return json.dumps(create_metric_resp)
 115
 116     def read_metric_data_response(self, **kwargs):
 117         """Generate a response for a read metric data request."""
 118         read_metric_data_resp = {"schema_version": schema_version,
 119                                  "schema_type": "read_metric_data_response",
 120                                  "metric_name": kwargs['m_name'],
 121                                  "metric_uuid": kwargs['m_id'],
 122                                  "resource_uuid": kwargs['r_id'],
 123                                  "correlation_id": kwargs['cor_id'],
 124                                  "metrics_data": {
 125                                      "time_series": kwargs['times'],
 126                                      "metrics_series": kwargs['metrics']}}
 127         return json.dumps(read_metric_data_resp)
 128
 129     def delete_metric_response(self, **kwargs):
 130         """Generate a response for a delete metric request."""
 131         delete_metric_resp = {"schema_version": schema_version,
 132                               "schema_type": "delete_metric_response",
 133                               "metric_name": kwargs['m_name'],
 134                               "metric_uuid": kwargs['m_id'],
 135                               "resource_uuid": kwargs['r_id'],
 136                               "correlation_id": kwargs['cor_id'],
 137                               "status": kwargs['status']}
 138         return json.dumps(delete_metric_resp)
 139
 140     def update_metric_response(self, **kwargs):
 141         """Generate a repsonse for an update metric request."""
 142         update_metric_resp = {"schema_version": schema_version,
 143                               "schema_type": "update_metric_response",
 144                               "correlation_id": kwargs['cor_id'],
 145                               "metric_update_response": {
 146                                   "metric_uuid": kwargs['m_id'],
 147                                   "status": kwargs['status'],
 148                                   "resource_uuid": kwargs['r_id']}}
 149         return json.dumps(update_metric_resp)
 150
 151     def list_metric_response(self, **kwargs):
 152         """Generate a response for a list metric request."""
 153         list_metric_resp = {"schema_version": schema_version,
 154                             "schema_type": "list_metric_response",
 155                             "correlation_id": kwargs['cor_id'],
 156                             "metrics_list": kwargs['m_list']}
 157         return json.dumps(list_metric_resp)
 158
 159     def notify_alarm(self, **kwargs):
 160         """Generate a response to send alarm notifications."""
 161         notify_alarm_resp = {"schema_version": schema_version,
 162                              "schema_type": "notify_alarm",
 163                              "notify_details": {
 164                                  "alarm_uuid": kwargs['a_id'],
 165                                  "resource_uuid": kwargs['r_id'],
 166                                  "vim_type": kwargs['vim_type'],
 167                                  "severity": kwargs['sev'],
 168                                  "status": kwargs['state'],
 169                                  "start_date": kwargs['date']}}
 170         return json.dumps(notify_alarm_resp)