osm_mon/core/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 logging
  25
  26 log = logging.getLogger(__name__)
  27
  28 schema_version = "1.1"
  29
  30
  31 class ResponseBuilder(object):
  32     """Generates responses for OpenStack plugin."""
  33
  34     def __init__(self):
  35         """Initialize OpenStack Response instance."""
  36
  37     def generate_response(self, key, **kwargs) -> dict:
  38         """Make call to appropriate response function."""
  39         if key == "list_alarm_response":
  40             message = self.alarm_list_response(**kwargs)
  41         elif key == "create_alarm_response":
  42             message = self.create_alarm_response(**kwargs)
  43         elif key == "delete_alarm_response":
  44             message = self.delete_alarm_response(**kwargs)
  45         elif key == "update_alarm_response":
  46             message = self.update_alarm_response(**kwargs)
  47         elif key == "create_metric_response":
  48             message = self.metric_create_response(**kwargs)
  49         elif key == "read_metric_data_response":
  50             message = self.read_metric_data_response(**kwargs)
  51         elif key == "delete_metric_response":
  52             message = self.delete_metric_response(**kwargs)
  53         elif key == "update_metric_response":
  54             message = self.update_metric_response(**kwargs)
  55         elif key == "list_metric_response":
  56             message = self.list_metric_response(**kwargs)
  57         elif key == "notify_alarm":
  58             message = self.notify_alarm(**kwargs)
  59         else:
  60             log.warning("Failed to generate a valid response message.")
  61             message = None
  62
  63         return message
  64
  65     def alarm_list_response(self, **kwargs) -> dict:
  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_response": kwargs['alarm_list']}
  71         return alarm_list_resp
  72
  73     def create_alarm_response(self, **kwargs) -> dict:
  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 create_alarm_resp
  82
  83     def delete_alarm_response(self, **kwargs) -> dict:
  84         """Generate a response for a delete alarm request."""
  85         delete_alarm_resp = {"schema_version": schema_version,
  86                              "schema_type": "alarm_delete_response",
  87                              "alarm_delete_response": {
  88                                  "correlation_id": kwargs['cor_id'],
  89                                  "alarm_uuid": kwargs['alarm_id'],
  90                                  "status": kwargs['status']}}
  91         return delete_alarm_resp
  92
  93     def update_alarm_response(self, **kwargs) -> dict:
  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 update_alarm_resp
 102
 103     def metric_create_response(self, **kwargs) -> dict:
 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['resource_id'],
 111                                   "status": kwargs['status']}}
 112         return create_metric_resp
 113
 114     def read_metric_data_response(self, **kwargs) -> dict:
 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['metric_name'],
 119                                  "metric_uuid": kwargs['metric_id'],
 120                                  "resource_uuid": kwargs['resource_id'],
 121                                  "correlation_id": kwargs['cor_id'],
 122                                  "status": kwargs['status'],
 123                                  "metrics_data": {
 124                                      "time_series": kwargs['times'],
 125                                      "metrics_series": kwargs['metrics']}}
 126         return read_metric_data_resp
 127
 128     def delete_metric_response(self, **kwargs) -> dict:
 129         """Generate a response for a delete metric request."""
 130         delete_metric_resp = {"schema_version": schema_version,
 131                               "schema_type": "delete_metric_response",
 132                               "metric_name": kwargs['metric_name'],
 133                               "metric_uuid": kwargs['metric_id'],
 134                               "resource_uuid": kwargs['resource_id'],
 135                               "correlation_id": kwargs['cor_id'],
 136                               "status": kwargs['status']}
 137         return delete_metric_resp
 138
 139     def update_metric_response(self, **kwargs) -> dict:
 140         """Generate a repsonse for an update metric request."""
 141         update_metric_resp = {"schema_version": schema_version,
 142                               "schema_type": "update_metric_response",
 143                               "correlation_id": kwargs['cor_id'],
 144                               "metric_update_response": {
 145                                   "metric_uuid": kwargs['metric_id'],
 146                                   "status": kwargs['status'],
 147                                   "resource_uuid": kwargs['resource_id']}}
 148         return update_metric_resp
 149
 150     def list_metric_response(self, **kwargs) -> dict:
 151         """Generate a response for a list metric request."""
 152         list_metric_resp = {"schema_version": schema_version,
 153                             "schema_type": "list_metric_response",
 154                             "correlation_id": kwargs['cor_id'],
 155                             "status": kwargs['status'],
 156                             "metrics_list": kwargs['metric_list']}
 157         return list_metric_resp
 158
 159     def notify_alarm(self, **kwargs) -> dict:
 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['alarm_id'],
 165                                  "vdu_name": kwargs['vdu_name'],
 166                                  "vnf_member_index": kwargs['vnf_member_index'],
 167                                  "ns_id": kwargs['ns_id'],
 168                                  "metric_name": kwargs['metric_name'],
 169                                  "threshold_value": kwargs['threshold_value'],
 170                                  "operation": kwargs['operation'],
 171                                  "severity": kwargs['sev'],
 172                                  "status": kwargs['status'],
 173                                  "start_date": kwargs['date']}}
 174         return notify_alarm_resp