438c40cdb5a806b60236db46915271233130c592
1 # -*- coding: utf-8 -*-
4 # Copyright 2016-2019 VMware Inc.
5 # This file is part of ETSI OSM
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
12 # http://www.apache.org/licenses/LICENSE-2.0
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
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact: osslegalrouting@vmware.com
28 from xml
.etree
import ElementTree
as XmlElementTree
32 from pyvcloud
.vcd
.client
import BasicLoginCredentials
33 from pyvcloud
.vcd
.client
import Client
35 from osm_mon
.collector
.utils
import CollectorUtils
36 from osm_mon
.collector
.vnf_collectors
.base_vim
import BaseVimCollector
37 from osm_mon
.collector
.vnf_metric
import VnfMetric
38 from osm_mon
.core
.common_db
import CommonDbClient
39 from osm_mon
.core
.config
import Config
41 log
= logging
.getLogger(__name__
)
45 PERIOD_MSEC
= {'HR': 3600000,
52 "average_memory_utilization": "mem|usage_average",
53 "cpu_utilization": "cpu|usage_average",
54 "read_latency_0": "virtualDisk:scsi0:0|totalReadLatency_average",
55 "write_latency_0": "virtualDisk:scsi0:0|totalWriteLatency_average",
56 "read_latency_1": "virtualDisk:scsi0:1|totalReadLatency_average",
57 "write_latency_1": "virtualDisk:scsi0:1|totalWriteLatency_average",
58 "packets_dropped_0": "net:4000|dropped",
59 "packets_dropped_1": "net:4001|dropped",
60 "packets_dropped_2": "net:4002|dropped",
61 "packets_received": "net:Aggregate of all instances|packetsRxPerSec",
62 "packets_sent": "net:Aggregate of all instances|packetsTxPerSec",
66 class VMwareCollector(BaseVimCollector
):
67 def __init__(self
, config
: Config
, vim_account_id
: str):
68 super().__init
__(config
, vim_account_id
)
69 self
.common_db
= CommonDbClient(config
)
70 vim_account
= self
.get_vim_account(vim_account_id
)
71 self
.vrops_site
= vim_account
['vrops_site']
72 self
.vrops_user
= vim_account
['vrops_user']
73 self
.vrops_password
= vim_account
['vrops_password']
74 self
.vcloud_site
= vim_account
['vim_url']
75 self
.admin_username
= vim_account
['admin_username']
76 self
.admin_password
= vim_account
['admin_password']
77 self
.vim_uuid
= vim_account
['vim_uuid']
79 def connect_as_admin(self
):
80 """ Method connect as pvdc admin user to vCloud director.
81 There are certain action that can be done only by provider vdc admin user.
82 Organization creation / provider network creation etc.
85 The return client object that letter can be used to connect to vcloud direct as admin for provider vdc
88 log
.info("Logging into vCD org as admin.")
92 host
= self
.vcloud_site
93 admin_user
= self
.admin_username
94 admin_passwd
= self
.admin_password
96 client
= Client(host
, verify_ssl_certs
=False)
97 client
.set_highest_supported_version()
98 client
.set_credentials(BasicLoginCredentials(admin_user
, org
,
102 except Exception as e
:
103 log
.info("Can't connect to a vCloud director as: {} with exception {}".format(admin_user
, e
))
105 def _get_resource_uuid(self
, nsr_id
, vnf_member_index
, vdur_name
) -> str:
106 vdur
= self
.common_db
.get_vdur(nsr_id
, vnf_member_index
, vdur_name
)
107 return vdur
['vim-id']
109 def get_vim_account(self
, vim_account_id
: str):
111 Method to get VIM account details by its ID
113 return - dict with vim account details
116 vim_account_info
= CollectorUtils
.get_credentials(vim_account_id
)
118 vim_account
['name'] = vim_account_info
.name
119 vim_account
['vim_tenant_name'] = vim_account_info
.tenant_name
120 vim_account
['vim_type'] = vim_account_info
.type
121 vim_account
['vim_url'] = vim_account_info
.url
122 vim_account
['org_user'] = vim_account_info
.user
123 vim_account
['org_password'] = vim_account_info
.password
124 vim_account
['vim_uuid'] = vim_account_info
.uuid
126 vim_config
= json
.loads(vim_account_info
.config
)
127 vim_account
['admin_username'] = vim_config
['admin_username']
128 vim_account
['admin_password'] = vim_config
['admin_password']
129 vim_account
['vrops_site'] = vim_config
['vrops_site']
130 vim_account
['vrops_user'] = vim_config
['vrops_user']
131 vim_account
['vrops_password'] = vim_config
['vrops_password']
132 vim_account
['vcenter_ip'] = vim_config
['vcenter_ip']
133 vim_account
['vcenter_port'] = vim_config
['vcenter_port']
134 vim_account
['vcenter_user'] = vim_config
['vcenter_user']
135 vim_account
['vcenter_password'] = vim_config
['vcenter_password']
137 if vim_config
['nsx_manager'] is not None:
138 vim_account
['nsx_manager'] = vim_config
['nsx_manager']
140 if vim_config
['nsx_user'] is not None:
141 vim_account
['nsx_user'] = vim_config
['nsx_user']
143 if vim_config
['nsx_password'] is not None:
144 vim_account
['nsx_password'] = vim_config
['nsx_password']
146 if vim_config
['orgname'] is not None:
147 vim_account
['orgname'] = vim_config
['orgname']
151 def get_vm_moref_id(self
, vapp_uuid
):
153 Method to get the moref_id of given VM
160 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
162 if vm_details
and "vm_vcenter_info" in vm_details
:
163 vm_moref_id
= vm_details
["vm_vcenter_info"].get("vm_moref_id", None)
165 log
.info("Found vm_moref_id: {} for vApp UUID: {}".format(vm_moref_id
, vapp_uuid
))
168 except Exception as exp
:
169 log
.info("Error occurred while getting VM moref ID for VM : {}\n{}".format(exp
, traceback
.format_exc()))
171 def get_vapp_details_rest(self
, vapp_uuid
=None):
173 Method retrieve vapp detail from vCloud director
174 vapp_uuid - is vapp identifier.
175 Returns - VM MOref ID or return None
180 if vapp_uuid
is None:
181 return parsed_respond
183 vca
= self
.connect_as_admin()
186 log
.error("Failed to connect to vCD")
187 return parsed_respond
189 url_list
= [self
.vcloud_site
, '/api/vApp/vapp-', vapp_uuid
]
190 get_vapp_restcall
= ''.join(url_list
)
193 headers
= {'Accept': 'application/*+xml;version=' + API_VERSION
,
194 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
195 response
= requests
.get(get_vapp_restcall
,
199 if response
.status_code
!= 200:
200 log
.error("REST API call {} failed. Return status code {}".format(get_vapp_restcall
,
202 return parsed_respond
205 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
207 namespaces
= {'vm': 'http://www.vmware.com/vcloud/v1.5',
208 "vmext": "http://www.vmware.com/vcloud/extension/v1.5",
209 "xmlns": "http://www.vmware.com/vcloud/v1.5"}
211 # parse children section for other attrib
212 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
213 if children_section
is not None:
214 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
215 if vCloud_extension_section
is not None:
217 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
218 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
219 if vmext
is not None:
220 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
221 parsed_respond
["vm_vcenter_info"] = vm_vcenter_info
223 except Exception as exp
:
224 log
.info("Error occurred for getting vApp details: {}\n{}".format(exp
,
225 traceback
.format_exc())
228 return parsed_respond
230 def get_vm_resource_id(self
, vm_moref_id
):
231 """ Find resource ID in vROPs using vm_moref_id
233 if vm_moref_id
is None:
236 api_url
= '/suite-api/api/resources?resourceKind=VirtualMachine'
237 headers
= {'Accept': 'application/json'}
239 resp
= requests
.get(self
.vrops_site
+ api_url
,
240 auth
=(self
.vrops_user
, self
.vrops_password
),
241 verify
=False, headers
=headers
)
243 if resp
.status_code
!= 200:
244 log
.error("Failed to get resource details for{} {} {}".format(vm_moref_id
,
249 vm_resource_id
= None
251 resp_data
= json
.loads(resp
.content
.decode('utf-8'))
252 if resp_data
.get('resourceList') is not None:
253 resource_list
= resp_data
.get('resourceList')
254 for resource
in resource_list
:
255 if resource
.get('resourceKey') is not None:
256 resource_details
= resource
['resourceKey']
257 if resource_details
.get('resourceIdentifiers') is not None:
258 resource_identifiers
= resource_details
['resourceIdentifiers']
259 for resource_identifier
in resource_identifiers
:
260 if resource_identifier
['identifierType']['name'] == 'VMEntityObjectID':
261 if resource_identifier
.get('value') is not None and \
262 resource_identifier
['value'] == vm_moref_id
:
263 vm_resource_id
= resource
['identifier']
264 log
.info("Found VM resource ID: {} for vm_moref_id: {}".format(vm_resource_id
,
267 except Exception as exp
:
268 log
.info("get_vm_resource_id: Error in parsing {}\n{}".format(exp
, traceback
.format_exc()))
270 return vm_resource_id
272 def collect(self
, vnfr
: dict):
273 nsr_id
= vnfr
['nsr-id-ref']
274 vnf_member_index
= vnfr
['member-vnf-index-ref']
275 vnfd
= self
.common_db
.get_vnfd(vnfr
['vnfd-id'])
277 for vdur
in vnfr
['vdur']:
278 # This avoids errors when vdur records have not been completely filled
279 if 'name' not in vdur
:
282 filter(lambda vdu
: vdu
['id'] == vdur
['vdu-id-ref'], vnfd
['vdu'])
285 if 'monitoring-param' in vdu
:
286 for param
in vdu
['monitoring-param']:
287 metric_name
= param
['nfvi-metric']
288 vrops_metric_name
= METRIC_MAPPINGS
[metric_name
]
289 resource_uuid
= self
._get
_resource
_uuid
(nsr_id
, vnf_member_index
, vdur
['name'])
291 # Find vm_moref_id from vApp uuid in vCD
292 vm_moref_id
= self
.get_vm_moref_id(resource_uuid
)
293 if vm_moref_id
is None:
294 log
.debug("Failed to find vm morefid for vApp in vCD: {}".format(resource_uuid
))
297 # Based on vm_moref_id, find VM's corresponding resource_id in vROPs
298 resource_id
= self
.get_vm_resource_id(vm_moref_id
)
299 if resource_id
is None:
300 log
.debug("Failed to find resource in vROPs: {}".format(resource_uuid
))
303 end_time
= int(round(time
.time() * 1000))
304 time_diff
= PERIOD_MSEC
['YEAR']
305 begin_time
= end_time
- time_diff
307 api_url
= "/suite-api/api/resources/{}/stats?statKey={}&begin={}&end={}".format(
308 resource_id
, vrops_metric_name
, str(begin_time
), str(end_time
))
310 headers
= {'Accept': 'application/json'}
312 resp
= requests
.get(self
.vrops_site
+ api_url
,
313 auth
=(self
.vrops_user
, self
.vrops_password
), verify
=False, headers
=headers
316 if resp
.status_code
!= 200:
317 log
.info("Failed to get Metrics data from vROPS for {} {} {}".format(vrops_metric_name
,
323 m_data
= json
.loads(resp
.content
.decode('utf-8'))
325 for resp_key
, resp_val
in six
.iteritems(m_data
):
326 if resp_key
== 'values':
327 data
= m_data
['values'][0]
328 for data_k
, data_v
in six
.iteritems(data
):
329 if data_k
== 'stat-list':
331 for stat_list_k
, stat_list_v
in six
.iteritems(stat_list
):
332 for stat_keys
, stat_vals
in six
.iteritems(stat_list_v
[0]):
333 if stat_keys
== 'timestamps':
334 metrics_data
['time_series'] = stat_list_v
[0]['timestamps']
335 if stat_keys
== 'data':
336 metrics_data
['metrics_series'] = stat_list_v
[0]['data']
339 metric
= VnfMetric(nsr_id
,
343 metrics_data
['metrics_series'][-1])
345 metrics
.append(metric
)
347 except Exception as e
:
348 log
.debug("No metric found: %s", e
)