osm_mon/collector/vnf_collectors/vrops/vrops_helper.py

   1 # -*- coding: utf-8 -*-
   2
   3 # #
   4 # Copyright 2016-2019 VMware Inc.
   5 # This file is part of ETSI OSM
   6 # All Rights Reserved.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   9 # not use this file except in compliance with the License. You may obtain
  10 # a copy of the License at
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  17 # License for the specific language governing permissions and limitations
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact:  osslegalrouting@vmware.com
  22 # #
  23
  24 import logging
  25 import json
  26 import requests
  27 import traceback
  28
  29 from osm_mon.collector.vnf_metric import VnfMetric
  30 from osm_mon.collector.vnf_collectors.vrops.metrics import METRIC_MAPPINGS
  31 import copy
  32
  33 log = logging.getLogger(__name__)
  34
  35
  36 # If the unit from vROPS does not align with the expected value. multiply by the specified amount to ensure
  37 # the correct unit is returned.
  38 METRIC_MULTIPLIERS = {
  39     "disk_read_bytes": 1024,
  40     "disk_write_bytes": 1024,
  41     "packets_received": 1024,
  42     "packets_sent": 1024
  43 }
  44
  45
  46 class vROPS_Helper():
  47
  48     def __init__(self,
  49                  vrops_site='https://vrops',
  50                  vrops_user='',
  51                  vrops_password=''):
  52         self.vrops_site = vrops_site
  53         self.vrops_user = vrops_user
  54         self.vrops_password = vrops_password
  55
  56     def get_vm_resource_list_from_vrops(self):
  57         """ Find all known resource IDs in vROPs
  58         """
  59         api_url = '/suite-api/api/resources?resourceKind=VirtualMachine'
  60         headers = {'Accept': 'application/json'}
  61         resource_list = []
  62
  63         resp = requests.get(self.vrops_site + api_url,
  64                             auth=(self.vrops_user, self.vrops_password),
  65                             verify=False, headers=headers)
  66
  67         if resp.status_code != 200:
  68             log.error("Failed to get resource list from vROPS: {} {}".format(resp.status_code,
  69                                                                              resp.content))
  70             return resource_list
  71
  72         try:
  73             resp_data = json.loads(resp.content.decode('utf-8'))
  74             if resp_data.get('resourceList') is not None:
  75                 resource_list = resp_data.get('resourceList')
  76
  77         except Exception as exp:
  78             log.error("get_vm_resource_id: Error in parsing {}\n{}".format(exp, traceback.format_exc()))
  79
  80         return resource_list
  81
  82     def get_metrics(self,
  83                     vdu_mappings={},
  84                     monitoring_params={},
  85                     vnfr=None,
  86                     tags={}):
  87
  88         monitoring_keys = {}
  89         # Collect the names of all the metrics we need to query
  90         for metric_entry in monitoring_params:
  91             metric_name = metric_entry['nfvi-metric']
  92             if metric_name not in METRIC_MAPPINGS:
  93                 log.debug("Metric {} not supported, ignoring".format(metric_name))
  94                 continue
  95             monitoring_keys[metric_name] = METRIC_MAPPINGS[metric_name]
  96
  97         metrics = []
  98         # Make a query for only the stats we have been asked for
  99         stats_key = ""
 100         for stat in monitoring_keys.values():
 101             stats_key += "&statKey={}".format(stat)
 102
 103         # And only ask for the resource ids that we are interested in
 104         resource_ids = ""
 105         sanitized_vdu_mappings = copy.deepcopy(vdu_mappings)
 106         for key in vdu_mappings.keys():
 107             vdu = vdu_mappings[key]
 108             if 'vrops_id' not in vdu:
 109                 log.info("Could not find vROPS id for vdu {}".format(vdu))
 110                 del sanitized_vdu_mappings[key]
 111                 continue
 112             resource_ids += "&resourceId={}".format(vdu['vrops_id'])
 113         vdu_mappings = sanitized_vdu_mappings
 114
 115         try:
 116
 117             # Now we can make a single call to vROPS to collect all relevant metrics for resources we need to monitor
 118             api_url = "/suite-api/api/resources/stats?IntervalType=MINUTES&IntervalCount=1"\
 119                 "&rollUpType=MAX&currentOnly=true{}{}".format(stats_key, resource_ids)
 120             headers = {'Accept': 'application/json'}
 121
 122             resp = requests.get(self.vrops_site + api_url,
 123                                 auth=(self.vrops_user, self.vrops_password), verify=False, headers=headers)
 124
 125             if resp.status_code != 200:
 126                 log.error("Failed to get Metrics data from vROPS for {} {}".format(resp.status_code,
 127                                                                                    resp.content))
 128                 return metrics
 129
 130             m_data = json.loads(resp.content.decode('utf-8'))
 131             if 'values' not in m_data:
 132                 return metrics
 133
 134             statistics = m_data['values']
 135             for vdu_stat in statistics:
 136                 vrops_id = vdu_stat['resourceId']
 137                 vdu_name = None
 138                 for vdu in vdu_mappings.values():
 139                     if vdu['vrops_id'] == vrops_id:
 140                         vdu_name = vdu['name']
 141                 if vdu_name is None:
 142                     continue
 143                 for item in vdu_stat['stat-list']['stat']:
 144                     reported_metric = item['statKey']['key']
 145                     if reported_metric not in METRIC_MAPPINGS.values():
 146                         continue
 147
 148                     # Convert the vROPS metric name back to OSM key
 149                     metric_name = list(METRIC_MAPPINGS.keys())[list(METRIC_MAPPINGS.values()).
 150                                                                index(reported_metric)]
 151                     if metric_name in monitoring_keys.keys():
 152                         metric_value = item['data'][-1]
 153                         if metric_name in METRIC_MULTIPLIERS:
 154                             metric_value *= METRIC_MULTIPLIERS[metric_name]
 155                         metric = VnfMetric(vnfr['nsr-id-ref'],
 156                                            vnfr['member-vnf-index-ref'],
 157                                            vdu_name,
 158                                            metric_name,
 159                                            metric_value,
 160                                            tags
 161                                            )
 162
 163                         metrics.append(metric)
 164
 165         except Exception as exp:
 166             log.error("Exception while parsing metrics data from vROPS {}\n{}".format(exp, traceback.format_exc()))
 167
 168         return metrics