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 as log
  26
  27 __author__ = "Helena McGough"
  28
  29 schema_version = "1.0"
  30
  31
  32 class OpenStack_Response(object):
  33     """Generates responses for SO from OpenStaack plugins."""
  34
  35     def __init__(self):
  36         """Initialize OpenStack Response instance."""
  37
  38     def generate_response(self, key, **kwargs):
  39         """Make call to appropriate response function."""
  40         if key == "list_alarm_response":
  41             message = self.alarm_list_response(**kwargs)
  42         elif key == "create_alarm_response":
  43             message = self.create_alarm_response(**kwargs)
  44         elif key == "delete_alarm_response":
  45             message = self.delete_alarm_response(**kwargs)
  46         elif key == "update_alarm_response":
  47             message = self.update_alarm_response(**kwargs)
  48         elif key == "create_metric_response":
  49             message = self.metric_create_response(**kwargs)
  50         elif key == "read_metric_data_response":
  51             message = self.read_metric_data_response(**kwargs)
  52         elif key == "delete_metric_response":
  53             message = self.delete_metric_response(**kwargs)
  54         elif key == "update_metric_response":
  55             message = self.update_metric_response(**kwargs)
  56         elif key == "list_metric_response":
  57             message = self.list_metric_response(**kwargs)
  58         elif key == "notify_alarm":
  59             message = self.notify_alarm(**kwargs)
  60         else:
  61             log.warn("Failed to generate a valid response message.")
  62
  63         return message
  64
  65     def alarm_list_response(self, **kwargs):
  66         """Generate the response for an alarm list request."""
  67         alarm_list_resp = {"schema_version": schema_version,
  68                            "schema_type": "list_alarm_response",
  69                            "correlation_id": kwargs['cor_id'],
  70                            "list_alarm_resp": kwargs['alarm_list']}
  71         return json.dumps(alarm_list_resp)
  72
  73     def create_alarm_response(self, **kwargs):
  74         """Generate a response for a create alarm request."""
  75         create_alarm_resp = {"schema_version": schema_version,
  76                              "schema_type": "create_alarm_response",
  77                              "alarm_create_response": {
  78                                  "correlation_id": kwargs['cor_id'],
  79                                  "alarm_uuid": kwargs['alarm_id'],
  80                                  "status": kwargs['status']}}
  81         return json.dumps(create_alarm_resp)
  82
  83     def delete_alarm_response(self, **kwargs):
  84         """Generate a response for a delete alarm request."""
  85         delete_alarm_resp = {"schema_version": schema_version,
  86                              "schema_type": "alarm_deletion_response",
  87                              "alarm_deletion_response": {
  88                                  "correlation_id": kwargs['cor_id'],
  89                                  "alarm_uuid": kwargs['alarm_id'],
  90                                  "status": kwargs['status']}}
  91         return json.dumps(delete_alarm_resp)
  92
  93     def update_alarm_response(self, **kwargs):
  94         """Generate a response for an update alarm request."""
  95         update_alarm_resp = {"schema_version": schema_version,
  96                              "schema_type": "update_alarm_response",
  97                              "alarm_update_response": {
  98                                  "correlation_id": kwargs['cor_id'],
  99                                  "alarm_uuid": kwargs['alarm_id'],
 100                                  "status": kwargs['status']}}
 101         return json.dumps(update_alarm_resp)
 102
 103     def metric_create_response(self, **kwargs):
 104         """Generate a response for a create metric request."""
 105         create_metric_resp = {"schema_version": schema_version,
 106                               "schema_type": "create_metric_response",
 107                               "correlation_id": kwargs['cor_id'],
 108                               "metric_create_response": {
 109                                   "metric_uuid": kwargs['metric_id'],
 110                                   "resource_uuid": kwargs['r_id'],
 111                                   "status": kwargs['status']}}
 112         return json.dumps(create_metric_resp)
 113
 114     def read_metric_data_response(self, **kwargs):
 115         """Generate a response for a read metric data request."""
 116         read_metric_data_resp = {"schema_version": schema_version,
 117                                  "schema_type": "read_metric_data_response",
 118                                  "metric_name": kwargs['m_name'],
 119                                  "metric_uuid": kwargs['m_id'],
 120                                  "resource_uuid": kwargs['r_id'],
 121                                  "correlation_id": kwargs['cor_id'],
 122                                  "metrics_data": {
 123                                      "time_series": kwargs['times'],
 124                                      "metrics_series": kwargs['metrics']}}
 125         return json.dumps(read_metric_data_resp)
 126
 127     def delete_metric_response(self, **kwargs):
 128         """Generate a response for a delete metric request."""
 129         delete_metric_resp = {"schema_version": schema_version,
 130                               "schema_type": "delete_metric_response",
 131                               "metric_name": kwargs['m_name'],
 132                               "metric_uuid": kwargs['m_id'],
 133                               "resource_uuid": kwargs['r_id'],
 134                               "correlation_id": kwargs['cor_id'],
 135                               "status": kwargs['status']}
 136         return json.dumps(delete_metric_resp)
 137
 138     def update_metric_response(self, **kwargs):
 139         """Generate a repsonse for an update metric request."""
 140         update_metric_resp = {"schema_version": schema_version,
 141                               "schema_type": "update_metric_response",
 142                               "correlation_id": kwargs['cor_id'],
 143                               "metric_update_response": {
 144                                   "metric_uuid": kwargs['m_id'],
 145                                   "status": kwargs['status'],
 146                                   "resource_uuid": kwargs['r_id']}}
 147         return json.dumps(update_metric_resp)
 148
 149     def list_metric_response(self, **kwargs):
 150         """Generate a response for a list metric request."""
 151         list_metric_resp = {"schema_version": schema_version,
 152                             "schema_type": "list_metric_response",
 153                             "correlation_id": kwargs['cor_id'],
 154                             "metrics_list": kwargs['m_list']}
 155         return json.dumps(list_metric_resp)
 156
 157     def notify_alarm(self, **kwargs):
 158         """Generate a response to send alarm notifications."""
 159         notify_alarm_resp = {"schema_version": schema_version,
 160                              "schema_type": "notify_alarm",
 161                              "notify_details": {
 162                                  "alarm_uuid": kwargs['a_id'],
 163                                  "resource_uuid": kwargs['r_id'],
 164                                  "vim_type": kwargs['vim_type'],
 165                                  "severity": kwargs['sev'],
 166                                  "status": kwargs['state'],
 167                                  "start_date": kwargs['date']}}
 168         return json.dumps(notify_alarm_resp)