1 # -*- coding: utf-8 -*-
4 # Copyright 2016-2017 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
25 vimconn_vmware implementation an Abstract class in order to interact with VMware vCloud Director.
28 from progressbar
import Percentage
, Bar
, ETA
, FileTransferSpeed
, ProgressBar
38 from pyVmomi
import vim
, vmodl
39 from pyVim
.connect
import SmartConnect
, Disconnect
41 from xml
.etree
import ElementTree
as XmlElementTree
42 from lxml
import etree
as lxmlElementTree
45 from pyvcloud
.vcd
.client
import BasicLoginCredentials
,Client
,VcdTaskException
46 from pyvcloud
.vcd
.vdc
import VDC
47 from pyvcloud
.vcd
.org
import Org
49 from pyvcloud
.vcd
.vapp
import VApp
50 from xml
.sax
.saxutils
import escape
64 # global variable for vcd connector type
65 STANDALONE
= 'standalone'
67 # key for flavor dicts
68 FLAVOR_RAM_KEY
= 'ram'
69 FLAVOR_VCPUS_KEY
= 'vcpus'
70 FLAVOR_DISK_KEY
= 'disk'
71 DEFAULT_IP_PROFILE
= {'dhcp_count':50,
75 # global variable for wait time
81 __author__
= "Mustafa Bayramov, Arpita Kate, Sachin Bhangare, Prakash Kasar"
82 __date__
= "$09-Mar-2018 11:09:29$"
85 # -1: "Could not be created",
91 # 5: "Waiting for user input",
93 # 7: "Unrecognized state",
95 # 9: "Inconsistent state",
96 # 10: "Children do not all have the same status",
97 # 11: "Upload initiated, OVF descriptor pending",
98 # 12: "Upload initiated, copying contents",
99 # 13: "Upload initiated , disk contents pending",
100 # 14: "Upload has been quarantined",
101 # 15: "Upload quarantine period has expired"
103 # mapping vCD status to MANO
104 vcdStatusCode2manoFormat
= {4: 'ACTIVE',
113 netStatus2manoFormat
= {'ACTIVE': 'ACTIVE', 'PAUSED': 'PAUSED', 'INACTIVE': 'INACTIVE', 'BUILD': 'BUILD',
114 'ERROR': 'ERROR', 'DELETED': 'DELETED'
117 class vimconnector(vimconn
.vimconnector
):
118 # dict used to store flavor in memory
121 def __init__(self
, uuid
=None, name
=None, tenant_id
=None, tenant_name
=None,
122 url
=None, url_admin
=None, user
=None, passwd
=None, log_level
=None, config
={}, persistent_info
={}):
124 Constructor create vmware connector to vCloud director.
126 By default construct doesn't validate connection state. So client can create object with None arguments.
127 If client specified username , password and host and VDC name. Connector initialize other missing attributes.
129 a) It initialize organization UUID
130 b) Initialize tenant_id/vdc ID. (This information derived from tenant name)
133 uuid - is organization uuid.
134 name - is organization name that must be presented in vCloud director.
135 tenant_id - is VDC uuid it must be presented in vCloud director
136 tenant_name - is VDC name.
137 url - is hostname or ip address of vCloud director
138 url_admin - same as above.
139 user - is user that administrator for organization. Caller must make sure that
140 username has right privileges.
142 password - is password for a user.
144 VMware connector also requires PVDC administrative privileges and separate account.
145 This variables must be passed via config argument dict contains keys
147 dict['admin_username']
148 dict['admin_password']
149 config - Provide NSX and vCenter information
155 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
,
156 url_admin
, user
, passwd
, log_level
, config
)
158 self
.logger
= logging
.getLogger('openmano.vim.vmware')
159 self
.logger
.setLevel(10)
160 self
.persistent_info
= persistent_info
165 self
.url_admin
= url_admin
166 self
.tenant_id
= tenant_id
167 self
.tenant_name
= tenant_name
171 self
.admin_password
= None
172 self
.admin_user
= None
174 self
.nsx_manager
= None
176 self
.nsx_password
= None
177 self
.availability_zone
= None
179 # Disable warnings from self-signed certificates.
180 requests
.packages
.urllib3
.disable_warnings()
182 if tenant_name
is not None:
183 orgnameandtenant
= tenant_name
.split(":")
184 if len(orgnameandtenant
) == 2:
185 self
.tenant_name
= orgnameandtenant
[1]
186 self
.org_name
= orgnameandtenant
[0]
188 self
.tenant_name
= tenant_name
189 if "orgname" in config
:
190 self
.org_name
= config
['orgname']
193 self
.logger
.setLevel(getattr(logging
, log_level
))
196 self
.admin_user
= config
['admin_username']
197 self
.admin_password
= config
['admin_password']
199 raise vimconn
.vimconnException(message
="Error admin username or admin password is empty.")
202 self
.nsx_manager
= config
['nsx_manager']
203 self
.nsx_user
= config
['nsx_user']
204 self
.nsx_password
= config
['nsx_password']
206 raise vimconn
.vimconnException(message
="Error: nsx manager or nsx user or nsx password is empty in Config")
208 self
.vcenter_ip
= config
.get("vcenter_ip", None)
209 self
.vcenter_port
= config
.get("vcenter_port", None)
210 self
.vcenter_user
= config
.get("vcenter_user", None)
211 self
.vcenter_password
= config
.get("vcenter_password", None)
213 #Set availability zone for Affinity rules
214 self
.availability_zone
= self
.set_availability_zones()
216 # ############# Stub code for SRIOV #################
218 # self.dvs_name = config['dv_switch_name']
220 # raise vimconn.vimconnException(message="Error: distributed virtaul switch name is empty in Config")
222 # self.vlanID_range = config.get("vlanID_range", None)
228 raise vimconn
.vimconnException('url param can not be NoneType')
230 if not self
.url_admin
: # try to use normal url
231 self
.url_admin
= self
.url
233 logging
.debug("UUID: {} name: {} tenant_id: {} tenant name {}".format(self
.id, self
.org_name
,
234 self
.tenant_id
, self
.tenant_name
))
235 logging
.debug("vcd url {} vcd username: {} vcd password: {}".format(self
.url
, self
.user
, self
.passwd
))
236 logging
.debug("vcd admin username {} vcd admin passowrd {}".format(self
.admin_user
, self
.admin_password
))
238 # initialize organization
239 if self
.user
is not None and self
.passwd
is not None and self
.url
:
240 self
.init_organization()
242 def __getitem__(self
, index
):
245 if index
== 'tenant_id':
246 return self
.tenant_id
247 if index
== 'tenant_name':
248 return self
.tenant_name
251 elif index
== 'org_name':
253 elif index
== 'org_uuid':
255 elif index
== 'user':
257 elif index
== 'passwd':
261 elif index
== 'url_admin':
262 return self
.url_admin
263 elif index
== "config":
266 raise KeyError("Invalid key '%s'" % str(index
))
268 def __setitem__(self
, index
, value
):
271 if index
== 'tenant_id':
272 self
.tenant_id
= value
273 if index
== 'tenant_name':
274 self
.tenant_name
= value
277 elif index
== 'org_name':
278 self
.org_name
= value
279 elif index
== 'org_uuid':
280 self
.org_uuid
= value
281 elif index
== 'user':
283 elif index
== 'passwd':
287 elif index
== 'url_admin':
288 self
.url_admin
= value
290 raise KeyError("Invalid key '%s'" % str(index
))
292 def connect_as_admin(self
):
293 """ Method connect as pvdc admin user to vCloud director.
294 There are certain action that can be done only by provider vdc admin user.
295 Organization creation / provider network creation etc.
298 The return client object that latter can be used to connect to vcloud director as admin for provider vdc
301 self
.logger
.debug("Logging into vCD {} as admin.".format(self
.org_name
))
306 client_as_admin
= Client(host
, verify_ssl_certs
=False)
307 client_as_admin
.set_credentials(BasicLoginCredentials(self
.admin_user
, org
, self
.admin_password
))
308 except Exception as e
:
309 raise vimconn
.vimconnException(
310 "Can't connect to a vCloud director as: {} with exception {}".format(self
.admin_user
, e
))
312 return client_as_admin
315 """ Method connect as normal user to vCloud director.
318 The return client object that latter can be used to connect to vCloud director as admin for VDC
322 self
.logger
.debug("Logging into vCD {} as {} to datacenter {}.".format(self
.org_name
,
326 client
= Client(host
, verify_ssl_certs
=False)
327 client
.set_credentials(BasicLoginCredentials(self
.user
, self
.org_name
, self
.passwd
))
329 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
330 "{} as user: {}".format(self
.org_name
, self
.user
))
334 def init_organization(self
):
335 """ Method initialize organization UUID and VDC parameters.
337 At bare minimum client must provide organization name that present in vCloud director and VDC.
339 The VDC - UUID ( tenant_id) will be initialized at the run time if client didn't call constructor.
340 The Org - UUID will be initialized at the run time if data center present in vCloud director.
343 The return vca object that letter can be used to connect to vcloud direct as admin
345 client
= self
.connect()
347 raise vimconn
.vimconnConnectionException("Failed to connect vCD.")
351 if self
.org_uuid
is None:
352 org_list
= client
.get_org_list()
353 for org
in org_list
.Org
:
354 # we set org UUID at the init phase but we can do it only when we have valid credential.
355 if org
.get('name') == self
.org_name
:
356 self
.org_uuid
= org
.get('href').split('/')[-1]
357 self
.logger
.debug("Setting organization UUID {}".format(self
.org_uuid
))
360 raise vimconn
.vimconnException("Vcloud director organization {} not found".format(self
.org_name
))
362 # if well good we require for org details
363 org_details_dict
= self
.get_org(org_uuid
=self
.org_uuid
)
365 # we have two case if we want to initialize VDC ID or VDC name at run time
366 # tenant_name provided but no tenant id
367 if self
.tenant_id
is None and self
.tenant_name
is not None and 'vdcs' in org_details_dict
:
368 vdcs_dict
= org_details_dict
['vdcs']
369 for vdc
in vdcs_dict
:
370 if vdcs_dict
[vdc
] == self
.tenant_name
:
372 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
376 raise vimconn
.vimconnException("Tenant name indicated but not present in vcloud director.")
377 # case two we have tenant_id but we don't have tenant name so we find and set it.
378 if self
.tenant_id
is not None and self
.tenant_name
is None and 'vdcs' in org_details_dict
:
379 vdcs_dict
= org_details_dict
['vdcs']
380 for vdc
in vdcs_dict
:
381 if vdc
== self
.tenant_id
:
382 self
.tenant_name
= vdcs_dict
[vdc
]
383 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
387 raise vimconn
.vimconnException("Tenant id indicated but not present in vcloud director")
388 self
.logger
.debug("Setting organization uuid {}".format(self
.org_uuid
))
390 self
.logger
.debug("Failed initialize organization UUID for org {}".format(self
.org_name
))
391 self
.logger
.debug(traceback
.format_exc())
394 def new_tenant(self
, tenant_name
=None, tenant_description
=None):
395 """ Method adds a new tenant to VIM with this name.
396 This action requires access to create VDC action in vCloud director.
399 tenant_name is tenant_name to be created.
400 tenant_description not used for this call
403 returns the tenant identifier in UUID format.
404 If action is failed method will throw vimconn.vimconnException method
406 vdc_task
= self
.create_vdc(vdc_name
=tenant_name
)
407 if vdc_task
is not None:
408 vdc_uuid
, value
= vdc_task
.popitem()
409 self
.logger
.info("Created new vdc {} and uuid: {}".format(tenant_name
, vdc_uuid
))
412 raise vimconn
.vimconnException("Failed create tenant {}".format(tenant_name
))
414 def delete_tenant(self
, tenant_id
=None):
415 """ Delete a tenant from VIM
417 tenant_id is tenant_id to be deleted.
420 returns the tenant identifier in UUID format.
421 If action is failed method will throw exception
423 vca
= self
.connect_as_admin()
425 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
427 if tenant_id
is not None:
430 url_list
= [self
.url
, '/api/vdc/', tenant_id
]
431 orgvdc_herf
= ''.join(url_list
)
433 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
434 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
435 response
= self
.perform_request(req_type
='GET',
439 if response
.status_code
!= requests
.codes
.ok
:
440 self
.logger
.debug("delete_tenant():GET REST API call {} failed. "\
441 "Return status code {}".format(orgvdc_herf
,
442 response
.status_code
))
443 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
445 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
446 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
448 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
449 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
450 vdc_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
451 vdc_remove_href
= vdc_remove_href
+ '?recursive=true&force=true'
453 response
= self
.perform_request(req_type
='DELETE',
457 if response
.status_code
== 202:
461 self
.logger
.debug("delete_tenant(): DELETE REST API call {} failed. "\
462 "Return status code {}".format(vdc_remove_href
,
463 response
.status_code
))
464 raise vimconn
.vimconnException("Fail to delete tenant with ID {}".format(tenant_id
))
466 self
.logger
.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id
))
467 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
470 def get_tenant_list(self
, filter_dict
={}):
471 """Obtain tenants of VIM
472 filter_dict can contain the following keys:
473 name: filter by tenant name
474 id: filter by tenant uuid/id
476 Returns the tenant list of dictionaries:
477 [{'name':'<name>, 'id':'<id>, ...}, ...]
480 org_dict
= self
.get_org(self
.org_uuid
)
481 vdcs_dict
= org_dict
['vdcs']
486 entry
= {'name': vdcs_dict
[k
], 'id': k
}
487 # if caller didn't specify dictionary we return all tenants.
488 if filter_dict
is not None and filter_dict
:
489 filtered_entry
= entry
.copy()
490 filtered_dict
= set(entry
.keys()) - set(filter_dict
)
491 for unwanted_key
in filtered_dict
: del entry
[unwanted_key
]
492 if filter_dict
== entry
:
493 vdclist
.append(filtered_entry
)
495 vdclist
.append(entry
)
497 self
.logger
.debug("Error in get_tenant_list()")
498 self
.logger
.debug(traceback
.format_exc())
499 raise vimconn
.vimconnException("Incorrect state. {}")
503 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False):
504 """Adds a tenant network to VIM
506 net_type can be 'bridge','data'.'ptp'.
507 ip_profile is a dict containing the IP parameters of the network
509 Returns the network identifier"""
511 self
.logger
.debug("new_network tenant {} net_type {} ip_profile {} shared {}"
512 .format(net_name
, net_type
, ip_profile
, shared
))
518 # ############# Stub code for SRIOV #################
519 # if net_type == "data" or net_type == "ptp":
520 # if self.config.get('dv_switch_name') == None:
521 # raise vimconn.vimconnConflictException("You must provide 'dv_switch_name' at config value")
522 # network_uuid = self.create_dvPort_group(net_name)
524 network_uuid
= self
.create_network(network_name
=net_name
, net_type
=net_type
,
525 ip_profile
=ip_profile
, isshared
=isshared
)
526 if network_uuid
is not None:
529 raise vimconn
.vimconnUnexpectedResponse("Failed create a new network {}".format(net_name
))
531 def get_vcd_network_list(self
):
532 """ Method available organization for a logged in tenant
535 The return vca object that letter can be used to connect to vcloud direct as admin
538 self
.logger
.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
540 if not self
.tenant_name
:
541 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
543 org
, vdc
= self
.get_vdc_details()
545 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self
.tenant_name
))
547 vdc_uuid
= vdc
.get('id').split(":")[3]
548 if self
.client
._session
:
549 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
550 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
551 response
= self
.perform_request(req_type
='GET',
554 if response
.status_code
!= 200:
555 self
.logger
.error("Failed to get vdc content")
556 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
558 content
= XmlElementTree
.fromstring(response
.content
)
563 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
565 response
= self
.perform_request(req_type
='GET',
569 if response
.status_code
!= 200:
570 self
.logger
.error("Failed to get network content")
571 raise vimconn
.vimconnNotFoundException("Failed to get network content")
573 net_details
= XmlElementTree
.fromstring(response
.content
)
576 net_uuid
= net_details
.get('id').split(":")
577 if len(net_uuid
) != 4:
580 net_uuid
= net_uuid
[3]
582 self
.logger
.debug("get_vcd_network_list(): Adding network {} "
583 "to a list vcd id {} network {}".format(net_uuid
,
585 net_details
.get('name')))
586 filter_dict
["name"] = net_details
.get('name')
587 filter_dict
["id"] = net_uuid
588 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
592 filter_dict
["shared"] = shared
593 filter_dict
["tenant_id"] = vdc_uuid
594 if int(net_details
.get('status')) == 1:
595 filter_dict
["admin_state_up"] = True
597 filter_dict
["admin_state_up"] = False
598 filter_dict
["status"] = "ACTIVE"
599 filter_dict
["type"] = "bridge"
600 network_list
.append(filter_dict
)
601 self
.logger
.debug("get_vcd_network_list adding entry {}".format(filter_dict
))
603 self
.logger
.debug("Error in get_vcd_network_list", exc_info
=True)
606 self
.logger
.debug("get_vcd_network_list returning {}".format(network_list
))
609 def get_network_list(self
, filter_dict
={}):
610 """Obtain tenant networks of VIM
612 name: network name OR/AND
613 id: network uuid OR/AND
614 shared: boolean OR/AND
615 tenant_id: tenant OR/AND
616 admin_state_up: boolean
619 [{key : value , key : value}]
621 Returns the network list of dictionaries:
622 [{<the fields at Filter_dict plus some VIM specific>}, ...]
626 self
.logger
.debug("get_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
628 if not self
.tenant_name
:
629 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
631 org
, vdc
= self
.get_vdc_details()
633 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}.".format(self
.tenant_name
))
636 vdcid
= vdc
.get('id').split(":")[3]
638 if self
.client
._session
:
639 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
640 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
641 response
= self
.perform_request(req_type
='GET',
644 if response
.status_code
!= 200:
645 self
.logger
.error("Failed to get vdc content")
646 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
648 content
= XmlElementTree
.fromstring(response
.content
)
652 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
654 response
= self
.perform_request(req_type
='GET',
658 if response
.status_code
!= 200:
659 self
.logger
.error("Failed to get network content")
660 raise vimconn
.vimconnNotFoundException("Failed to get network content")
662 net_details
= XmlElementTree
.fromstring(response
.content
)
665 net_uuid
= net_details
.get('id').split(":")
666 if len(net_uuid
) != 4:
669 net_uuid
= net_uuid
[3]
671 self
.logger
.debug("get_network_list(): Adding net {}"
672 " to a list vcd id {} network {}".format(net_uuid
,
674 net_details
.get('name')))
675 filter_entry
["name"] = net_details
.get('name')
676 filter_entry
["id"] = net_uuid
677 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
681 filter_entry
["shared"] = shared
682 filter_entry
["tenant_id"] = vdcid
683 if int(net_details
.get('status')) == 1:
684 filter_entry
["admin_state_up"] = True
686 filter_entry
["admin_state_up"] = False
687 filter_entry
["status"] = "ACTIVE"
688 filter_entry
["type"] = "bridge"
689 filtered_entry
= filter_entry
.copy()
691 if filter_dict
is not None and filter_dict
:
692 # we remove all the key : value we don't care and match only
694 filtered_dict
= set(filter_entry
.keys()) - set(filter_dict
)
695 for unwanted_key
in filtered_dict
: del filter_entry
[unwanted_key
]
696 if filter_dict
== filter_entry
:
697 network_list
.append(filtered_entry
)
699 network_list
.append(filtered_entry
)
700 except Exception as e
:
701 self
.logger
.debug("Error in get_network_list",exc_info
=True)
702 if isinstance(e
, vimconn
.vimconnException
):
705 raise vimconn
.vimconnNotFoundException("Failed : Networks list not found {} ".format(e
))
707 self
.logger
.debug("Returning {}".format(network_list
))
710 def get_network(self
, net_id
):
711 """Method obtains network details of net_id VIM network
712 Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
715 org
, vdc
= self
.get_vdc_details()
716 vdc_id
= vdc
.get('id').split(":")[3]
717 if self
.client
._session
:
718 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
719 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
720 response
= self
.perform_request(req_type
='GET',
723 if response
.status_code
!= 200:
724 self
.logger
.error("Failed to get vdc content")
725 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
727 content
= XmlElementTree
.fromstring(response
.content
)
732 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
734 response
= self
.perform_request(req_type
='GET',
738 if response
.status_code
!= 200:
739 self
.logger
.error("Failed to get network content")
740 raise vimconn
.vimconnNotFoundException("Failed to get network content")
742 net_details
= XmlElementTree
.fromstring(response
.content
)
744 vdc_network_id
= net_details
.get('id').split(":")
745 if len(vdc_network_id
) == 4 and vdc_network_id
[3] == net_id
:
746 filter_dict
["name"] = net_details
.get('name')
747 filter_dict
["id"] = vdc_network_id
[3]
748 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
752 filter_dict
["shared"] = shared
753 filter_dict
["tenant_id"] = vdc_id
754 if int(net_details
.get('status')) == 1:
755 filter_dict
["admin_state_up"] = True
757 filter_dict
["admin_state_up"] = False
758 filter_dict
["status"] = "ACTIVE"
759 filter_dict
["type"] = "bridge"
760 self
.logger
.debug("Returning {}".format(filter_dict
))
763 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
764 except Exception as e
:
765 self
.logger
.debug("Error in get_network")
766 self
.logger
.debug(traceback
.format_exc())
767 if isinstance(e
, vimconn
.vimconnException
):
770 raise vimconn
.vimconnNotFoundException("Failed : Network not found {} ".format(e
))
774 def delete_network(self
, net_id
):
776 Method Deletes a tenant network from VIM, provide the network id.
778 Returns the network identifier or raise an exception
781 # ############# Stub code for SRIOV #################
782 # dvport_group = self.get_dvport_group(net_id)
785 # status = self.destroy_dvport_group(net_id)
787 # # Remove vlanID from persistent info
788 # if net_id in self.persistent_info["used_vlanIDs"]:
789 # del self.persistent_info["used_vlanIDs"][net_id]
793 vcd_network
= self
.get_vcd_network(network_uuid
=net_id
)
794 if vcd_network
is not None and vcd_network
:
795 if self
.delete_network_action(network_uuid
=net_id
):
798 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
800 def refresh_nets_status(self
, net_list
):
801 """Get the status of the networks
802 Params: the list of network identifiers
803 Returns a dictionary with:
804 net_id: #VIM id of this network
805 status: #Mandatory. Text with one of:
806 # DELETED (not found at vim)
807 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
808 # OTHER (Vim reported other status not understood)
809 # ERROR (VIM indicates an ERROR status)
810 # ACTIVE, INACTIVE, DOWN (admin down),
811 # BUILD (on building process)
813 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
814 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
822 vcd_network
= self
.get_vcd_network(network_uuid
=net
)
823 if vcd_network
is not None and vcd_network
:
824 if vcd_network
['status'] == '1':
830 errormsg
= 'Network not found.'
832 dict_entry
[net
] = {'status': status
, 'error_msg': errormsg
,
833 'vim_info': yaml
.safe_dump(vcd_network
)}
835 self
.logger
.debug("Error in refresh_nets_status")
836 self
.logger
.debug(traceback
.format_exc())
840 def get_flavor(self
, flavor_id
):
841 """Obtain flavor details from the VIM
842 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
844 if flavor_id
not in vimconnector
.flavorlist
:
845 raise vimconn
.vimconnNotFoundException("Flavor not found.")
846 return vimconnector
.flavorlist
[flavor_id
]
848 def new_flavor(self
, flavor_data
):
849 """Adds a tenant flavor to VIM
850 flavor_data contains a dictionary with information, keys:
852 ram: memory (cloud type) in MBytes
853 vpcus: cpus (cloud type)
854 extended: EPA parameters
855 - numas: #items requested in same NUMA
856 memory: number of 1G huge pages memory
857 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
858 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
859 - name: interface name
860 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
861 bandwidth: X Gbps; requested guarantee bandwidth
862 vpci: requested virtual PCI address
866 Returns the flavor identifier"""
868 # generate a new uuid put to internal dict and return it.
869 self
.logger
.debug("Creating new flavor - flavor_data: {}".format(flavor_data
))
870 new_flavor
=flavor_data
871 ram
= flavor_data
.get(FLAVOR_RAM_KEY
, 1024)
872 cpu
= flavor_data
.get(FLAVOR_VCPUS_KEY
, 1)
873 disk
= flavor_data
.get(FLAVOR_DISK_KEY
, 0)
875 if not isinstance(ram
, int):
876 raise vimconn
.vimconnException("Non-integer value for ram")
877 elif not isinstance(cpu
, int):
878 raise vimconn
.vimconnException("Non-integer value for cpu")
879 elif not isinstance(disk
, int):
880 raise vimconn
.vimconnException("Non-integer value for disk")
882 extended_flv
= flavor_data
.get("extended")
884 numas
=extended_flv
.get("numas")
887 #overwrite ram and vcpus
889 ram
= numa
['memory']*1024
890 if 'paired-threads' in numa
:
891 cpu
= numa
['paired-threads']*2
892 elif 'cores' in numa
:
894 elif 'threads' in numa
:
895 cpu
= numa
['threads']
897 new_flavor
[FLAVOR_RAM_KEY
] = ram
898 new_flavor
[FLAVOR_VCPUS_KEY
] = cpu
899 new_flavor
[FLAVOR_DISK_KEY
] = disk
900 # generate a new uuid put to internal dict and return it.
901 flavor_id
= uuid
.uuid4()
902 vimconnector
.flavorlist
[str(flavor_id
)] = new_flavor
903 self
.logger
.debug("Created flavor - {} : {}".format(flavor_id
, new_flavor
))
905 return str(flavor_id
)
907 def delete_flavor(self
, flavor_id
):
908 """Deletes a tenant flavor from VIM identify by its id
910 Returns the used id or raise an exception
912 if flavor_id
not in vimconnector
.flavorlist
:
913 raise vimconn
.vimconnNotFoundException("Flavor not found.")
915 vimconnector
.flavorlist
.pop(flavor_id
, None)
918 def new_image(self
, image_dict
):
920 Adds a tenant image to VIM
922 200, image-id if the image is created
923 <0, message if there is an error
926 return self
.get_image_id_from_path(image_dict
['location'])
928 def delete_image(self
, image_id
):
930 Deletes a tenant image from VIM
932 image_id is ID of Image to be deleted
934 returns the image identifier in UUID format or raises an exception on error
936 conn
= self
.connect_as_admin()
938 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
939 # Get Catalog details
940 url_list
= [self
.url
, '/api/catalog/', image_id
]
941 catalog_herf
= ''.join(url_list
)
943 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
944 'x-vcloud-authorization': conn
._session
.headers
['x-vcloud-authorization']}
946 response
= self
.perform_request(req_type
='GET',
950 if response
.status_code
!= requests
.codes
.ok
:
951 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
952 "Return status code {}".format(catalog_herf
,
953 response
.status_code
))
954 raise vimconn
.vimconnNotFoundException("Fail to get image {}".format(image_id
))
956 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
957 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
959 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
960 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
962 catalogItems_section
= lxmlroot_respond
.find("xmlns:CatalogItems",namespaces
)
963 catalogItems
= catalogItems_section
.iterfind("xmlns:CatalogItem",namespaces
)
964 for catalogItem
in catalogItems
:
965 catalogItem_href
= catalogItem
.attrib
['href']
967 response
= self
.perform_request(req_type
='GET',
968 url
=catalogItem_href
,
971 if response
.status_code
!= requests
.codes
.ok
:
972 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
973 "Return status code {}".format(catalog_herf
,
974 response
.status_code
))
975 raise vimconn
.vimconnNotFoundException("Fail to get catalogItem {} for catalog {}".format(
979 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
980 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
982 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
983 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
984 catalogitem_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
987 response
= self
.perform_request(req_type
='DELETE',
988 url
=catalogitem_remove_href
,
990 if response
.status_code
== requests
.codes
.no_content
:
991 self
.logger
.debug("Deleted Catalog item {}".format(catalogItem
))
993 raise vimconn
.vimconnException("Fail to delete Catalog Item {}".format(catalogItem
))
996 url_list
= [self
.url
, '/api/admin/catalog/', image_id
]
997 catalog_remove_herf
= ''.join(url_list
)
998 response
= self
.perform_request(req_type
='DELETE',
999 url
=catalog_remove_herf
,
1002 if response
.status_code
== requests
.codes
.no_content
:
1003 self
.logger
.debug("Deleted Catalog {}".format(image_id
))
1006 raise vimconn
.vimconnException("Fail to delete Catalog {}".format(image_id
))
1009 def catalog_exists(self
, catalog_name
, catalogs
):
1012 :param catalog_name:
1016 for catalog
in catalogs
:
1017 if catalog
['name'] == catalog_name
:
1021 def create_vimcatalog(self
, vca
=None, catalog_name
=None):
1022 """ Create new catalog entry in vCloud director.
1025 vca: vCloud director.
1026 catalog_name catalog that client wish to create. Note no validation done for a name.
1027 Client must make sure that provide valid string representation.
1029 Return (bool) True if catalog created.
1033 result
= vca
.create_catalog(catalog_name
, catalog_name
)
1034 if result
is not None:
1036 catalogs
= vca
.list_catalogs()
1039 return self
.catalog_exists(catalog_name
, catalogs
)
1041 # noinspection PyIncorrectDocstring
1042 def upload_ovf(self
, vca
=None, catalog_name
=None, image_name
=None, media_file_name
=None,
1043 description
='', progress
=False, chunk_bytes
=128 * 1024):
1045 Uploads a OVF file to a vCloud catalog
1052 :param catalog_name: (str): The name of the catalog to upload the media.
1053 :param media_file_name: (str): The name of the local media file to upload.
1054 :return: (bool) True if the media file was successfully uploaded, false otherwise.
1056 os
.path
.isfile(media_file_name
)
1057 statinfo
= os
.stat(media_file_name
)
1059 # find a catalog entry where we upload OVF.
1060 # create vApp Template and check the status if vCD able to read OVF it will respond with appropirate
1062 # if VCD can parse OVF we upload VMDK file
1064 for catalog
in vca
.list_catalogs():
1065 if catalog_name
!= catalog
['name']:
1067 catalog_href
= "{}/api/catalog/{}/action/upload".format(self
.url
, catalog
['id'])
1069 <UploadVAppTemplateParams name="{}" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>{} vApp Template</Description></UploadVAppTemplateParams>
1070 """.format(catalog_name
, description
)
1073 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1074 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1075 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
1077 response
= self
.perform_request(req_type
='POST',
1082 if response
.status_code
== requests
.codes
.created
:
1083 catalogItem
= XmlElementTree
.fromstring(response
.content
)
1084 entity
= [child
for child
in catalogItem
if
1085 child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
1086 href
= entity
.get('href')
1089 response
= self
.perform_request(req_type
='GET',
1093 if response
.status_code
== requests
.codes
.ok
:
1094 headers
['Content-Type'] = 'Content-Type text/xml'
1095 result
= re
.search('rel="upload:default"\shref="(.*?\/descriptor.ovf)"',response
.content
)
1097 transfer_href
= result
.group(1)
1099 response
= self
.perform_request(req_type
='PUT',
1102 data
=open(media_file_name
, 'rb'))
1103 if response
.status_code
!= requests
.codes
.ok
:
1105 "Failed create vApp template for catalog name {} and image {}".format(catalog_name
,
1109 # TODO fix this with aync block
1112 self
.logger
.debug("vApp template for catalog name {} and image {}".format(catalog_name
, media_file_name
))
1114 # uploading VMDK file
1115 # check status of OVF upload and upload remaining files.
1116 response
= self
.perform_request(req_type
='GET',
1120 if response
.status_code
== requests
.codes
.ok
:
1121 result
= re
.search('rel="upload:default"\s*href="(.*?vmdk)"',response
.content
)
1123 link_href
= result
.group(1)
1124 # we skip ovf since it already uploaded.
1125 if 'ovf' in link_href
:
1127 # The OVF file and VMDK must be in a same directory
1128 head
, tail
= os
.path
.split(media_file_name
)
1129 file_vmdk
= head
+ '/' + link_href
.split("/")[-1]
1130 if not os
.path
.isfile(file_vmdk
):
1132 statinfo
= os
.stat(file_vmdk
)
1133 if statinfo
.st_size
== 0:
1135 hrefvmdk
= link_href
1138 widgets
= ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
1139 FileTransferSpeed()]
1140 progress_bar
= ProgressBar(widgets
=widgets
, maxval
=statinfo
.st_size
).start()
1142 bytes_transferred
= 0
1143 f
= open(file_vmdk
, 'rb')
1144 while bytes_transferred
< statinfo
.st_size
:
1145 my_bytes
= f
.read(chunk_bytes
)
1146 if len(my_bytes
) <= chunk_bytes
:
1147 headers
['Content-Range'] = 'bytes %s-%s/%s' % (
1148 bytes_transferred
, len(my_bytes
) - 1, statinfo
.st_size
)
1149 headers
['Content-Length'] = str(len(my_bytes
))
1150 response
= requests
.put(url
=hrefvmdk
,
1154 if response
.status_code
== requests
.codes
.ok
:
1155 bytes_transferred
+= len(my_bytes
)
1157 progress_bar
.update(bytes_transferred
)
1160 'file upload failed with error: [%s] %s' % (response
.status_code
,
1167 progress_bar
.finish()
1171 self
.logger
.debug("Failed retrieve vApp template for catalog name {} for OVF {}".
1172 format(catalog_name
, media_file_name
))
1174 except Exception as exp
:
1175 self
.logger
.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1176 .format(catalog_name
,media_file_name
, exp
))
1177 raise vimconn
.vimconnException(
1178 "Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1179 .format(catalog_name
,media_file_name
, exp
))
1181 self
.logger
.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name
, media_file_name
))
1184 def upload_vimimage(self
, vca
=None, catalog_name
=None, media_name
=None, medial_file_name
=None, progress
=False):
1185 """Upload media file"""
1186 # TODO add named parameters for readability
1188 return self
.upload_ovf(vca
=vca
, catalog_name
=catalog_name
, image_name
=media_name
.split(".")[0],
1189 media_file_name
=medial_file_name
, description
='medial_file_name', progress
=progress
)
1191 def validate_uuid4(self
, uuid_string
=None):
1192 """ Method validate correct format of UUID.
1194 Return: true if string represent valid uuid
1197 val
= uuid
.UUID(uuid_string
, version
=4)
1202 def get_catalogid(self
, catalog_name
=None, catalogs
=None):
1203 """ Method check catalog and return catalog ID in UUID format.
1206 catalog_name: catalog name as string
1207 catalogs: list of catalogs.
1209 Return: catalogs uuid
1212 for catalog
in catalogs
:
1213 if catalog
['name'] == catalog_name
:
1214 catalog_id
= catalog
['id']
1218 def get_catalogbyid(self
, catalog_uuid
=None, catalogs
=None):
1219 """ Method check catalog and return catalog name lookup done by catalog UUID.
1222 catalog_name: catalog name as string
1223 catalogs: list of catalogs.
1225 Return: catalogs name or None
1228 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1231 for catalog
in catalogs
:
1232 catalog_id
= catalog
.get('id')
1233 if catalog_id
== catalog_uuid
:
1234 return catalog
.get('name')
1237 def get_catalog_obj(self
, catalog_uuid
=None, catalogs
=None):
1238 """ Method check catalog and return catalog name lookup done by catalog UUID.
1241 catalog_name: catalog name as string
1242 catalogs: list of catalogs.
1244 Return: catalogs name or None
1247 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1250 for catalog
in catalogs
:
1251 catalog_id
= catalog
.get('id')
1252 if catalog_id
== catalog_uuid
:
1256 def get_image_id_from_path(self
, path
=None, progress
=False):
1257 """ Method upload OVF image to vCloud director.
1259 Each OVF image represented as single catalog entry in vcloud director.
1260 The method check for existing catalog entry. The check done by file name without file extension.
1262 if given catalog name already present method will respond with existing catalog uuid otherwise
1263 it will create new catalog entry and upload OVF file to newly created catalog.
1265 If method can't create catalog entry or upload a file it will throw exception.
1267 Method accept boolean flag progress that will output progress bar. It useful method
1268 for standalone upload use case. In case to test large file upload.
1271 path: - valid path to OVF file.
1272 progress - boolean progress bar show progress bar.
1274 Return: if image uploaded correct method will provide image catalog UUID.
1278 raise vimconn
.vimconnException("Image path can't be None.")
1280 if not os
.path
.isfile(path
):
1281 raise vimconn
.vimconnException("Can't read file. File not found.")
1283 if not os
.access(path
, os
.R_OK
):
1284 raise vimconn
.vimconnException("Can't read file. Check file permission to read.")
1286 self
.logger
.debug("get_image_id_from_path() client requesting {} ".format(path
))
1288 dirpath
, filename
= os
.path
.split(path
)
1289 flname
, file_extension
= os
.path
.splitext(path
)
1290 if file_extension
!= '.ovf':
1291 self
.logger
.debug("Wrong file extension {} connector support only OVF container.".format(file_extension
))
1292 raise vimconn
.vimconnException("Wrong container. vCloud director supports only OVF.")
1294 catalog_name
= os
.path
.splitext(filename
)[0]
1295 catalog_md5_name
= hashlib
.md5(path
).hexdigest()
1296 self
.logger
.debug("File name {} Catalog Name {} file path {} "
1297 "vdc catalog name {}".format(filename
, catalog_name
, path
, catalog_md5_name
))
1300 org
,vdc
= self
.get_vdc_details()
1301 catalogs
= org
.list_catalogs()
1302 except Exception as exp
:
1303 self
.logger
.debug("Failed get catalogs() with Exception {} ".format(exp
))
1304 raise vimconn
.vimconnException("Failed get catalogs() with Exception {} ".format(exp
))
1306 if len(catalogs
) == 0:
1307 self
.logger
.info("Creating a new catalog entry {} in vcloud director".format(catalog_name
))
1308 result
= self
.create_vimcatalog(org
, catalog_md5_name
)
1310 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1312 result
= self
.upload_vimimage(vca
=org
, catalog_name
=catalog_md5_name
,
1313 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1315 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_name
))
1316 return self
.get_catalogid(catalog_name
, catalogs
)
1318 for catalog
in catalogs
:
1319 # search for existing catalog if we find same name we return ID
1320 # TODO optimize this
1321 if catalog
['name'] == catalog_md5_name
:
1322 self
.logger
.debug("Found existing catalog entry for {} "
1323 "catalog id {}".format(catalog_name
,
1324 self
.get_catalogid(catalog_md5_name
, catalogs
)))
1325 return self
.get_catalogid(catalog_md5_name
, catalogs
)
1327 # if we didn't find existing catalog we create a new one and upload image.
1328 self
.logger
.debug("Creating new catalog entry {} - {}".format(catalog_name
, catalog_md5_name
))
1329 result
= self
.create_vimcatalog(org
, catalog_md5_name
)
1331 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1333 result
= self
.upload_vimimage(vca
=org
, catalog_name
=catalog_md5_name
,
1334 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1336 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_md5_name
))
1338 return self
.get_catalogid(catalog_md5_name
, org
.list_catalogs())
1340 def get_image_list(self
, filter_dict
={}):
1341 '''Obtain tenant images from VIM
1345 checksum: image checksum
1346 location: image path
1347 Returns the image list of dictionaries:
1348 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1353 org
, vdc
= self
.get_vdc_details()
1355 catalogs
= org
.list_catalogs()
1356 if len(catalogs
) == 0:
1359 for catalog
in catalogs
:
1360 catalog_uuid
= catalog
.get('id')
1361 name
= catalog
.get('name')
1363 if filter_dict
.get("name") and filter_dict
["name"] != name
:
1365 if filter_dict
.get("id") and filter_dict
["id"] != catalog_uuid
:
1367 filtered_dict
["name"] = name
1368 filtered_dict
["id"] = catalog_uuid
1369 image_list
.append(filtered_dict
)
1371 self
.logger
.debug("List of already created catalog items: {}".format(image_list
))
1373 except Exception as exp
:
1374 raise vimconn
.vimconnException("Exception occured while retriving catalog items {}".format(exp
))
1376 def get_vappid(self
, vdc
=None, vapp_name
=None):
1377 """ Method takes vdc object and vApp name and returns vapp uuid or None
1380 vdc: The VDC object.
1381 vapp_name: is application vappp name identifier
1384 The return vApp name otherwise None
1386 if vdc
is None or vapp_name
is None:
1388 # UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
1390 refs
= filter(lambda ref
: ref
.name
== vapp_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1391 vdc
.ResourceEntities
.ResourceEntity
)
1393 #refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
1394 # if ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
1396 return refs
[0].href
.split("vapp")[1][1:]
1397 except Exception as e
:
1398 self
.logger
.exception(e
)
1402 def check_vapp(self
, vdc
=None, vapp_uuid
=None):
1403 """ Method Method returns True or False if vapp deployed in vCloud director
1406 vca: Connector to VCA
1407 vdc: The VDC object.
1408 vappid: vappid is application identifier
1411 The return True if vApp deployed
1416 refs
= filter(lambda ref
:
1417 ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1418 vdc
.ResourceEntities
.ResourceEntity
)
1420 #refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
1421 # if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
1423 vappid
= ref
.href
.split("vapp")[1][1:]
1424 # find vapp with respected vapp uuid
1425 if vappid
== vapp_uuid
:
1427 except Exception as e
:
1428 self
.logger
.exception(e
)
1432 def get_namebyvappid(self
, vapp_uuid
=None):
1433 """Method returns vApp name from vCD and lookup done by vapp_id.
1436 vapp_uuid: vappid is application identifier
1439 The return vApp name otherwise None
1442 if self
.client
and vapp_uuid
:
1443 vapp_call
= "{}/api/vApp/vapp-{}".format(self
.url
, vapp_uuid
)
1444 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1445 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1447 response
= self
.perform_request(req_type
='GET',
1450 #Retry login if session expired & retry sending request
1451 if response
.status_code
== 403:
1452 response
= self
.retry_rest('GET', vapp_call
)
1454 tree
= XmlElementTree
.fromstring(response
.content
)
1455 return tree
.attrib
['name']
1456 except Exception as e
:
1457 self
.logger
.exception(e
)
1461 def new_vminstance(self
, name
=None, description
="", start
=False, image_id
=None, flavor_id
=None, net_list
=[],
1462 cloud_config
=None, disk_list
=None, availability_zone_index
=None, availability_zone_list
=None):
1463 """Adds a VM instance to VIM
1465 'start': (boolean) indicates if VM must start or created in pause mode.
1466 'image_id','flavor_id': image and flavor VIM id to use for the VM
1467 'net_list': list of interfaces, each one is a dictionary with:
1468 'name': (optional) name for the interface.
1469 'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
1470 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
1471 'model': (optional and only have sense for type==virtual) interface model: virtio, e1000, ...
1472 'mac_address': (optional) mac address to assign to this interface
1473 #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
1474 the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
1475 'type': (mandatory) can be one of:
1476 'virtual', in this case always connected to a network of type 'net_type=bridge'
1477 'PCI-PASSTHROUGH' or 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
1478 can created unconnected
1479 'SR-IOV' or 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
1480 'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
1481 are allocated on the same physical NIC
1482 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS
1483 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing
1484 or True, it must apply the default VIM behaviour
1485 After execution the method will add the key:
1486 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this
1487 interface. 'net_list' is modified
1488 'cloud_config': (optional) dictionary with:
1489 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1490 'users': (optional) list of users to be inserted, each item is a dict with:
1491 'name': (mandatory) user name,
1492 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1493 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
1494 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
1495 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1496 'dest': (mandatory) string with the destination absolute path
1497 'encoding': (optional, by default text). Can be one of:
1498 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1499 'content' (mandatory): string with the content of the file
1500 'permissions': (optional) string with file permissions, typically octal notation '0644'
1501 'owner': (optional) file owner, string with the format 'owner:group'
1502 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1503 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1504 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1505 'size': (mandatory) string with the size of the disk in GB
1506 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1507 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1508 availability_zone_index is None
1509 Returns a tuple with the instance identifier and created_items or raises an exception on error
1510 created_items can be None or a dictionary where this method can include key-values that will be passed to
1511 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1512 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1515 self
.logger
.info("Creating new instance for entry {}".format(name
))
1516 self
.logger
.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {} disk_list {} "\
1517 "availability_zone_index {} availability_zone_list {}"\
1518 .format(description
, start
, image_id
, flavor_id
, net_list
, cloud_config
, disk_list
,\
1519 availability_zone_index
, availability_zone_list
))
1521 #new vm name = vmname + tenant_id + uuid
1522 new_vm_name
= [name
, '-', str(uuid
.uuid4())]
1523 vmname_andid
= ''.join(new_vm_name
)
1525 for net
in net_list
:
1526 if net
['type'] == "SR-IOV" or net
['type'] == "PCI-PASSTHROUGH":
1527 raise vimconn
.vimconnNotSupportedException(
1528 "Current vCD version does not support type : {}".format(net
['type']))
1530 if len(net_list
) > 10:
1531 raise vimconn
.vimconnNotSupportedException(
1532 "The VM hardware versions 7 and above support upto 10 NICs only")
1534 # if vm already deployed we return existing uuid
1535 # we check for presence of VDC, Catalog entry and Flavor.
1536 org
, vdc
= self
.get_vdc_details()
1538 raise vimconn
.vimconnNotFoundException(
1539 "new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name
))
1540 catalogs
= org
.list_catalogs()
1541 if catalogs
is None:
1542 #Retry once, if failed by refreshing token
1544 org
= Org(self
.client
, resource
=self
.client
.get_org())
1545 catalogs
= org
.list_catalogs()
1546 if catalogs
is None:
1547 raise vimconn
.vimconnNotFoundException(
1548 "new_vminstance(): Failed create vApp {}: (Failed retrieve catalogs list)".format(name
))
1550 catalog_hash_name
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1551 if catalog_hash_name
:
1552 self
.logger
.info("Found catalog entry {} for image id {}".format(catalog_hash_name
, image_id
))
1554 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1555 "(Failed retrieve catalog information {})".format(name
, image_id
))
1558 # Set vCPU and Memory based on flavor.
1564 if flavor_id
is not None:
1565 if flavor_id
not in vimconnector
.flavorlist
:
1566 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1567 "Failed retrieve flavor information "
1568 "flavor id {}".format(name
, flavor_id
))
1571 flavor
= vimconnector
.flavorlist
[flavor_id
]
1572 vm_cpus
= flavor
[FLAVOR_VCPUS_KEY
]
1573 vm_memory
= flavor
[FLAVOR_RAM_KEY
]
1574 vm_disk
= flavor
[FLAVOR_DISK_KEY
]
1575 extended
= flavor
.get("extended", None)
1577 numas
=extended
.get("numas", None)
1579 except Exception as exp
:
1580 raise vimconn
.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id
, exp
))
1582 # image upload creates template name as catalog name space Template.
1583 templateName
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1588 # client must provide at least one entry in net_list if not we report error
1589 #If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
1590 #If no mgmt, then the 1st NN in netlist is considered as primary net.
1592 primary_netname
= None
1593 primary_net_href
= None
1594 network_mode
= 'bridged'
1595 if net_list
is not None and len(net_list
) > 0:
1596 for net
in net_list
:
1597 if 'use' in net
and net
['use'] == 'mgmt' and not primary_net
:
1599 if primary_net
is None:
1600 primary_net
= net_list
[0]
1603 primary_net_id
= primary_net
['net_id']
1604 url_list
= [self
.url
, '/api/network/', primary_net_id
]
1605 primary_net_href
= ''.join(url_list
)
1606 network_dict
= self
.get_vcd_network(network_uuid
=primary_net_id
)
1607 if 'name' in network_dict
:
1608 primary_netname
= network_dict
['name']
1611 raise vimconn
.vimconnException("Corrupted flavor. {}".format(primary_net
))
1613 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name
))
1615 # use: 'data', 'bridge', 'mgmt'
1616 # create vApp. Set vcpu and ram based on flavor id.
1618 vdc_obj
= VDC(self
.client
, resource
=org
.get_vdc(self
.tenant_name
))
1620 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed to get VDC object")
1623 items
= org
.get_catalog_item(catalog_hash_name
, catalog_hash_name
)
1624 catalog_items
= [items
.attrib
]
1626 if len(catalog_items
) == 1:
1628 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1629 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1631 response
= self
.perform_request(req_type
='GET',
1632 url
=catalog_items
[0].get('href'),
1634 catalogItem
= XmlElementTree
.fromstring(response
.content
)
1635 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
1636 vapp_tempalte_href
= entity
.get("href")
1638 response
= self
.perform_request(req_type
='GET',
1639 url
=vapp_tempalte_href
,
1641 if response
.status_code
!= requests
.codes
.ok
:
1642 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vapp_tempalte_href
,
1643 response
.status_code
))
1645 result
= (response
.content
).replace("\n"," ")
1647 src
= re
.search('<Vm goldMaster="false"\sstatus="\d+"\sname="(.*?)"\s'
1648 'id="(\w+:\w+:vm:.*?)"\shref="(.*?)"\s'
1649 'type="application/vnd\.vmware\.vcloud\.vm\+xml',result
)
1651 vm_name
= src
.group(1)
1652 vm_id
= src
.group(2)
1653 vm_href
= src
.group(3)
1655 cpus
= re
.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
1656 memory_mb
= re
.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
1657 cores
= re
.search('<vmw:CoresPerSocket ovf:required.*?>(\d+)</vmw:CoresPerSocket>',result
).group(1)
1659 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'
1660 vdc_id
= vdc
.get('id').split(':')[-1]
1661 instantiate_vapp_href
= "{}/api/vdc/{}/action/instantiateVAppTemplate".format(self
.url
,
1663 data
= """<?xml version="1.0" encoding="UTF-8"?>
1664 <InstantiateVAppTemplateParams
1665 xmlns="http://www.vmware.com/vcloud/v1.5"
1669 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1670 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1">
1671 <Description>Vapp instantiation</Description>
1672 <InstantiationParams>
1673 <NetworkConfigSection>
1674 <ovf:Info>Configuration parameters for logical networks</ovf:Info>
1675 <NetworkConfig networkName="{}">
1677 <ParentNetwork href="{}" />
1678 <FenceMode>bridged</FenceMode>
1681 </NetworkConfigSection>
1682 <LeaseSettingsSection
1683 type="application/vnd.vmware.vcloud.leaseSettingsSection+xml">
1684 <ovf:Info>Lease Settings</ovf:Info>
1685 <StorageLeaseInSeconds>172800</StorageLeaseInSeconds>
1686 <StorageLeaseExpiration>2014-04-25T08:08:16.438-07:00</StorageLeaseExpiration>
1687 </LeaseSettingsSection>
1688 </InstantiationParams>
1691 <Source href="{}" id="{}" name="{}"
1692 type="application/vnd.vmware.vcloud.vm+xml"/>
1694 <NeedsCustomization>false</NeedsCustomization>
1696 <InstantiationParams>
1697 <NetworkConnectionSection>
1698 <ovf:Info>Specifies the available VM network connections</ovf:Info>
1699 <NetworkConnection network="{}">
1700 <NetworkConnectionIndex>0</NetworkConnectionIndex>
1701 <IsConnected>true</IsConnected>
1702 <IpAddressAllocationMode>DHCP</IpAddressAllocationMode>
1703 </NetworkConnection>
1704 </NetworkConnectionSection><ovf:VirtualHardwareSection>
1705 <ovf:Info>Virtual hardware requirements</ovf:Info>
1706 <ovf:Item xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
1707 xmlns:vmw="http://www.vmware.com/schema/ovf">
1708 <rasd:AllocationUnits>hertz * 10^6</rasd:AllocationUnits>
1709 <rasd:Description>Number of Virtual CPUs</rasd:Description>
1710 <rasd:ElementName xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="str">{cpu} virtual CPU(s)</rasd:ElementName>
1711 <rasd:InstanceID>4</rasd:InstanceID>
1712 <rasd:Reservation>0</rasd:Reservation>
1713 <rasd:ResourceType>3</rasd:ResourceType>
1714 <rasd:VirtualQuantity xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="int">{cpu}</rasd:VirtualQuantity>
1715 <rasd:Weight>0</rasd:Weight>
1716 <vmw:CoresPerSocket ovf:required="false">{core}</vmw:CoresPerSocket>
1717 </ovf:Item><ovf:Item xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData">
1718 <rasd:AllocationUnits>byte * 2^20</rasd:AllocationUnits>
1719 <rasd:Description>Memory Size</rasd:Description>
1720 <rasd:ElementName xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="str">{memory} MB of memory</rasd:ElementName>
1721 <rasd:InstanceID>5</rasd:InstanceID>
1722 <rasd:Reservation>0</rasd:Reservation>
1723 <rasd:ResourceType>4</rasd:ResourceType>
1724 <rasd:VirtualQuantity xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="int">{memory}</rasd:VirtualQuantity>
1725 <rasd:Weight>0</rasd:Weight>
1727 </ovf:VirtualHardwareSection>
1728 </InstantiationParams>
1730 <AllEULAsAccepted>false</AllEULAsAccepted>
1731 </InstantiateVAppTemplateParams>""".format(vmname_andid
,
1743 response
= self
.perform_request(req_type
='POST',
1744 url
=instantiate_vapp_href
,
1748 if response
.status_code
!= 201:
1749 self
.logger
.error("REST call {} failed reason : {}"\
1750 "status code : {}".format(instantiate_vapp_href
,
1752 response
.status_code
))
1753 raise vimconn
.vimconnException("new_vminstance(): Failed to create"\
1754 "vAapp {}".format(vmname_andid
))
1756 vapptask
= self
.get_task_from_response(response
.content
)
1758 if vapptask
is None and retry
==1:
1759 self
.get_token() # Retry getting token
1764 if vapptask
is None or vapptask
is False:
1765 raise vimconn
.vimconnUnexpectedResponse(
1766 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1768 # wait for task to complete
1769 result
= self
.client
.get_task_monitor().wait_for_success(task
=vapptask
)
1771 if result
.get('status') == 'success':
1772 self
.logger
.debug("new_vminstance(): Sucessfully created Vapp {}".format(vmname_andid
))
1774 raise vimconn
.vimconnUnexpectedResponse(
1775 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1777 except Exception as exp
:
1778 raise vimconn
.vimconnUnexpectedResponse(
1779 "new_vminstance(): failed to create vApp {} with Exception:{}".format(vmname_andid
, exp
))
1781 # we should have now vapp in undeployed state.
1783 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
1784 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1785 vapp_uuid
= vapp_resource
.get('id').split(':')[-1]
1786 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1788 except Exception as exp
:
1789 raise vimconn
.vimconnUnexpectedResponse(
1790 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
1791 .format(vmname_andid
, exp
))
1793 if vapp_uuid
is None:
1794 raise vimconn
.vimconnUnexpectedResponse(
1795 "new_vminstance(): Failed to retrieve vApp {} after creation".format(
1798 #Add PCI passthrough/SRIOV configrations
1800 pci_devices_info
= []
1802 reserve_memory
= False
1804 for net
in net_list
:
1805 if net
["type"] == "PF" or net
["type"] == "PCI-PASSTHROUGH":
1806 pci_devices_info
.append(net
)
1807 elif (net
["type"] == "VF" or net
["type"] == "SR-IOV" or net
["type"] == "VFnotShared") and 'net_id'in net
:
1808 sriov_net_info
.append(net
)
1811 if len(pci_devices_info
) > 0:
1812 self
.logger
.info("Need to add PCI devices {} into VM {}".format(pci_devices_info
,
1814 PCI_devices_status
, vm_obj
, vcenter_conect
= self
.add_pci_devices(vapp_uuid
,
1817 if PCI_devices_status
:
1818 self
.logger
.info("Added PCI devives {} to VM {}".format(
1822 reserve_memory
= True
1824 self
.logger
.info("Fail to add PCI devives {} to VM {}".format(
1831 #Assuming there is only one disk in ovf and fast provisioning in organization vDC is disabled
1832 result
= self
.modify_vm_disk(vapp_uuid
, vm_disk
)
1834 self
.logger
.debug("Modified Disk size of VM {} ".format(vmname_andid
))
1836 #Add new or existing disks to vApp
1838 added_existing_disk
= False
1839 for disk
in disk_list
:
1840 if 'device_type' in disk
and disk
['device_type'] == 'cdrom':
1841 image_id
= disk
['image_id']
1842 # Adding CD-ROM to VM
1843 # will revisit code once specification ready to support this feature
1844 self
.insert_media_to_vm(vapp
, image_id
)
1845 elif "image_id" in disk
and disk
["image_id"] is not None:
1846 self
.logger
.debug("Adding existing disk from image {} to vm {} ".format(
1847 disk
["image_id"] , vapp_uuid
))
1848 self
.add_existing_disk(catalogs
=catalogs
,
1849 image_id
=disk
["image_id"],
1850 size
= disk
["size"],
1851 template_name
=templateName
,
1854 added_existing_disk
= True
1856 #Wait till added existing disk gets reflected into vCD database/API
1857 if added_existing_disk
:
1859 added_existing_disk
= False
1860 self
.add_new_disk(vapp_uuid
, disk
['size'])
1863 # Assigning numa affinity setting
1865 if 'paired-threads-id' in numa
:
1866 paired_threads_id
= numa
['paired-threads-id']
1867 self
.set_numa_affinity(vapp_uuid
, paired_threads_id
)
1869 # add NICs & connect to networks in netlist
1871 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
1872 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1873 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1875 self
.logger
.info("Removing primary NIC: ")
1876 # First remove all NICs so that NIC properties can be adjusted as needed
1877 self
.remove_primary_network_adapter_from_all_vms(vapp
)
1879 self
.logger
.info("Request to connect VM to a network: {}".format(net_list
))
1880 primary_nic_index
= 0
1882 for net
in net_list
:
1883 # openmano uses network id in UUID format.
1884 # vCloud Director need a name so we do reverse operation from provided UUID we lookup a name
1885 # [{'use': 'bridge', 'net_id': '527d4bf7-566a-41e7-a9e7-ca3cdd9cef4f', 'type': 'virtual',
1886 # 'vpci': '0000:00:11.0', 'name': 'eth0'}]
1888 if 'net_id' not in net
:
1891 #Using net_id as a vim_id i.e. vim interface id, as do not have saperate vim interface id
1892 #Same will be returned in refresh_vms_status() as vim_interface_id
1893 net
['vim_id'] = net
['net_id'] # Provide the same VIM identifier as the VIM network
1895 interface_net_id
= net
['net_id']
1896 interface_net_name
= self
.get_network_name_by_id(network_uuid
=interface_net_id
)
1897 interface_network_mode
= net
['use']
1899 if interface_network_mode
== 'mgmt':
1900 primary_nic_index
= nicIndex
1902 """- POOL (A static IP address is allocated automatically from a pool of addresses.)
1903 - DHCP (The IP address is obtained from a DHCP service.)
1904 - MANUAL (The IP address is assigned manually in the IpAddress element.)
1905 - NONE (No IP addressing mode specified.)"""
1907 if primary_netname
is not None:
1908 self
.logger
.debug("new_vminstance(): Filtering by net name {}".format(interface_net_name
))
1909 nets
= filter(lambda n
: n
.get('name') == interface_net_name
, self
.get_network_list())
1911 #nets = [n for n in self.get_network_list() if n.get('name') == interface_net_name]
1913 self
.logger
.info("new_vminstance(): Found requested network: {}".format(nets
[0].get('name')))
1915 if interface_net_name
!= primary_netname
:
1916 # connect network to VM - with all DHCP by default
1917 self
.logger
.info("new_vminstance(): Attaching net {} to vapp".format(interface_net_name
))
1918 task
= vapp
.connect_org_vdc_network(nets
[0].get('name'))
1919 self
.client
.get_task_monitor().wait_for_success(task
=task
)
1921 type_list
= ('PF', 'PCI-PASSTHROUGH', 'VF', 'SR-IOV', 'VFnotShared')
1922 if 'type' in net
and net
['type'] not in type_list
:
1923 # fetching nic type from vnf
1925 if net
['model'] is not None:
1926 if net
['model'].lower() == 'paravirt' or net
['model'].lower() == 'virtio':
1927 nic_type
= 'VMXNET3'
1929 nic_type
= net
['model']
1931 self
.logger
.info("new_vminstance(): adding network adapter "\
1932 "to a network {}".format(nets
[0].get('name')))
1933 self
.add_network_adapter_to_vms(vapp
, nets
[0].get('name'),
1939 self
.logger
.info("new_vminstance(): adding network adapter "\
1940 "to a network {}".format(nets
[0].get('name')))
1941 self
.add_network_adapter_to_vms(vapp
, nets
[0].get('name'),
1947 # cloud-init for ssh-key injection
1949 self
.cloud_init(vapp
,cloud_config
)
1951 # ############# Stub code for SRIOV #################
1953 # if len(sriov_net_info) > 0:
1954 # self.logger.info("Need to add SRIOV adapters {} into VM {}".format(sriov_net_info,
1956 # sriov_status, vm_obj, vcenter_conect = self.add_sriov(vapp_uuid,
1960 # self.logger.info("Added SRIOV {} to VM {}".format(
1964 # reserve_memory = True
1966 # self.logger.info("Fail to add SRIOV {} to VM {}".format(
1971 # If VM has PCI devices or SRIOV reserve memory for VM
1973 memReserve
= vm_obj
.config
.hardware
.memoryMB
1974 spec
= vim
.vm
.ConfigSpec()
1975 spec
.memoryAllocation
= vim
.ResourceAllocationInfo(reservation
=memReserve
)
1976 task
= vm_obj
.ReconfigVM_Task(spec
=spec
)
1978 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
1979 self
.logger
.info("Reserved memory {} MB for "
1980 "VM VM status: {}".format(str(memReserve
), result
))
1982 self
.logger
.info("Fail to reserved memory {} to VM {}".format(
1983 str(memReserve
), str(vm_obj
)))
1985 self
.logger
.debug("new_vminstance(): starting power on vApp {} ".format(vmname_andid
))
1987 vapp_id
= vapp_resource
.get('id').split(':')[-1]
1988 poweron_task
= self
.power_on_vapp(vapp_id
, vmname_andid
)
1989 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
1990 if result
.get('status') == 'success':
1991 self
.logger
.info("new_vminstance(): Successfully power on "\
1992 "vApp {}".format(vmname_andid
))
1994 self
.logger
.error("new_vminstance(): failed to power on vApp "\
1995 "{}".format(vmname_andid
))
1997 except Exception as exp
:
1998 # it might be a case if specific mandatory entry in dict is empty or some other pyVcloud exception
1999 self
.logger
.error("new_vminstance(): Failed create new vm instance {} with exception {}"
2001 raise vimconn
.vimconnException("new_vminstance(): Failed create new vm instance {} with exception {}"
2004 # check if vApp deployed and if that the case return vApp UUID otherwise -1
2007 while wait_time
<= MAX_WAIT_TIME
:
2009 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
2010 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2011 except Exception as exp
:
2012 raise vimconn
.vimconnUnexpectedResponse(
2013 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
2014 .format(vmname_andid
, exp
))
2016 #if vapp and vapp.me.deployed:
2017 if vapp
and vapp_resource
.get('deployed') == 'true':
2018 vapp_uuid
= vapp_resource
.get('id').split(':')[-1]
2021 self
.logger
.debug("new_vminstance(): Wait for vApp {} to deploy".format(name
))
2022 time
.sleep(INTERVAL_TIME
)
2024 wait_time
+=INTERVAL_TIME
2026 #SET Affinity Rule for VM
2027 #Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used
2028 #While creating VIM account user has to pass the Host Group names in availability_zone list
2029 #"availability_zone" is a part of VIM "config" parameters
2030 #For example, in VIM config: "availability_zone":["HG_170","HG_174","HG_175"]
2031 #Host groups are referred as availability zones
2032 #With following procedure, deployed VM will be added into a VM group.
2033 #Then A VM to Host Affinity rule will be created using the VM group & Host group.
2034 if(availability_zone_list
):
2035 self
.logger
.debug("Existing Host Groups in VIM {}".format(self
.config
.get('availability_zone')))
2036 #Admin access required for creating Affinity rules
2037 client
= self
.connect_as_admin()
2039 raise vimconn
.vimconnConnectionException("Failed to connect vCD as admin")
2041 self
.client
= client
2043 headers
= {'Accept':'application/*+xml;version=27.0',
2044 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2045 #Step1: Get provider vdc details from organization
2046 pvdc_href
= self
.get_pvdc_for_org(self
.tenant_name
, headers
)
2047 if pvdc_href
is not None:
2048 #Step2: Found required pvdc, now get resource pool information
2049 respool_href
= self
.get_resource_pool_details(pvdc_href
, headers
)
2050 if respool_href
is None:
2051 #Raise error if respool_href not found
2052 msg
= "new_vminstance():Error in finding resource pool details in pvdc {}"\
2054 self
.log_message(msg
)
2056 #Step3: Verify requested availability zone(hostGroup) is present in vCD
2057 # get availability Zone
2058 vm_az
= self
.get_vm_availability_zone(availability_zone_index
, availability_zone_list
)
2059 # check if provided av zone(hostGroup) is present in vCD VIM
2060 status
= self
.check_availibility_zone(vm_az
, respool_href
, headers
)
2062 msg
= "new_vminstance(): Error in finding availability zone(Host Group): {} in "\
2063 "resource pool {} status: {}".format(vm_az
,respool_href
,status
)
2064 self
.log_message(msg
)
2066 self
.logger
.debug ("new_vminstance(): Availability zone {} found in VIM".format(vm_az
))
2068 #Step4: Find VM group references to create vm group
2069 vmgrp_href
= self
.find_vmgroup_reference(respool_href
, headers
)
2070 if vmgrp_href
== None:
2071 msg
= "new_vminstance(): No reference to VmGroup found in resource pool"
2072 self
.log_message(msg
)
2074 #Step5: Create a VmGroup with name az_VmGroup
2075 vmgrp_name
= vm_az
+ "_" + name
#Formed VM Group name = Host Group name + VM name
2076 status
= self
.create_vmgroup(vmgrp_name
, vmgrp_href
, headers
)
2077 if status
is not True:
2078 msg
= "new_vminstance(): Error in creating VM group {}".format(vmgrp_name
)
2079 self
.log_message(msg
)
2081 #VM Group url to add vms to vm group
2082 vmgrpname_url
= self
.url
+ "/api/admin/extension/vmGroup/name/"+ vmgrp_name
2084 #Step6: Add VM to VM Group
2085 #Find VM uuid from vapp_uuid
2086 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
2087 vm_uuid
= vm_details
['vmuuid']
2089 status
= self
.add_vm_to_vmgroup(vm_uuid
, vmgrpname_url
, vmgrp_name
, headers
)
2090 if status
is not True:
2091 msg
= "new_vminstance(): Error in adding VM to VM group {}".format(vmgrp_name
)
2092 self
.log_message(msg
)
2094 #Step7: Create VM to Host affinity rule
2095 addrule_href
= self
.get_add_rule_reference (respool_href
, headers
)
2096 if addrule_href
is None:
2097 msg
= "new_vminstance(): Error in finding href to add rule in resource pool: {}"\
2098 .format(respool_href
)
2099 self
.log_message(msg
)
2101 status
= self
.create_vm_to_host_affinity_rule(addrule_href
, vmgrp_name
, vm_az
, "Affinity", headers
)
2103 msg
= "new_vminstance(): Error in creating affinity rule for VM {} in Host group {}"\
2104 .format(name
, vm_az
)
2105 self
.log_message(msg
)
2107 self
.logger
.debug("new_vminstance(): Affinity rule created successfully. Added {} in Host group {}"\
2108 .format(name
, vm_az
))
2109 #Reset token to a normal user to perform other operations
2112 if vapp_uuid
is not None:
2113 return vapp_uuid
, None
2115 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name
))
2118 def get_vcd_availibility_zones(self
,respool_href
, headers
):
2119 """ Method to find presence of av zone is VIM resource pool
2122 respool_href - resource pool href
2123 headers - header information
2126 vcd_az - list of azone present in vCD
2130 resp
= self
.perform_request(req_type
='GET',url
=respool_href
, headers
=headers
)
2132 if resp
.status_code
!= requests
.codes
.ok
:
2133 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(url
, resp
.status_code
))
2135 #Get the href to hostGroups and find provided hostGroup is present in it
2136 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2137 for child
in resp_xml
:
2138 if 'VMWProviderVdcResourcePool' in child
.tag
:
2139 for schild
in child
:
2140 if 'Link' in schild
.tag
:
2141 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
2142 hostGroup
= schild
.attrib
.get('href')
2143 hg_resp
= self
.perform_request(req_type
='GET',url
=hostGroup
, headers
=headers
)
2144 if hg_resp
.status_code
!= requests
.codes
.ok
:
2145 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(hostGroup
, hg_resp
.status_code
))
2147 hg_resp_xml
= XmlElementTree
.fromstring(hg_resp
.content
)
2148 for hostGroup
in hg_resp_xml
:
2149 if 'HostGroup' in hostGroup
.tag
:
2150 #append host group name to the list
2151 vcd_az
.append(hostGroup
.attrib
.get("name"))
2155 def set_availability_zones(self
):
2157 Set vim availability zone
2160 vim_availability_zones
= None
2161 availability_zone
= None
2162 if 'availability_zone' in self
.config
:
2163 vim_availability_zones
= self
.config
.get('availability_zone')
2164 if isinstance(vim_availability_zones
, str):
2165 availability_zone
= [vim_availability_zones
]
2166 elif isinstance(vim_availability_zones
, list):
2167 availability_zone
= vim_availability_zones
2169 return availability_zone
2171 return availability_zone
2174 def get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
2176 Return the availability zone to be used by the created VM.
2177 returns: The VIM availability zone to be used or None
2179 if availability_zone_index
is None:
2180 if not self
.config
.get('availability_zone'):
2182 elif isinstance(self
.config
.get('availability_zone'), str):
2183 return self
.config
['availability_zone']
2185 return self
.config
['availability_zone'][0]
2187 vim_availability_zones
= self
.availability_zone
2189 # check if VIM offer enough availability zones describe in the VNFD
2190 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
2191 # check if all the names of NFV AV match VIM AV names
2192 match_by_index
= False
2193 for av
in availability_zone_list
:
2194 if av
not in vim_availability_zones
:
2195 match_by_index
= True
2198 self
.logger
.debug("Required Availability zone or Host Group not found in VIM config")
2199 self
.logger
.debug("Input Availability zone list: {}".format(availability_zone_list
))
2200 self
.logger
.debug("VIM configured Availability zones: {}".format(vim_availability_zones
))
2201 self
.logger
.debug("VIM Availability zones will be used by index")
2202 return vim_availability_zones
[availability_zone_index
]
2204 return availability_zone_list
[availability_zone_index
]
2206 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
2209 def create_vm_to_host_affinity_rule(self
, addrule_href
, vmgrpname
, hostgrpname
, polarity
, headers
):
2210 """ Method to create VM to Host Affinity rule in vCD
2213 addrule_href - href to make a POST request
2214 vmgrpname - name of the VM group created
2215 hostgrpnmae - name of the host group created earlier
2216 polarity - Affinity or Anti-affinity (default: Affinity)
2217 headers - headers to make REST call
2220 True- if rule is created
2221 False- Failed to create rule due to some error
2225 rule_name
= polarity
+ "_" + vmgrpname
2226 payload
= """<?xml version="1.0" encoding="UTF-8"?>
2227 <vmext:VMWVmHostAffinityRule
2228 xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5"
2229 xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
2230 type="application/vnd.vmware.admin.vmwVmHostAffinityRule+xml">
2231 <vcloud:Name>{}</vcloud:Name>
2232 <vcloud:IsEnabled>true</vcloud:IsEnabled>
2233 <vcloud:IsMandatory>true</vcloud:IsMandatory>
2234 <vcloud:Polarity>{}</vcloud:Polarity>
2235 <vmext:HostGroupName>{}</vmext:HostGroupName>
2236 <vmext:VmGroupName>{}</vmext:VmGroupName>
2237 </vmext:VMWVmHostAffinityRule>""".format(rule_name
, polarity
, hostgrpname
, vmgrpname
)
2239 resp
= self
.perform_request(req_type
='POST',url
=addrule_href
, headers
=headers
, data
=payload
)
2241 if resp
.status_code
!= requests
.codes
.accepted
:
2242 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(addrule_href
, resp
.status_code
))
2246 affinity_task
= self
.get_task_from_response(resp
.content
)
2247 self
.logger
.debug ("affinity_task: {}".format(affinity_task
))
2248 if affinity_task
is None or affinity_task
is False:
2249 raise vimconn
.vimconnUnexpectedResponse("failed to find affinity task")
2250 # wait for task to complete
2251 result
= self
.client
.get_task_monitor().wait_for_success(task
=affinity_task
)
2252 if result
.get('status') == 'success':
2253 self
.logger
.debug("Successfully created affinity rule {}".format(rule_name
))
2256 raise vimconn
.vimconnUnexpectedResponse(
2257 "failed to create affinity rule {}".format(rule_name
))
2260 def get_add_rule_reference (self
, respool_href
, headers
):
2261 """ This method finds href to add vm to host affinity rule to vCD
2264 respool_href- href to resource pool
2265 headers- header information to make REST call
2268 None - if no valid href to add rule found or
2269 addrule_href - href to add vm to host affinity rule of resource pool
2272 resp
= self
.perform_request(req_type
='GET',url
=respool_href
, headers
=headers
)
2274 if resp
.status_code
!= requests
.codes
.ok
:
2275 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(respool_href
, resp
.status_code
))
2278 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2279 for child
in resp_xml
:
2280 if 'VMWProviderVdcResourcePool' in child
.tag
:
2281 for schild
in child
:
2282 if 'Link' in schild
.tag
:
2283 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwVmHostAffinityRule+xml" and \
2284 schild
.attrib
.get('rel') == "add":
2285 addrule_href
= schild
.attrib
.get('href')
2291 def add_vm_to_vmgroup(self
, vm_uuid
, vmGroupNameURL
, vmGroup_name
, headers
):
2292 """ Method to add deployed VM to newly created VM Group.
2293 This is required to create VM to Host affinity in vCD
2296 vm_uuid- newly created vm uuid
2297 vmGroupNameURL- URL to VM Group name
2298 vmGroup_name- Name of VM group created
2299 headers- Headers for REST request
2302 True- if VM added to VM group successfully
2303 False- if any error encounter
2306 addvm_resp
= self
.perform_request(req_type
='GET',url
=vmGroupNameURL
, headers
=headers
)#, data=payload)
2308 if addvm_resp
.status_code
!= requests
.codes
.ok
:
2309 self
.logger
.debug ("REST API call to get VM Group Name url {} failed. Return status code {}"\
2310 .format(vmGroupNameURL
, addvm_resp
.status_code
))
2313 resp_xml
= XmlElementTree
.fromstring(addvm_resp
.content
)
2314 for child
in resp_xml
:
2315 if child
.tag
.split('}')[1] == 'Link':
2316 if child
.attrib
.get("rel") == "addVms":
2317 addvmtogrpURL
= child
.attrib
.get("href")
2320 url_list
= [self
.url
, '/api/vApp/vm-',vm_uuid
]
2321 vmdetailsURL
= ''.join(url_list
)
2323 resp
= self
.perform_request(req_type
='GET',url
=vmdetailsURL
, headers
=headers
)
2325 if resp
.status_code
!= requests
.codes
.ok
:
2326 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(vmdetailsURL
, resp
.status_code
))
2330 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2331 if resp_xml
.tag
.split('}')[1] == "Vm":
2332 vm_id
= resp_xml
.attrib
.get("id")
2333 vm_name
= resp_xml
.attrib
.get("name")
2334 vm_href
= resp_xml
.attrib
.get("href")
2335 #print vm_id, vm_name, vm_href
2336 #Add VM into VMgroup
2337 payload
= """<?xml version="1.0" encoding="UTF-8"?>\
2338 <ns2:Vms xmlns:ns2="http://www.vmware.com/vcloud/v1.5" \
2339 xmlns="http://www.vmware.com/vcloud/versions" \
2340 xmlns:ns3="http://schemas.dmtf.org/ovf/envelope/1" \
2341 xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" \
2342 xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/common" \
2343 xmlns:ns6="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" \
2344 xmlns:ns7="http://www.vmware.com/schema/ovf" \
2345 xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1" \
2346 xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">\
2347 <ns2:VmReference href="{}" id="{}" name="{}" \
2348 type="application/vnd.vmware.vcloud.vm+xml" />\
2349 </ns2:Vms>""".format(vm_href
, vm_id
, vm_name
)
2351 addvmtogrp_resp
= self
.perform_request(req_type
='POST',url
=addvmtogrpURL
, headers
=headers
, data
=payload
)
2353 if addvmtogrp_resp
.status_code
!= requests
.codes
.accepted
:
2354 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(addvmtogrpURL
, addvmtogrp_resp
.status_code
))
2357 self
.logger
.debug ("Done adding VM {} to VMgroup {}".format(vm_name
, vmGroup_name
))
2361 def create_vmgroup(self
, vmgroup_name
, vmgroup_href
, headers
):
2362 """Method to create a VM group in vCD
2365 vmgroup_name : Name of VM group to be created
2366 vmgroup_href : href for vmgroup
2367 headers- Headers for REST request
2369 #POST to add URL with required data
2370 vmgroup_status
= False
2371 payload
= """<VMWVmGroup xmlns="http://www.vmware.com/vcloud/extension/v1.5" \
2372 xmlns:vcloud_v1.5="http://www.vmware.com/vcloud/v1.5" name="{}">\
2373 <vmCount>1</vmCount>\
2374 </VMWVmGroup>""".format(vmgroup_name
)
2375 resp
= self
.perform_request(req_type
='POST',url
=vmgroup_href
, headers
=headers
, data
=payload
)
2377 if resp
.status_code
!= requests
.codes
.accepted
:
2378 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(vmgroup_href
, resp
.status_code
))
2379 return vmgroup_status
2381 vmgroup_task
= self
.get_task_from_response(resp
.content
)
2382 if vmgroup_task
is None or vmgroup_task
is False:
2383 raise vimconn
.vimconnUnexpectedResponse(
2384 "create_vmgroup(): failed to create VM group {}".format(vmgroup_name
))
2386 # wait for task to complete
2387 result
= self
.client
.get_task_monitor().wait_for_success(task
=vmgroup_task
)
2389 if result
.get('status') == 'success':
2390 self
.logger
.debug("create_vmgroup(): Successfully created VM group {}".format(vmgroup_name
))
2392 vmgroup_status
= True
2393 return vmgroup_status
2395 raise vimconn
.vimconnUnexpectedResponse(\
2396 "create_vmgroup(): failed to create VM group {}".format(vmgroup_name
))
2399 def find_vmgroup_reference(self
, url
, headers
):
2400 """ Method to create a new VMGroup which is required to add created VM
2402 url- resource pool href
2403 headers- header information
2406 returns href to VM group to create VM group
2408 #Perform GET on resource pool to find 'add' link to create VMGroup
2409 #https://vcd-ip/api/admin/extension/providervdc/<providervdc id>/resourcePools
2411 resp
= self
.perform_request(req_type
='GET',url
=url
, headers
=headers
)
2413 if resp
.status_code
!= requests
.codes
.ok
:
2414 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(url
, resp
.status_code
))
2416 #Get the href to add vmGroup to vCD
2417 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2418 for child
in resp_xml
:
2419 if 'VMWProviderVdcResourcePool' in child
.tag
:
2420 for schild
in child
:
2421 if 'Link' in schild
.tag
:
2422 #Find href with type VMGroup and rel with add
2423 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwVmGroupType+xml"\
2424 and schild
.attrib
.get('rel') == "add":
2425 vmgrp_href
= schild
.attrib
.get('href')
2429 def check_availibility_zone(self
, az
, respool_href
, headers
):
2430 """ Method to verify requested av zone is present or not in provided
2434 az - name of hostgroup (availibility_zone)
2435 respool_href - Resource Pool href
2436 headers - Headers to make REST call
2438 az_found - True if availibility_zone is found else False
2441 headers
['Accept']='application/*+xml;version=27.0'
2442 resp
= self
.perform_request(req_type
='GET',url
=respool_href
, headers
=headers
)
2444 if resp
.status_code
!= requests
.codes
.ok
:
2445 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(respool_href
, resp
.status_code
))
2447 #Get the href to hostGroups and find provided hostGroup is present in it
2448 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2450 for child
in resp_xml
:
2451 if 'VMWProviderVdcResourcePool' in child
.tag
:
2452 for schild
in child
:
2453 if 'Link' in schild
.tag
:
2454 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
2455 hostGroup_href
= schild
.attrib
.get('href')
2456 hg_resp
= self
.perform_request(req_type
='GET',url
=hostGroup_href
, headers
=headers
)
2457 if hg_resp
.status_code
!= requests
.codes
.ok
:
2458 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(hostGroup_href
, hg_resp
.status_code
))
2460 hg_resp_xml
= XmlElementTree
.fromstring(hg_resp
.content
)
2461 for hostGroup
in hg_resp_xml
:
2462 if 'HostGroup' in hostGroup
.tag
:
2463 if hostGroup
.attrib
.get("name") == az
:
2469 def get_pvdc_for_org(self
, org_vdc
, headers
):
2470 """ This method gets provider vdc references from organisation
2473 org_vdc - name of the organisation VDC to find pvdc
2474 headers - headers to make REST call
2477 None - if no pvdc href found else
2478 pvdc_href - href to pvdc
2481 #Get provider VDC references from vCD
2483 #url = '<vcd url>/api/admin/extension/providerVdcReferences'
2484 url_list
= [self
.url
, '/api/admin/extension/providerVdcReferences']
2485 url
= ''.join(url_list
)
2487 response
= self
.perform_request(req_type
='GET',url
=url
, headers
=headers
)
2488 if response
.status_code
!= requests
.codes
.ok
:
2489 self
.logger
.debug ("REST API call {} failed. Return status code {}"\
2490 .format(url
, response
.status_code
))
2492 xmlroot_response
= XmlElementTree
.fromstring(response
.content
)
2493 for child
in xmlroot_response
:
2494 if 'ProviderVdcReference' in child
.tag
:
2495 pvdc_href
= child
.attrib
.get('href')
2496 #Get vdcReferences to find org
2497 pvdc_resp
= self
.perform_request(req_type
='GET',url
=pvdc_href
, headers
=headers
)
2498 if pvdc_resp
.status_code
!= requests
.codes
.ok
:
2499 raise vimconn
.vimconnException("REST API call {} failed. "\
2500 "Return status code {}"\
2501 .format(url
, pvdc_resp
.status_code
))
2503 pvdc_resp_xml
= XmlElementTree
.fromstring(pvdc_resp
.content
)
2504 for child
in pvdc_resp_xml
:
2505 if 'Link' in child
.tag
:
2506 if child
.attrib
.get('type') == "application/vnd.vmware.admin.vdcReferences+xml":
2507 vdc_href
= child
.attrib
.get('href')
2509 #Check if provided org is present in vdc
2510 vdc_resp
= self
.perform_request(req_type
='GET',
2513 if vdc_resp
.status_code
!= requests
.codes
.ok
:
2514 raise vimconn
.vimconnException("REST API call {} failed. "\
2515 "Return status code {}"\
2516 .format(url
, vdc_resp
.status_code
))
2517 vdc_resp_xml
= XmlElementTree
.fromstring(vdc_resp
.content
)
2518 for child
in vdc_resp_xml
:
2519 if 'VdcReference' in child
.tag
:
2520 if child
.attrib
.get('name') == org_vdc
:
2524 def get_resource_pool_details(self
, pvdc_href
, headers
):
2525 """ Method to get resource pool information.
2526 Host groups are property of resource group.
2527 To get host groups, we need to GET details of resource pool.
2530 pvdc_href: href to pvdc details
2534 respool_href - Returns href link reference to resource pool
2537 resp
= self
.perform_request(req_type
='GET',url
=pvdc_href
, headers
=headers
)
2539 if resp
.status_code
!= requests
.codes
.ok
:
2540 self
.logger
.debug ("REST API call {} failed. Return status code {}"\
2541 .format(pvdc_href
, resp
.status_code
))
2543 respool_resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2544 for child
in respool_resp_xml
:
2545 if 'Link' in child
.tag
:
2546 if child
.attrib
.get('type') == "application/vnd.vmware.admin.vmwProviderVdcResourcePoolSet+xml":
2547 respool_href
= child
.attrib
.get("href")
2552 def log_message(self
, msg
):
2554 Method to log error messages related to Affinity rule creation
2555 in new_vminstance & raise Exception
2557 msg - Error message to be logged
2560 #get token to connect vCD as a normal user
2562 self
.logger
.debug(msg
)
2563 raise vimconn
.vimconnException(msg
)
2568 ## based on current discussion
2572 # created: '2016-09-08T11:51:58'
2573 # description: simple-instance.linux1.1
2574 # flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
2575 # hostId: e836c036-74e7-11e6-b249-0800273e724c
2576 # image: dde30fe6-75a9-11e6-ad5f-0800273e724c
2581 def get_vminstance(self
, vim_vm_uuid
=None):
2582 """Returns the VM instance information from VIM"""
2584 self
.logger
.debug("Client requesting vm instance {} ".format(vim_vm_uuid
))
2586 org
, vdc
= self
.get_vdc_details()
2588 raise vimconn
.vimconnConnectionException(
2589 "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2591 vm_info_dict
= self
.get_vapp_details_rest(vapp_uuid
=vim_vm_uuid
)
2592 if not vm_info_dict
:
2593 self
.logger
.debug("get_vminstance(): Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
2594 raise vimconn
.vimconnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
2596 status_key
= vm_info_dict
['status']
2599 vm_dict
= {'created': vm_info_dict
['created'],
2600 'description': vm_info_dict
['name'],
2601 'status': vcdStatusCode2manoFormat
[int(status_key
)],
2602 'hostId': vm_info_dict
['vmuuid'],
2604 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
2606 if 'interfaces' in vm_info_dict
:
2607 vm_dict
['interfaces'] = vm_info_dict
['interfaces']
2609 vm_dict
['interfaces'] = []
2611 vm_dict
= {'created': '',
2613 'status': vcdStatusCode2manoFormat
[int(-1)],
2614 'hostId': vm_info_dict
['vmuuid'],
2615 'error_msg': "Inconsistency state",
2616 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
2620 def delete_vminstance(self
, vm__vim_uuid
, created_items
=None):
2621 """Method poweroff and remove VM instance from vcloud director network.
2624 vm__vim_uuid: VM UUID
2627 Returns the instance identifier
2630 self
.logger
.debug("Client requesting delete vm instance {} ".format(vm__vim_uuid
))
2632 org
, vdc
= self
.get_vdc_details()
2633 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2635 self
.logger
.debug("delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(
2637 raise vimconn
.vimconnException(
2638 "delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2641 vapp_name
= self
.get_namebyvappid(vm__vim_uuid
)
2642 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2643 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2644 if vapp_name
is None:
2645 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2646 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2648 self
.logger
.info("Deleting vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
2650 # Delete vApp and wait for status change if task executed and vApp is None.
2653 if vapp_resource
.get('deployed') == 'true':
2654 self
.logger
.info("Powering off vApp {}".format(vapp_name
))
2658 while wait_time
<= MAX_WAIT_TIME
:
2659 power_off_task
= vapp
.power_off()
2660 result
= self
.client
.get_task_monitor().wait_for_success(task
=power_off_task
)
2662 if result
.get('status') == 'success':
2666 self
.logger
.info("Wait for vApp {} to power off".format(vapp_name
))
2667 time
.sleep(INTERVAL_TIME
)
2669 wait_time
+=INTERVAL_TIME
2671 self
.logger
.debug("delete_vminstance(): Failed to power off VM instance {} ".format(vm__vim_uuid
))
2673 self
.logger
.info("delete_vminstance(): Powered off VM instance {} ".format(vm__vim_uuid
))
2676 self
.logger
.info("Undeploy vApp {}".format(vapp_name
))
2679 while wait_time
<= MAX_WAIT_TIME
:
2680 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2682 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2683 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2684 undeploy_task
= vapp
.undeploy()
2686 result
= self
.client
.get_task_monitor().wait_for_success(task
=undeploy_task
)
2687 if result
.get('status') == 'success':
2691 self
.logger
.debug("Wait for vApp {} to undeploy".format(vapp_name
))
2692 time
.sleep(INTERVAL_TIME
)
2694 wait_time
+=INTERVAL_TIME
2697 self
.logger
.debug("delete_vminstance(): Failed to undeploy vApp {} ".format(vm__vim_uuid
))
2700 self
.logger
.info("Start deletion of vApp {} ".format(vapp_name
))
2702 if vapp
is not None:
2706 while wait_time
<= MAX_WAIT_TIME
:
2707 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2709 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2710 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2712 delete_task
= vdc_obj
.delete_vapp(vapp
.name
, force
=True)
2714 result
= self
.client
.get_task_monitor().wait_for_success(task
=delete_task
)
2715 if result
.get('status') == 'success':
2718 self
.logger
.debug("Wait for vApp {} to delete".format(vapp_name
))
2719 time
.sleep(INTERVAL_TIME
)
2721 wait_time
+=INTERVAL_TIME
2724 self
.logger
.debug("delete_vminstance(): Failed delete uuid {} ".format(vm__vim_uuid
))
2726 self
.logger
.info("Deleted vm instance {} sccessfully".format(vm__vim_uuid
))
2729 self
.logger
.debug(traceback
.format_exc())
2730 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
2733 def refresh_vms_status(self
, vm_list
):
2734 """Get the status of the virtual machines and their interfaces/ports
2735 Params: the list of VM identifiers
2736 Returns a dictionary with:
2737 vm_id: #VIM id of this Virtual Machine
2738 status: #Mandatory. Text with one of:
2739 # DELETED (not found at vim)
2740 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2741 # OTHER (Vim reported other status not understood)
2742 # ERROR (VIM indicates an ERROR status)
2743 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
2744 # CREATING (on building process), ERROR
2745 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
2747 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2748 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2750 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2751 mac_address: #Text format XX:XX:XX:XX:XX:XX
2752 vim_net_id: #network id where this interface is connected
2753 vim_interface_id: #interface/port VIM id
2754 ip_address: #null, or text with IPv4, IPv6 address
2757 self
.logger
.debug("Client requesting refresh vm status for {} ".format(vm_list
))
2759 org
,vdc
= self
.get_vdc_details()
2761 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2765 for vmuuid
in vm_list
:
2766 vapp_name
= self
.get_namebyvappid(vmuuid
)
2767 if vapp_name
is not None:
2770 vm_pci_details
= self
.get_vm_pci_details(vmuuid
)
2771 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2772 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2773 the_vapp
= VApp(self
.client
, resource
=vapp_resource
)
2776 for vm
in the_vapp
.get_all_vms():
2777 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2778 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2779 response
= self
.perform_request(req_type
='GET',
2783 if response
.status_code
!= 200:
2784 self
.logger
.error("refresh_vms_status : REST call {} failed reason : {}"\
2785 "status code : {}".format(vm
.get('href'),
2787 response
.status_code
))
2788 raise vimconn
.vimconnException("refresh_vms_status : Failed to get "\
2790 xmlroot
= XmlElementTree
.fromstring(response
.content
)
2793 result
= response
.content
.replace("\n"," ")
2794 hdd_match
= re
.search('vcloud:capacity="(\d+)"\svcloud:storageProfileOverrideVmDefault=',result
)
2796 hdd_mb
= hdd_match
.group(1)
2797 vm_details
['hdd_mb'] = int(hdd_mb
) if hdd_mb
else None
2798 cpus_match
= re
.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result
)
2800 cpus
= cpus_match
.group(1)
2801 vm_details
['cpus'] = int(cpus
) if cpus
else None
2802 memory_mb
= re
.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
2803 vm_details
['memory_mb'] = int(memory_mb
) if memory_mb
else None
2804 vm_details
['status'] = vcdStatusCode2manoFormat
[int(xmlroot
.get('status'))]
2805 vm_details
['id'] = xmlroot
.get('id')
2806 vm_details
['name'] = xmlroot
.get('name')
2807 vm_info
= [vm_details
]
2809 vm_info
[0].update(vm_pci_details
)
2811 vm_dict
= {'status': vcdStatusCode2manoFormat
[int(vapp_resource
.get('status'))],
2812 'error_msg': vcdStatusCode2manoFormat
[int(vapp_resource
.get('status'))],
2813 'vim_info': yaml
.safe_dump(vm_info
), 'interfaces': []}
2818 networks
= re
.findall('<NetworkConnection needsCustomization=.*?</NetworkConnection>',result
)
2819 for network
in networks
:
2820 mac_s
= re
.search('<MACAddress>(.*?)</MACAddress>',network
)
2821 vm_mac
= mac_s
.group(1) if mac_s
else None
2822 ip_s
= re
.search('<IpAddress>(.*?)</IpAddress>',network
)
2823 vm_ip
= ip_s
.group(1) if ip_s
else None
2826 if not nsx_edge_list
:
2827 nsx_edge_list
= self
.get_edge_details()
2828 if nsx_edge_list
is None:
2829 raise vimconn
.vimconnException("refresh_vms_status:"\
2830 "Failed to get edge details from NSX Manager")
2831 if vm_mac
is not None:
2832 vm_ip
= self
.get_ipaddr_from_NSXedge(nsx_edge_list
, vm_mac
)
2834 net_s
= re
.search('network="(.*?)"',network
)
2835 network_name
= net_s
.group(1) if net_s
else None
2837 vm_net_id
= self
.get_network_id_by_name(network_name
)
2838 interface
= {"mac_address": vm_mac
,
2839 "vim_net_id": vm_net_id
,
2840 "vim_interface_id": vm_net_id
,
2841 "ip_address": vm_ip
}
2843 vm_dict
["interfaces"].append(interface
)
2845 # add a vm to vm dict
2846 vms_dict
.setdefault(vmuuid
, vm_dict
)
2847 self
.logger
.debug("refresh_vms_status : vm info {}".format(vm_dict
))
2848 except Exception as exp
:
2849 self
.logger
.debug("Error in response {}".format(exp
))
2850 self
.logger
.debug(traceback
.format_exc())
2855 def get_edge_details(self
):
2856 """Get the NSX edge list from NSX Manager
2857 Returns list of NSX edges
2860 rheaders
= {'Content-Type': 'application/xml'}
2861 nsx_api_url
= '/api/4.0/edges'
2863 self
.logger
.debug("Get edge details from NSX Manager {} {}".format(self
.nsx_manager
, nsx_api_url
))
2866 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2867 auth
= (self
.nsx_user
, self
.nsx_password
),
2868 verify
= False, headers
= rheaders
)
2869 if resp
.status_code
== requests
.codes
.ok
:
2870 paged_Edge_List
= XmlElementTree
.fromstring(resp
.text
)
2871 for edge_pages
in paged_Edge_List
:
2872 if edge_pages
.tag
== 'edgePage':
2873 for edge_summary
in edge_pages
:
2874 if edge_summary
.tag
== 'pagingInfo':
2875 for element
in edge_summary
:
2876 if element
.tag
== 'totalCount' and element
.text
== '0':
2877 raise vimconn
.vimconnException("get_edge_details: No NSX edges details found: {}"
2878 .format(self
.nsx_manager
))
2880 if edge_summary
.tag
== 'edgeSummary':
2881 for element
in edge_summary
:
2882 if element
.tag
== 'id':
2883 edge_list
.append(element
.text
)
2885 raise vimconn
.vimconnException("get_edge_details: No NSX edge details found: {}"
2886 .format(self
.nsx_manager
))
2889 raise vimconn
.vimconnException("get_edge_details: "\
2890 "No NSX edge details found: {}"
2891 .format(self
.nsx_manager
))
2893 self
.logger
.debug("get_edge_details: Found NSX edges {}".format(edge_list
))
2896 self
.logger
.debug("get_edge_details: "
2897 "Failed to get NSX edge details from NSX Manager: {}"
2898 .format(resp
.content
))
2901 except Exception as exp
:
2902 self
.logger
.debug("get_edge_details: "\
2903 "Failed to get NSX edge details from NSX Manager: {}"
2905 raise vimconn
.vimconnException("get_edge_details: "\
2906 "Failed to get NSX edge details from NSX Manager: {}"
2910 def get_ipaddr_from_NSXedge(self
, nsx_edges
, mac_address
):
2911 """Get IP address details from NSX edges, using the MAC address
2912 PARAMS: nsx_edges : List of NSX edges
2913 mac_address : Find IP address corresponding to this MAC address
2914 Returns: IP address corrresponding to the provided MAC address
2918 rheaders
= {'Content-Type': 'application/xml'}
2920 self
.logger
.debug("get_ipaddr_from_NSXedge: Finding IP addr from NSX edge")
2923 for edge
in nsx_edges
:
2924 nsx_api_url
= '/api/4.0/edges/'+ edge
+'/dhcp/leaseInfo'
2926 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2927 auth
= (self
.nsx_user
, self
.nsx_password
),
2928 verify
= False, headers
= rheaders
)
2930 if resp
.status_code
== requests
.codes
.ok
:
2931 dhcp_leases
= XmlElementTree
.fromstring(resp
.text
)
2932 for child
in dhcp_leases
:
2933 if child
.tag
== 'dhcpLeaseInfo':
2934 dhcpLeaseInfo
= child
2935 for leaseInfo
in dhcpLeaseInfo
:
2936 for elem
in leaseInfo
:
2937 if (elem
.tag
)=='macAddress':
2938 edge_mac_addr
= elem
.text
2939 if (elem
.tag
)=='ipAddress':
2941 if edge_mac_addr
is not None:
2942 if edge_mac_addr
== mac_address
:
2943 self
.logger
.debug("Found ip addr {} for mac {} at NSX edge {}"
2944 .format(ip_addr
, mac_address
,edge
))
2947 self
.logger
.debug("get_ipaddr_from_NSXedge: "\
2948 "Error occurred while getting DHCP lease info from NSX Manager: {}"
2949 .format(resp
.content
))
2951 self
.logger
.debug("get_ipaddr_from_NSXedge: No IP addr found in any NSX edge")
2954 except XmlElementTree
.ParseError
as Err
:
2955 self
.logger
.debug("ParseError in response from NSX Manager {}".format(Err
.message
), exc_info
=True)
2958 def action_vminstance(self
, vm__vim_uuid
=None, action_dict
=None, created_items
={}):
2959 """Send and action over a VM instance from VIM
2960 Returns the vm_id if the action was successfully sent to the VIM"""
2962 self
.logger
.debug("Received action for vm {} and action dict {}".format(vm__vim_uuid
, action_dict
))
2963 if vm__vim_uuid
is None or action_dict
is None:
2964 raise vimconn
.vimconnException("Invalid request. VM id or action is None.")
2966 org
, vdc
= self
.get_vdc_details()
2968 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2970 vapp_name
= self
.get_namebyvappid(vm__vim_uuid
)
2971 if vapp_name
is None:
2972 self
.logger
.debug("action_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2973 raise vimconn
.vimconnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2975 self
.logger
.info("Action_vminstance vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
2978 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2979 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2980 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2981 if "start" in action_dict
:
2982 self
.logger
.info("action_vminstance: Power on vApp: {}".format(vapp_name
))
2983 poweron_task
= self
.power_on_vapp(vm__vim_uuid
, vapp_name
)
2984 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
2985 self
.instance_actions_result("start", result
, vapp_name
)
2986 elif "rebuild" in action_dict
:
2987 self
.logger
.info("action_vminstance: Rebuild vApp: {}".format(vapp_name
))
2988 rebuild_task
= vapp
.deploy(power_on
=True)
2989 result
= self
.client
.get_task_monitor().wait_for_success(task
=rebuild_task
)
2990 self
.instance_actions_result("rebuild", result
, vapp_name
)
2991 elif "pause" in action_dict
:
2992 self
.logger
.info("action_vminstance: pause vApp: {}".format(vapp_name
))
2993 pause_task
= vapp
.undeploy(action
='suspend')
2994 result
= self
.client
.get_task_monitor().wait_for_success(task
=pause_task
)
2995 self
.instance_actions_result("pause", result
, vapp_name
)
2996 elif "resume" in action_dict
:
2997 self
.logger
.info("action_vminstance: resume vApp: {}".format(vapp_name
))
2998 poweron_task
= self
.power_on_vapp(vm__vim_uuid
, vapp_name
)
2999 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
3000 self
.instance_actions_result("resume", result
, vapp_name
)
3001 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
3002 action_name
, value
= action_dict
.items()[0]
3004 #action_name , value = list(action_dict.items())[0]
3005 self
.logger
.info("action_vminstance: {} vApp: {}".format(action_name
, vapp_name
))
3006 shutdown_task
= vapp
.shutdown()
3007 result
= self
.client
.get_task_monitor().wait_for_success(task
=shutdown_task
)
3008 if action_name
== "shutdown":
3009 self
.instance_actions_result("shutdown", result
, vapp_name
)
3011 self
.instance_actions_result("shutoff", result
, vapp_name
)
3012 elif "forceOff" in action_dict
:
3013 result
= vapp
.undeploy(action
='powerOff')
3014 self
.instance_actions_result("forceOff", result
, vapp_name
)
3015 elif "reboot" in action_dict
:
3016 self
.logger
.info("action_vminstance: reboot vApp: {}".format(vapp_name
))
3017 reboot_task
= vapp
.reboot()
3018 self
.client
.get_task_monitor().wait_for_success(task
=reboot_task
)
3020 raise vimconn
.vimconnException("action_vminstance: Invalid action {} or action is None.".format(action_dict
))
3022 except Exception as exp
:
3023 self
.logger
.debug("action_vminstance: Failed with Exception {}".format(exp
))
3024 raise vimconn
.vimconnException("action_vminstance: Failed with Exception {}".format(exp
))
3026 def instance_actions_result(self
, action
, result
, vapp_name
):
3027 if result
.get('status') == 'success':
3028 self
.logger
.info("action_vminstance: Sucessfully {} the vApp: {}".format(action
, vapp_name
))
3030 self
.logger
.error("action_vminstance: Failed to {} vApp: {}".format(action
, vapp_name
))
3032 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
3034 Get a console for the virtual machine
3036 vm_id: uuid of the VM
3037 console_type, can be:
3038 "novnc" (by default), "xvpvnc" for VNC types,
3039 "rdp-html5" for RDP types, "spice-html5" for SPICE types
3040 Returns dict with the console parameters:
3041 protocol: ssh, ftp, http, https, ...
3042 server: usually ip address
3043 port: the http, ssh, ... port
3044 suffix: extra text, e.g. the http path and query string
3046 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3048 # NOT USED METHODS in current version
3050 def host_vim2gui(self
, host
, server_dict
):
3051 """Transform host dictionary from VIM format to GUI format,
3052 and append to the server_dict
3054 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3056 def get_hosts_info(self
):
3057 """Get the information of deployed hosts
3058 Returns the hosts content"""
3059 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3061 def get_hosts(self
, vim_tenant
):
3062 """Get the hosts and deployed instances
3063 Returns the hosts content"""
3064 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3066 def get_processor_rankings(self
):
3067 """Get the processor rankings in the VIM database"""
3068 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3070 def new_host(self
, host_data
):
3071 """Adds a new host to VIM"""
3072 '''Returns status code of the VIM response'''
3073 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3075 def new_external_port(self
, port_data
):
3076 """Adds a external port to VIM"""
3077 '''Returns the port identifier'''
3078 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3080 def new_external_network(self
, net_name
, net_type
):
3081 """Adds a external network to VIM (shared)"""
3082 '''Returns the network identifier'''
3083 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3085 def connect_port_network(self
, port_id
, network_id
, admin
=False):
3086 """Connects a external port to a network"""
3087 '''Returns status code of the VIM response'''
3088 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3090 def new_vminstancefromJSON(self
, vm_data
):
3091 """Adds a VM instance to VIM"""
3092 '''Returns the instance identifier'''
3093 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3095 def get_network_name_by_id(self
, network_uuid
=None):
3096 """Method gets vcloud director network named based on supplied uuid.
3099 network_uuid: network_id
3102 The return network name.
3105 if not network_uuid
:
3109 org_dict
= self
.get_org(self
.org_uuid
)
3110 if 'networks' in org_dict
:
3111 org_network_dict
= org_dict
['networks']
3112 for net_uuid
in org_network_dict
:
3113 if net_uuid
== network_uuid
:
3114 return org_network_dict
[net_uuid
]
3116 self
.logger
.debug("Exception in get_network_name_by_id")
3117 self
.logger
.debug(traceback
.format_exc())
3121 def get_network_id_by_name(self
, network_name
=None):
3122 """Method gets vcloud director network uuid based on supplied name.
3125 network_name: network_name
3127 The return network uuid.
3128 network_uuid: network_id
3131 if not network_name
:
3132 self
.logger
.debug("get_network_id_by_name() : Network name is empty")
3136 org_dict
= self
.get_org(self
.org_uuid
)
3137 if org_dict
and 'networks' in org_dict
:
3138 org_network_dict
= org_dict
['networks']
3139 for net_uuid
,net_name
in org_network_dict
.iteritems():
3141 #for net_uuid,net_name in org_network_dict.items():
3142 if net_name
== network_name
:
3145 except KeyError as exp
:
3146 self
.logger
.debug("get_network_id_by_name() : KeyError- {} ".format(exp
))
3150 def list_org_action(self
):
3152 Method leverages vCloud director and query for available organization for particular user
3155 vca - is active VCA connection.
3156 vdc_name - is a vdc name that will be used to query vms action
3159 The return XML respond
3161 url_list
= [self
.url
, '/api/org']
3162 vm_list_rest_call
= ''.join(url_list
)
3164 if self
.client
._session
:
3165 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3166 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3168 response
= self
.perform_request(req_type
='GET',
3169 url
=vm_list_rest_call
,
3172 if response
.status_code
== 403:
3173 response
= self
.retry_rest('GET', vm_list_rest_call
)
3175 if response
.status_code
== requests
.codes
.ok
:
3176 return response
.content
3180 def get_org_action(self
, org_uuid
=None):
3182 Method leverages vCloud director and retrieve available object for organization.
3185 org_uuid - vCD organization uuid
3186 self.client - is active connection.
3189 The return XML respond
3192 if org_uuid
is None:
3195 url_list
= [self
.url
, '/api/org/', org_uuid
]
3196 vm_list_rest_call
= ''.join(url_list
)
3198 if self
.client
._session
:
3199 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3200 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3202 #response = requests.get(vm_list_rest_call, headers=headers, verify=False)
3203 response
= self
.perform_request(req_type
='GET',
3204 url
=vm_list_rest_call
,
3206 if response
.status_code
== 403:
3207 response
= self
.retry_rest('GET', vm_list_rest_call
)
3209 if response
.status_code
== requests
.codes
.ok
:
3210 return response
.content
3213 def get_org(self
, org_uuid
=None):
3215 Method retrieves available organization in vCloud Director
3218 org_uuid - is a organization uuid.
3221 The return dictionary with following key
3222 "network" - for network list under the org
3223 "catalogs" - for network list under the org
3224 "vdcs" - for vdc list under org
3229 if org_uuid
is None:
3232 content
= self
.get_org_action(org_uuid
=org_uuid
)
3237 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3238 for child
in vm_list_xmlroot
:
3239 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.vdc+xml':
3240 vdc_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
3241 org_dict
['vdcs'] = vdc_list
3242 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.orgNetwork+xml':
3243 network_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
3244 org_dict
['networks'] = network_list
3245 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
3246 catalog_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
3247 org_dict
['catalogs'] = catalog_list
3253 def get_org_list(self
):
3255 Method retrieves available organization in vCloud Director
3258 vca - is active VCA connection.
3261 The return dictionary and key for each entry VDC UUID
3266 content
= self
.list_org_action()
3268 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3269 for vm_xml
in vm_list_xmlroot
:
3270 if vm_xml
.tag
.split("}")[1] == 'Org':
3271 org_uuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3272 org_dict
[org_uuid
[0]] = vm_xml
.attrib
['name']
3278 def vms_view_action(self
, vdc_name
=None):
3279 """ Method leverages vCloud director vms query call
3282 vca - is active VCA connection.
3283 vdc_name - is a vdc name that will be used to query vms action
3286 The return XML respond
3288 vca
= self
.connect()
3289 if vdc_name
is None:
3292 url_list
= [vca
.host
, '/api/vms/query']
3293 vm_list_rest_call
= ''.join(url_list
)
3295 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
3296 refs
= filter(lambda ref
: ref
.name
== vdc_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vdc+xml',
3297 vca
.vcloud_session
.organization
.Link
)
3299 #refs = [ref for ref in vca.vcloud_session.organization.Link if ref.name == vdc_name and\
3300 # ref.type_ == 'application/vnd.vmware.vcloud.vdc+xml']
3302 response
= Http
.get(url
=vm_list_rest_call
,
3303 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3306 if response
.status_code
== requests
.codes
.ok
:
3307 return response
.content
3311 def get_vapp_list(self
, vdc_name
=None):
3313 Method retrieves vApp list deployed vCloud director and returns a dictionary
3314 contains a list of all vapp deployed for queried VDC.
3315 The key for a dictionary is vApp UUID
3319 vca - is active VCA connection.
3320 vdc_name - is a vdc name that will be used to query vms action
3323 The return dictionary and key for each entry vapp UUID
3327 if vdc_name
is None:
3330 content
= self
.vms_view_action(vdc_name
=vdc_name
)
3332 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3333 for vm_xml
in vm_list_xmlroot
:
3334 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
3335 if vm_xml
.attrib
['isVAppTemplate'] == 'true':
3336 rawuuid
= vm_xml
.attrib
['container'].split('/')[-1:]
3337 if 'vappTemplate-' in rawuuid
[0]:
3338 # vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
3339 # vm and use raw UUID as key
3340 vapp_dict
[rawuuid
[0][13:]] = vm_xml
.attrib
3346 def get_vm_list(self
, vdc_name
=None):
3348 Method retrieves VM's list deployed vCloud director. It returns a dictionary
3349 contains a list of all VM's deployed for queried VDC.
3350 The key for a dictionary is VM UUID
3354 vca - is active VCA connection.
3355 vdc_name - is a vdc name that will be used to query vms action
3358 The return dictionary and key for each entry vapp UUID
3362 if vdc_name
is None:
3365 content
= self
.vms_view_action(vdc_name
=vdc_name
)
3367 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3368 for vm_xml
in vm_list_xmlroot
:
3369 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
3370 if vm_xml
.attrib
['isVAppTemplate'] == 'false':
3371 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3372 if 'vm-' in rawuuid
[0]:
3373 # vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
3374 # vm and use raw UUID as key
3375 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
3381 def get_vapp(self
, vdc_name
=None, vapp_name
=None, isuuid
=False):
3383 Method retrieves VM deployed vCloud director. It returns VM attribute as dictionary
3384 contains a list of all VM's deployed for queried VDC.
3385 The key for a dictionary is VM UUID
3389 vca - is active VCA connection.
3390 vdc_name - is a vdc name that will be used to query vms action
3393 The return dictionary and key for each entry vapp UUID
3396 vca
= self
.connect()
3398 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3400 if vdc_name
is None:
3403 content
= self
.vms_view_action(vdc_name
=vdc_name
)
3405 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3406 for vm_xml
in vm_list_xmlroot
:
3407 if vm_xml
.tag
.split("}")[1] == 'VMRecord' and vm_xml
.attrib
['isVAppTemplate'] == 'false':
3408 # lookup done by UUID
3410 if vapp_name
in vm_xml
.attrib
['container']:
3411 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3412 if 'vm-' in rawuuid
[0]:
3413 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
3415 # lookup done by Name
3417 if vapp_name
in vm_xml
.attrib
['name']:
3418 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3419 if 'vm-' in rawuuid
[0]:
3420 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
3427 def get_network_action(self
, network_uuid
=None):
3429 Method leverages vCloud director and query network based on network uuid
3432 vca - is active VCA connection.
3433 network_uuid - is a network uuid
3436 The return XML respond
3439 if network_uuid
is None:
3442 url_list
= [self
.url
, '/api/network/', network_uuid
]
3443 vm_list_rest_call
= ''.join(url_list
)
3445 if self
.client
._session
:
3446 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3447 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3449 response
= self
.perform_request(req_type
='GET',
3450 url
=vm_list_rest_call
,
3452 #Retry login if session expired & retry sending request
3453 if response
.status_code
== 403:
3454 response
= self
.retry_rest('GET', vm_list_rest_call
)
3456 if response
.status_code
== requests
.codes
.ok
:
3457 return response
.content
3461 def get_vcd_network(self
, network_uuid
=None):
3463 Method retrieves available network from vCloud Director
3466 network_uuid - is VCD network UUID
3468 Each element serialized as key : value pair
3470 Following keys available for access. network_configuration['Gateway'}
3474 <IsInherited>true</IsInherited>
3475 <Gateway>172.16.252.100</Gateway>
3476 <Netmask>255.255.255.0</Netmask>
3477 <Dns1>172.16.254.201</Dns1>
3478 <Dns2>172.16.254.202</Dns2>
3479 <DnsSuffix>vmwarelab.edu</DnsSuffix>
3480 <IsEnabled>true</IsEnabled>
3483 <StartAddress>172.16.252.1</StartAddress>
3484 <EndAddress>172.16.252.99</EndAddress>
3489 <FenceMode>bridged</FenceMode>
3492 The return dictionary and key for each entry vapp UUID
3495 network_configuration
= {}
3496 if network_uuid
is None:
3500 content
= self
.get_network_action(network_uuid
=network_uuid
)
3501 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3503 network_configuration
['status'] = vm_list_xmlroot
.get("status")
3504 network_configuration
['name'] = vm_list_xmlroot
.get("name")
3505 network_configuration
['uuid'] = vm_list_xmlroot
.get("id").split(":")[3]
3507 for child
in vm_list_xmlroot
:
3508 if child
.tag
.split("}")[1] == 'IsShared':
3509 network_configuration
['isShared'] = child
.text
.strip()
3510 if child
.tag
.split("}")[1] == 'Configuration':
3511 for configuration
in child
.iter():
3512 tagKey
= configuration
.tag
.split("}")[1].strip()
3514 network_configuration
[tagKey
] = configuration
.text
.strip()
3515 return network_configuration
3516 except Exception as exp
:
3517 self
.logger
.debug("get_vcd_network: Failed with Exception {}".format(exp
))
3518 raise vimconn
.vimconnException("get_vcd_network: Failed with Exception {}".format(exp
))
3520 return network_configuration
3522 def delete_network_action(self
, network_uuid
=None):
3524 Method delete given network from vCloud director
3527 network_uuid - is a network uuid that client wish to delete
3530 The return None or XML respond or false
3532 client
= self
.connect_as_admin()
3534 raise vimconn
.vimconnConnectionException("Failed to connect vCD as admin")
3535 if network_uuid
is None:
3538 url_list
= [self
.url
, '/api/admin/network/', network_uuid
]
3539 vm_list_rest_call
= ''.join(url_list
)
3542 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3543 'x-vcloud-authorization': client
._session
.headers
['x-vcloud-authorization']}
3544 response
= self
.perform_request(req_type
='DELETE',
3545 url
=vm_list_rest_call
,
3547 if response
.status_code
== 202:
3552 def create_network(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
3553 ip_profile
=None, isshared
='true'):
3555 Method create network in vCloud director
3558 network_name - is network name to be created.
3559 net_type - can be 'bridge','data','ptp','mgmt'.
3560 ip_profile is a dict containing the IP parameters of the network
3561 isshared - is a boolean
3562 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3563 It optional attribute. by default if no parent network indicate the first available will be used.
3566 The return network uuid or return None
3569 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
3570 content
= self
.create_network_rest(network_name
=''.join(new_network_name
),
3571 ip_profile
=ip_profile
,
3573 parent_network_uuid
=parent_network_uuid
,
3576 self
.logger
.debug("Failed create network {}.".format(network_name
))
3580 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3581 vcd_uuid
= vm_list_xmlroot
.get('id').split(":")
3582 if len(vcd_uuid
) == 4:
3583 self
.logger
.info("Created new network name: {} uuid: {}".format(network_name
, vcd_uuid
[3]))
3586 self
.logger
.debug("Failed create network {}".format(network_name
))
3589 def create_network_rest(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
3590 ip_profile
=None, isshared
='true'):
3592 Method create network in vCloud director
3595 network_name - is network name to be created.
3596 net_type - can be 'bridge','data','ptp','mgmt'.
3597 ip_profile is a dict containing the IP parameters of the network
3598 isshared - is a boolean
3599 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3600 It optional attribute. by default if no parent network indicate the first available will be used.
3603 The return network uuid or return None
3605 client_as_admin
= self
.connect_as_admin()
3606 if not client_as_admin
:
3607 raise vimconn
.vimconnConnectionException("Failed to connect vCD.")
3608 if network_name
is None:
3611 url_list
= [self
.url
, '/api/admin/vdc/', self
.tenant_id
]
3612 vm_list_rest_call
= ''.join(url_list
)
3614 if client_as_admin
._session
:
3615 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3616 'x-vcloud-authorization': client_as_admin
._session
.headers
['x-vcloud-authorization']}
3618 response
= self
.perform_request(req_type
='GET',
3619 url
=vm_list_rest_call
,
3622 provider_network
= None
3623 available_networks
= None
3624 add_vdc_rest_url
= None
3626 if response
.status_code
!= requests
.codes
.ok
:
3627 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3628 response
.status_code
))
3632 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3633 for child
in vm_list_xmlroot
:
3634 if child
.tag
.split("}")[1] == 'ProviderVdcReference':
3635 provider_network
= child
.attrib
.get('href')
3636 # application/vnd.vmware.admin.providervdc+xml
3637 if child
.tag
.split("}")[1] == 'Link':
3638 if child
.attrib
.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
3639 and child
.attrib
.get('rel') == 'add':
3640 add_vdc_rest_url
= child
.attrib
.get('href')
3642 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3643 self
.logger
.debug("Respond body {}".format(response
.content
))
3646 # find pvdc provided available network
3647 response
= self
.perform_request(req_type
='GET',
3648 url
=provider_network
,
3650 if response
.status_code
!= requests
.codes
.ok
:
3651 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3652 response
.status_code
))
3655 if parent_network_uuid
is None:
3657 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3658 for child
in vm_list_xmlroot
.iter():
3659 if child
.tag
.split("}")[1] == 'AvailableNetworks':
3660 for networks
in child
.iter():
3661 # application/vnd.vmware.admin.network+xml
3662 if networks
.attrib
.get('href') is not None:
3663 available_networks
= networks
.attrib
.get('href')
3669 #Configure IP profile of the network
3670 ip_profile
= ip_profile
if ip_profile
is not None else DEFAULT_IP_PROFILE
3672 if 'subnet_address' not in ip_profile
or ip_profile
['subnet_address'] is None:
3673 subnet_rand
= random
.randint(0, 255)
3674 ip_base
= "192.168.{}.".format(subnet_rand
)
3675 ip_profile
['subnet_address'] = ip_base
+ "0/24"
3677 ip_base
= ip_profile
['subnet_address'].rsplit('.',1)[0] + '.'
3679 if 'gateway_address' not in ip_profile
or ip_profile
['gateway_address'] is None:
3680 ip_profile
['gateway_address']=ip_base
+ "1"
3681 if 'dhcp_count' not in ip_profile
or ip_profile
['dhcp_count'] is None:
3682 ip_profile
['dhcp_count']=DEFAULT_IP_PROFILE
['dhcp_count']
3683 if 'dhcp_enabled' not in ip_profile
or ip_profile
['dhcp_enabled'] is None:
3684 ip_profile
['dhcp_enabled']=DEFAULT_IP_PROFILE
['dhcp_enabled']
3685 if 'dhcp_start_address' not in ip_profile
or ip_profile
['dhcp_start_address'] is None:
3686 ip_profile
['dhcp_start_address']=ip_base
+ "3"
3687 if 'ip_version' not in ip_profile
or ip_profile
['ip_version'] is None:
3688 ip_profile
['ip_version']=DEFAULT_IP_PROFILE
['ip_version']
3689 if 'dns_address' not in ip_profile
or ip_profile
['dns_address'] is None:
3690 ip_profile
['dns_address']=ip_base
+ "2"
3692 gateway_address
=ip_profile
['gateway_address']
3693 dhcp_count
=int(ip_profile
['dhcp_count'])
3694 subnet_address
=self
.convert_cidr_to_netmask(ip_profile
['subnet_address'])
3696 if ip_profile
['dhcp_enabled']==True:
3699 dhcp_enabled
='false'
3700 dhcp_start_address
=ip_profile
['dhcp_start_address']
3702 #derive dhcp_end_address from dhcp_start_address & dhcp_count
3703 end_ip_int
= int(netaddr
.IPAddress(dhcp_start_address
))
3704 end_ip_int
+= dhcp_count
- 1
3705 dhcp_end_address
= str(netaddr
.IPAddress(end_ip_int
))
3707 ip_version
=ip_profile
['ip_version']
3708 dns_address
=ip_profile
['dns_address']
3709 except KeyError as exp
:
3710 self
.logger
.debug("Create Network REST: Key error {}".format(exp
))
3711 raise vimconn
.vimconnException("Create Network REST: Key error{}".format(exp
))
3713 # either use client provided UUID or search for a first available
3714 # if both are not defined we return none
3715 if parent_network_uuid
is not None:
3716 url_list
= [self
.url
, '/api/admin/network/', parent_network_uuid
]
3717 add_vdc_rest_url
= ''.join(url_list
)
3719 #Creating all networks as Direct Org VDC type networks.
3720 #Unused in case of Underlay (data/ptp) network interface.
3721 fence_mode
="bridged"
3722 is_inherited
='false'
3723 dns_list
= dns_address
.split(";")
3726 if len(dns_list
) >= 2:
3727 dns2_text
= "\n <Dns2>{}</Dns2>\n".format(dns_list
[1])
3728 data
= """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
3729 <Description>Openmano created</Description>
3733 <IsInherited>{1:s}</IsInherited>
3734 <Gateway>{2:s}</Gateway>
3735 <Netmask>{3:s}</Netmask>
3736 <Dns1>{4:s}</Dns1>{5:s}
3737 <IsEnabled>{6:s}</IsEnabled>
3740 <StartAddress>{7:s}</StartAddress>
3741 <EndAddress>{8:s}</EndAddress>
3746 <ParentNetwork href="{9:s}"/>
3747 <FenceMode>{10:s}</FenceMode>
3749 <IsShared>{11:s}</IsShared>
3750 </OrgVdcNetwork> """.format(escape(network_name
), is_inherited
, gateway_address
,
3751 subnet_address
, dns1
, dns2_text
, dhcp_enabled
,
3752 dhcp_start_address
, dhcp_end_address
, available_networks
,
3753 fence_mode
, isshared
)
3755 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
3757 response
= self
.perform_request(req_type
='POST',
3758 url
=add_vdc_rest_url
,
3762 if response
.status_code
!= 201:
3763 self
.logger
.debug("Create Network POST REST API call failed. Return status code {}, Response content: {}"
3764 .format(response
.status_code
,response
.content
))
3766 network_task
= self
.get_task_from_response(response
.content
)
3767 self
.logger
.debug("Create Network REST : Waiting for Network creation complete")
3769 result
= self
.client
.get_task_monitor().wait_for_success(task
=network_task
)
3770 if result
.get('status') == 'success':
3771 return response
.content
3773 self
.logger
.debug("create_network_rest task failed. Network Create response : {}"
3774 .format(response
.content
))
3775 except Exception as exp
:
3776 self
.logger
.debug("create_network_rest : Exception : {} ".format(exp
))
3780 def convert_cidr_to_netmask(self
, cidr_ip
=None):
3782 Method sets convert CIDR netmask address to normal IP format
3784 cidr_ip : CIDR IP address
3786 netmask : Converted netmask
3788 if cidr_ip
is not None:
3790 network
, net_bits
= cidr_ip
.split('/')
3791 netmask
= socket
.inet_ntoa(struct
.pack(">I", (0xffffffff << (32 - int(net_bits
))) & 0xffffffff))
3797 def get_provider_rest(self
, vca
=None):
3799 Method gets provider vdc view from vcloud director
3802 network_name - is network name to be created.
3803 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3804 It optional attribute. by default if no parent network indicate the first available will be used.
3807 The return xml content of respond or None
3810 url_list
= [self
.url
, '/api/admin']
3812 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3813 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3814 response
= self
.perform_request(req_type
='GET',
3815 url
=''.join(url_list
),
3818 if response
.status_code
== requests
.codes
.ok
:
3819 return response
.content
3822 def create_vdc(self
, vdc_name
=None):
3826 xml_content
= self
.create_vdc_from_tmpl_rest(vdc_name
=vdc_name
)
3827 if xml_content
is not None:
3829 task_resp_xmlroot
= XmlElementTree
.fromstring(xml_content
)
3830 for child
in task_resp_xmlroot
:
3831 if child
.tag
.split("}")[1] == 'Owner':
3832 vdc_id
= child
.attrib
.get('href').split("/")[-1]
3833 vdc_dict
[vdc_id
] = task_resp_xmlroot
.get('href')
3836 self
.logger
.debug("Respond body {}".format(xml_content
))
3840 def create_vdc_from_tmpl_rest(self
, vdc_name
=None):
3842 Method create vdc in vCloud director based on VDC template.
3843 it uses pre-defined template.
3846 vdc_name - name of a new vdc.
3849 The return xml content of respond or None
3851 # pre-requesite atleast one vdc template should be available in vCD
3852 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
3853 vca
= self
.connect_as_admin()
3855 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
3856 if vdc_name
is None:
3859 url_list
= [self
.url
, '/api/vdcTemplates']
3860 vm_list_rest_call
= ''.join(url_list
)
3862 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3863 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
3864 response
= self
.perform_request(req_type
='GET',
3865 url
=vm_list_rest_call
,
3868 # container url to a template
3869 vdc_template_ref
= None
3871 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3872 for child
in vm_list_xmlroot
:
3873 # application/vnd.vmware.admin.providervdc+xml
3874 # we need find a template from witch we instantiate VDC
3875 if child
.tag
.split("}")[1] == 'VdcTemplate':
3876 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml':
3877 vdc_template_ref
= child
.attrib
.get('href')
3879 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3880 self
.logger
.debug("Respond body {}".format(response
.content
))
3883 # if we didn't found required pre defined template we return None
3884 if vdc_template_ref
is None:
3889 url_list
= [self
.url
, '/api/org/', self
.org_uuid
, '/action/instantiate']
3890 vm_list_rest_call
= ''.join(url_list
)
3891 data
= """<InstantiateVdcTemplateParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
3892 <Source href="{1:s}"></Source>
3893 <Description>opnemano</Description>
3894 </InstantiateVdcTemplateParams>""".format(vdc_name
, vdc_template_ref
)
3896 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVdcTemplateParams+xml'
3898 response
= self
.perform_request(req_type
='POST',
3899 url
=vm_list_rest_call
,
3903 vdc_task
= self
.get_task_from_response(response
.content
)
3904 self
.client
.get_task_monitor().wait_for_success(task
=vdc_task
)
3906 # if we all ok we respond with content otherwise by default None
3907 if response
.status_code
>= 200 and response
.status_code
< 300:
3908 return response
.content
3911 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3912 self
.logger
.debug("Respond body {}".format(response
.content
))
3916 def create_vdc_rest(self
, vdc_name
=None):
3918 Method create network in vCloud director
3921 vdc_name - vdc name to be created
3926 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
3928 vca
= self
.connect_as_admin()
3930 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
3931 if vdc_name
is None:
3934 url_list
= [self
.url
, '/api/admin/org/', self
.org_uuid
]
3935 vm_list_rest_call
= ''.join(url_list
)
3938 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3939 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3940 response
= self
.perform_request(req_type
='GET',
3941 url
=vm_list_rest_call
,
3944 provider_vdc_ref
= None
3945 add_vdc_rest_url
= None
3946 available_networks
= None
3948 if response
.status_code
!= requests
.codes
.ok
:
3949 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3950 response
.status_code
))
3954 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3955 for child
in vm_list_xmlroot
:
3956 # application/vnd.vmware.admin.providervdc+xml
3957 if child
.tag
.split("}")[1] == 'Link':
3958 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
3959 and child
.attrib
.get('rel') == 'add':
3960 add_vdc_rest_url
= child
.attrib
.get('href')
3962 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3963 self
.logger
.debug("Respond body {}".format(response
.content
))
3966 response
= self
.get_provider_rest(vca
=vca
)
3968 vm_list_xmlroot
= XmlElementTree
.fromstring(response
)
3969 for child
in vm_list_xmlroot
:
3970 if child
.tag
.split("}")[1] == 'ProviderVdcReferences':
3971 for sub_child
in child
:
3972 provider_vdc_ref
= sub_child
.attrib
.get('href')
3974 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3975 self
.logger
.debug("Respond body {}".format(response
))
3978 if add_vdc_rest_url
is not None and provider_vdc_ref
is not None:
3979 data
= """ <CreateVdcParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5"><Description>{1:s}</Description>
3980 <AllocationModel>ReservationPool</AllocationModel>
3981 <ComputeCapacity><Cpu><Units>MHz</Units><Allocated>2048</Allocated><Limit>2048</Limit></Cpu>
3982 <Memory><Units>MB</Units><Allocated>2048</Allocated><Limit>2048</Limit></Memory>
3983 </ComputeCapacity><NicQuota>0</NicQuota><NetworkQuota>100</NetworkQuota>
3984 <VdcStorageProfile><Enabled>true</Enabled><Units>MB</Units><Limit>20480</Limit><Default>true</Default></VdcStorageProfile>
3985 <ProviderVdcReference
3986 name="Main Provider"
3988 <UsesFastProvisioning>true</UsesFastProvisioning></CreateVdcParams>""".format(escape(vdc_name
),
3992 headers
['Content-Type'] = 'application/vnd.vmware.admin.createVdcParams+xml'
3994 response
= self
.perform_request(req_type
='POST',
3995 url
=add_vdc_rest_url
,
3999 # if we all ok we respond with content otherwise by default None
4000 if response
.status_code
== 201:
4001 return response
.content
4004 def get_vapp_details_rest(self
, vapp_uuid
=None, need_admin_access
=False):
4006 Method retrieve vapp detail from vCloud director
4009 vapp_uuid - is vapp identifier.
4012 The return network uuid or return None
4018 if need_admin_access
:
4019 vca
= self
.connect_as_admin()
4024 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
4025 if vapp_uuid
is None:
4028 url_list
= [self
.url
, '/api/vApp/vapp-', vapp_uuid
]
4029 get_vapp_restcall
= ''.join(url_list
)
4032 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4033 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
4034 response
= self
.perform_request(req_type
='GET',
4035 url
=get_vapp_restcall
,
4038 if response
.status_code
== 403:
4039 if need_admin_access
== False:
4040 response
= self
.retry_rest('GET', get_vapp_restcall
)
4042 if response
.status_code
!= requests
.codes
.ok
:
4043 self
.logger
.debug("REST API call {} failed. Return status code {}".format(get_vapp_restcall
,
4044 response
.status_code
))
4045 return parsed_respond
4048 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
4049 parsed_respond
['ovfDescriptorUploaded'] = xmlroot_respond
.attrib
['ovfDescriptorUploaded']
4051 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
4052 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
4053 'vmw': 'http://www.vmware.com/schema/ovf',
4054 'vm': 'http://www.vmware.com/vcloud/v1.5',
4055 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
4056 "vmext":"http://www.vmware.com/vcloud/extension/v1.5",
4057 "xmlns":"http://www.vmware.com/vcloud/v1.5"
4060 created_section
= xmlroot_respond
.find('vm:DateCreated', namespaces
)
4061 if created_section
is not None:
4062 parsed_respond
['created'] = created_section
.text
4064 network_section
= xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig', namespaces
)
4065 if network_section
is not None and 'networkName' in network_section
.attrib
:
4066 parsed_respond
['networkname'] = network_section
.attrib
['networkName']
4068 ipscopes_section
= \
4069 xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig/vm:Configuration/vm:IpScopes',
4071 if ipscopes_section
is not None:
4072 for ipscope
in ipscopes_section
:
4073 for scope
in ipscope
:
4074 tag_key
= scope
.tag
.split("}")[1]
4075 if tag_key
== 'IpRanges':
4076 ip_ranges
= scope
.getchildren()
4077 for ipblock
in ip_ranges
:
4078 for block
in ipblock
:
4079 parsed_respond
[block
.tag
.split("}")[1]] = block
.text
4081 parsed_respond
[tag_key
] = scope
.text
4083 # parse children section for other attrib
4084 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
4085 if children_section
is not None:
4086 parsed_respond
['name'] = children_section
.attrib
['name']
4087 parsed_respond
['nestedHypervisorEnabled'] = children_section
.attrib
['nestedHypervisorEnabled'] \
4088 if "nestedHypervisorEnabled" in children_section
.attrib
else None
4089 parsed_respond
['deployed'] = children_section
.attrib
['deployed']
4090 parsed_respond
['status'] = children_section
.attrib
['status']
4091 parsed_respond
['vmuuid'] = children_section
.attrib
['id'].split(":")[-1]
4092 network_adapter
= children_section
.find('vm:NetworkConnectionSection', namespaces
)
4094 for adapters
in network_adapter
:
4095 adapter_key
= adapters
.tag
.split("}")[1]
4096 if adapter_key
== 'PrimaryNetworkConnectionIndex':
4097 parsed_respond
['primarynetwork'] = adapters
.text
4098 if adapter_key
== 'NetworkConnection':
4100 if 'network' in adapters
.attrib
:
4101 vnic
['network'] = adapters
.attrib
['network']
4102 for adapter
in adapters
:
4103 setting_key
= adapter
.tag
.split("}")[1]
4104 vnic
[setting_key
] = adapter
.text
4105 nic_list
.append(vnic
)
4107 for link
in children_section
:
4108 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
4109 if link
.attrib
['rel'] == 'screen:acquireTicket':
4110 parsed_respond
['acquireTicket'] = link
.attrib
4111 if link
.attrib
['rel'] == 'screen:acquireMksTicket':
4112 parsed_respond
['acquireMksTicket'] = link
.attrib
4114 parsed_respond
['interfaces'] = nic_list
4115 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
4116 if vCloud_extension_section
is not None:
4117 vm_vcenter_info
= {}
4118 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
4119 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
4120 if vmext
is not None:
4121 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
4122 parsed_respond
["vm_vcenter_info"]= vm_vcenter_info
4124 virtual_hardware_section
= children_section
.find('ovf:VirtualHardwareSection', namespaces
)
4125 vm_virtual_hardware_info
= {}
4126 if virtual_hardware_section
is not None:
4127 for item
in virtual_hardware_section
.iterfind('ovf:Item',namespaces
):
4128 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
4129 disk_size
= item
.find("rasd:HostResource" ,namespaces
4130 ).attrib
["{"+namespaces
['vm']+"}capacity"]
4132 vm_virtual_hardware_info
["disk_size"]= disk_size
4135 for link
in virtual_hardware_section
:
4136 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
4137 if link
.attrib
['rel'] == 'edit' and link
.attrib
['href'].endswith("/disks"):
4138 vm_virtual_hardware_info
["disk_edit_href"] = link
.attrib
['href']
4141 parsed_respond
["vm_virtual_hardware"]= vm_virtual_hardware_info
4142 except Exception as exp
:
4143 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
4144 return parsed_respond
4146 def acquire_console(self
, vm_uuid
=None):
4150 if self
.client
._session
:
4151 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4152 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4153 vm_dict
= self
.get_vapp_details_rest(vapp_uuid
=vm_uuid
)
4154 console_dict
= vm_dict
['acquireTicket']
4155 console_rest_call
= console_dict
['href']
4157 response
= self
.perform_request(req_type
='POST',
4158 url
=console_rest_call
,
4161 if response
.status_code
== 403:
4162 response
= self
.retry_rest('POST', console_rest_call
)
4164 if response
.status_code
== requests
.codes
.ok
:
4165 return response
.content
4169 def modify_vm_disk(self
, vapp_uuid
, flavor_disk
):
4171 Method retrieve vm disk details
4174 vapp_uuid - is vapp identifier.
4175 flavor_disk - disk size as specified in VNFD (flavor)
4178 The return network uuid or return None
4182 #Flavor disk is in GB convert it into MB
4183 flavor_disk
= int(flavor_disk
) * 1024
4184 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
4186 vm_name
= vm_details
["name"]
4187 self
.logger
.info("VM: {} flavor_disk :{}".format(vm_name
, flavor_disk
))
4189 if vm_details
and "vm_virtual_hardware" in vm_details
:
4190 vm_disk
= int(vm_details
["vm_virtual_hardware"]["disk_size"])
4191 disk_edit_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
4193 self
.logger
.info("VM: {} VM_disk :{}".format(vm_name
, vm_disk
))
4195 if flavor_disk
> vm_disk
:
4196 status
= self
.modify_vm_disk_rest(disk_edit_href
,flavor_disk
)
4197 self
.logger
.info("Modify disk of VM {} from {} to {} MB".format(vm_name
,
4198 vm_disk
, flavor_disk
))
4201 self
.logger
.info("No need to modify disk of VM {}".format(vm_name
))
4204 except Exception as exp
:
4205 self
.logger
.info("Error occurred while modifing disk size {}".format(exp
))
4208 def modify_vm_disk_rest(self
, disk_href
, disk_size
):
4210 Method retrieve modify vm disk size
4213 disk_href - vCD API URL to GET and PUT disk data
4214 disk_size - disk size as specified in VNFD (flavor)
4217 The return network uuid or return None
4219 if disk_href
is None or disk_size
is None:
4222 if self
.client
._session
:
4223 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4224 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4225 response
= self
.perform_request(req_type
='GET',
4229 if response
.status_code
== 403:
4230 response
= self
.retry_rest('GET', disk_href
)
4232 if response
.status_code
!= requests
.codes
.ok
:
4233 self
.logger
.debug("GET REST API call {} failed. Return status code {}".format(disk_href
,
4234 response
.status_code
))
4237 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
4238 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
4240 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
4241 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
4243 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
4244 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
4245 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
4246 if disk_item
is not None:
4247 disk_item
.attrib
["{"+namespaces
['xmlns']+"}capacity"] = str(disk_size
)
4250 data
= lxmlElementTree
.tostring(lxmlroot_respond
, encoding
='utf8', method
='xml',
4251 xml_declaration
=True)
4253 #Send PUT request to modify disk size
4254 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
4256 response
= self
.perform_request(req_type
='PUT',
4260 if response
.status_code
== 403:
4261 add_headers
= {'Content-Type': headers
['Content-Type']}
4262 response
= self
.retry_rest('PUT', disk_href
, add_headers
, data
)
4264 if response
.status_code
!= 202:
4265 self
.logger
.debug("PUT REST API call {} failed. Return status code {}".format(disk_href
,
4266 response
.status_code
))
4268 modify_disk_task
= self
.get_task_from_response(response
.content
)
4269 result
= self
.client
.get_task_monitor().wait_for_success(task
=modify_disk_task
)
4270 if result
.get('status') == 'success':
4276 except Exception as exp
:
4277 self
.logger
.info("Error occurred calling rest api for modifing disk size {}".format(exp
))
4280 def add_pci_devices(self
, vapp_uuid
, pci_devices
, vmname_andid
):
4282 Method to attach pci devices to VM
4285 vapp_uuid - uuid of vApp/VM
4286 pci_devices - pci devices infromation as specified in VNFD (flavor)
4289 The status of add pci device task , vm object and
4290 vcenter_conect object
4293 self
.logger
.info("Add pci devices {} into vApp {}".format(pci_devices
, vapp_uuid
))
4294 vcenter_conect
, content
= self
.get_vcenter_content()
4295 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
4299 no_of_pci_devices
= len(pci_devices
)
4300 if no_of_pci_devices
> 0:
4301 #Get VM and its host
4302 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4303 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
4304 if host_obj
and vm_obj
:
4305 #get PCI devies from host on which vapp is currently installed
4306 avilable_pci_devices
= self
.get_pci_devices(host_obj
, no_of_pci_devices
)
4308 if avilable_pci_devices
is None:
4309 #find other hosts with active pci devices
4310 new_host_obj
, avilable_pci_devices
= self
.get_host_and_PCIdevices(
4315 if new_host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
4316 #Migrate vm to the host where PCI devices are availble
4317 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
, new_host_obj
))
4318 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
4319 if task
is not None:
4320 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4321 self
.logger
.info("Migrate VM status: {}".format(result
))
4322 host_obj
= new_host_obj
4324 self
.logger
.info("Fail to migrate VM : {}".format(result
))
4325 raise vimconn
.vimconnNotFoundException(
4326 "Fail to migrate VM : {} to host {}".format(
4331 if host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
4332 #Add PCI devices one by one
4333 for pci_device
in avilable_pci_devices
:
4334 task
= self
.add_pci_to_vm(host_obj
, vm_obj
, pci_device
)
4336 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4338 self
.logger
.info("Added PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
4340 self
.logger
.error("Fail to add PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
4341 return True, vm_obj
, vcenter_conect
4343 self
.logger
.error("Currently there is no host with"\
4344 " {} number of avaialble PCI devices required for VM {}".format(
4348 raise vimconn
.vimconnNotFoundException(
4349 "Currently there is no host with {} "\
4350 "number of avaialble PCI devices required for VM {}".format(
4354 self
.logger
.debug("No infromation about PCI devices {} ",pci_devices
)
4356 except vmodl
.MethodFault
as error
:
4357 self
.logger
.error("Error occurred while adding PCI devices {} ",error
)
4358 return None, vm_obj
, vcenter_conect
4360 def get_vm_obj(self
, content
, mob_id
):
4362 Method to get the vsphere VM object associated with a given morf ID
4364 vapp_uuid - uuid of vApp/VM
4365 content - vCenter content object
4366 mob_id - mob_id of VM
4374 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
4375 [vim
.VirtualMachine
], True
4377 for vm
in container
.view
:
4378 mobID
= vm
._GetMoId
()
4381 host_obj
= vm_obj
.runtime
.host
4383 except Exception as exp
:
4384 self
.logger
.error("Error occurred while finding VM object : {}".format(exp
))
4385 return host_obj
, vm_obj
4387 def get_pci_devices(self
, host
, need_devices
):
4389 Method to get the details of pci devices on given host
4391 host - vSphere host object
4392 need_devices - number of pci devices needed on host
4395 array of pci devices
4399 used_devices_ids
= []
4403 pciPassthruInfo
= host
.config
.pciPassthruInfo
4404 pciDevies
= host
.hardware
.pciDevice
4406 for pci_status
in pciPassthruInfo
:
4407 if pci_status
.passthruActive
:
4408 for device
in pciDevies
:
4409 if device
.id == pci_status
.id:
4410 all_device_ids
.append(device
.id)
4411 all_devices
.append(device
)
4413 #check if devices are in use
4414 avalible_devices
= all_devices
4416 if vm
.runtime
.powerState
== vim
.VirtualMachinePowerState
.poweredOn
:
4417 vm_devices
= vm
.config
.hardware
.device
4418 for device
in vm_devices
:
4419 if type(device
) is vim
.vm
.device
.VirtualPCIPassthrough
:
4420 if device
.backing
.id in all_device_ids
:
4421 for use_device
in avalible_devices
:
4422 if use_device
.id == device
.backing
.id:
4423 avalible_devices
.remove(use_device
)
4424 used_devices_ids
.append(device
.backing
.id)
4425 self
.logger
.debug("Device {} from devices {}"\
4426 "is in use".format(device
.backing
.id,
4429 if len(avalible_devices
) < need_devices
:
4430 self
.logger
.debug("Host {} don't have {} number of active devices".format(host
,
4432 self
.logger
.debug("found only {} devives {}".format(len(avalible_devices
),
4436 required_devices
= avalible_devices
[:need_devices
]
4437 self
.logger
.info("Found {} PCI devivces on host {} but required only {}".format(
4438 len(avalible_devices
),
4441 self
.logger
.info("Retruning {} devices as {}".format(need_devices
,
4443 return required_devices
4445 except Exception as exp
:
4446 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host
))
4450 def get_host_and_PCIdevices(self
, content
, need_devices
):
4452 Method to get the details of pci devices infromation on all hosts
4455 content - vSphere host object
4456 need_devices - number of pci devices needed on host
4459 array of pci devices and host object
4462 pci_device_objs
= None
4465 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
4466 [vim
.HostSystem
], True)
4467 for host
in container
.view
:
4468 devices
= self
.get_pci_devices(host
, need_devices
)
4471 pci_device_objs
= devices
4473 except Exception as exp
:
4474 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host_obj
))
4476 return host_obj
,pci_device_objs
4478 def relocate_vm(self
, dest_host
, vm
) :
4480 Method to get the relocate VM to new host
4483 dest_host - vSphere host object
4484 vm - vSphere VM object
4491 relocate_spec
= vim
.vm
.RelocateSpec(host
=dest_host
)
4492 task
= vm
.Relocate(relocate_spec
)
4493 self
.logger
.info("Migrating {} to destination host {}".format(vm
, dest_host
))
4494 except Exception as exp
:
4495 self
.logger
.error("Error occurred while relocate VM {} to new host {}: {}".format(
4496 dest_host
, vm
, exp
))
4499 def wait_for_vcenter_task(self
, task
, actionName
='job', hideResult
=False):
4501 Waits and provides updates on a vSphere task
4503 while task
.info
.state
== vim
.TaskInfo
.State
.running
:
4506 if task
.info
.state
== vim
.TaskInfo
.State
.success
:
4507 if task
.info
.result
is not None and not hideResult
:
4508 self
.logger
.info('{} completed successfully, result: {}'.format(
4512 self
.logger
.info('Task {} completed successfully.'.format(actionName
))
4514 self
.logger
.error('{} did not complete successfully: {} '.format(
4519 return task
.info
.result
4521 def add_pci_to_vm(self
,host_object
, vm_object
, host_pci_dev
):
4523 Method to add pci device in given VM
4526 host_object - vSphere host object
4527 vm_object - vSphere VM object
4528 host_pci_dev - host_pci_dev must be one of the devices from the
4529 host_object.hardware.pciDevice list
4530 which is configured as a PCI passthrough device
4536 if vm_object
and host_object
and host_pci_dev
:
4538 #Add PCI device to VM
4539 pci_passthroughs
= vm_object
.environmentBrowser
.QueryConfigTarget(host
=None).pciPassthrough
4540 systemid_by_pciid
= {item
.pciDevice
.id: item
.systemId
for item
in pci_passthroughs
}
4542 if host_pci_dev
.id not in systemid_by_pciid
:
4543 self
.logger
.error("Device {} is not a passthrough device ".format(host_pci_dev
))
4546 deviceId
= hex(host_pci_dev
.deviceId
% 2**16).lstrip('0x')
4547 backing
= vim
.VirtualPCIPassthroughDeviceBackingInfo(deviceId
=deviceId
,
4549 systemId
=systemid_by_pciid
[host_pci_dev
.id],
4550 vendorId
=host_pci_dev
.vendorId
,
4551 deviceName
=host_pci_dev
.deviceName
)
4553 hba_object
= vim
.VirtualPCIPassthrough(key
=-100, backing
=backing
)
4555 new_device_config
= vim
.VirtualDeviceConfigSpec(device
=hba_object
)
4556 new_device_config
.operation
= "add"
4557 vmConfigSpec
= vim
.vm
.ConfigSpec()
4558 vmConfigSpec
.deviceChange
= [new_device_config
]
4560 task
= vm_object
.ReconfigVM_Task(spec
=vmConfigSpec
)
4561 self
.logger
.info("Adding PCI device {} into VM {} from host {} ".format(
4562 host_pci_dev
, vm_object
, host_object
)
4564 except Exception as exp
:
4565 self
.logger
.error("Error occurred while adding pci devive {} to VM {}: {}".format(
4571 def get_vm_vcenter_info(self
):
4573 Method to get details of vCenter and vm
4576 vapp_uuid - uuid of vApp or VM
4579 Moref Id of VM and deails of vCenter
4581 vm_vcenter_info
= {}
4583 if self
.vcenter_ip
is not None:
4584 vm_vcenter_info
["vm_vcenter_ip"] = self
.vcenter_ip
4586 raise vimconn
.vimconnException(message
="vCenter IP is not provided."\
4587 " Please provide vCenter IP while attaching datacenter to tenant in --config")
4588 if self
.vcenter_port
is not None:
4589 vm_vcenter_info
["vm_vcenter_port"] = self
.vcenter_port
4591 raise vimconn
.vimconnException(message
="vCenter port is not provided."\
4592 " Please provide vCenter port while attaching datacenter to tenant in --config")
4593 if self
.vcenter_user
is not None:
4594 vm_vcenter_info
["vm_vcenter_user"] = self
.vcenter_user
4596 raise vimconn
.vimconnException(message
="vCenter user is not provided."\
4597 " Please provide vCenter user while attaching datacenter to tenant in --config")
4599 if self
.vcenter_password
is not None:
4600 vm_vcenter_info
["vm_vcenter_password"] = self
.vcenter_password
4602 raise vimconn
.vimconnException(message
="vCenter user password is not provided."\
4603 " Please provide vCenter user password while attaching datacenter to tenant in --config")
4605 return vm_vcenter_info
4608 def get_vm_pci_details(self
, vmuuid
):
4610 Method to get VM PCI device details from vCenter
4613 vm_obj - vSphere VM object
4616 dict of PCI devives attached to VM
4619 vm_pci_devices_info
= {}
4621 vcenter_conect
, content
= self
.get_vcenter_content()
4622 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
4624 #Get VM and its host
4626 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4627 if host_obj
and vm_obj
:
4628 vm_pci_devices_info
["host_name"]= host_obj
.name
4629 vm_pci_devices_info
["host_ip"]= host_obj
.config
.network
.vnic
[0].spec
.ip
.ipAddress
4630 for device
in vm_obj
.config
.hardware
.device
:
4631 if type(device
) == vim
.vm
.device
.VirtualPCIPassthrough
:
4632 device_details
={'devide_id':device
.backing
.id,
4633 'pciSlotNumber':device
.slotInfo
.pciSlotNumber
,
4635 vm_pci_devices_info
[device
.deviceInfo
.label
] = device_details
4637 self
.logger
.error("Can not connect to vCenter while getting "\
4638 "PCI devices infromationn")
4639 return vm_pci_devices_info
4640 except Exception as exp
:
4641 self
.logger
.error("Error occurred while getting VM infromationn"\
4642 " for VM : {}".format(exp
))
4643 raise vimconn
.vimconnException(message
=exp
)
4646 def remove_primary_network_adapter_from_all_vms(self
, vapp
):
4648 Method to remove network adapter type to vm
4655 self
.logger
.info("Removing network adapter from all VMs")
4656 for vms
in vapp
.get_all_vms():
4657 vm_id
= vms
.get('id').split(':')[-1]
4659 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
4661 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4662 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4663 response
= self
.perform_request(req_type
='GET',
4667 if response
.status_code
== 403:
4668 response
= self
.retry_rest('GET', url_rest_call
)
4670 if response
.status_code
!= 200:
4671 self
.logger
.error("REST call {} failed reason : {}"\
4672 "status code : {}".format(url_rest_call
,
4674 response
.status_code
))
4675 raise vimconn
.vimconnException("remove_primary_network_adapter : Failed to get "\
4676 "network connection section")
4678 data
= response
.content
4679 data
= data
.split('<Link rel="edit"')[0]
4681 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
4683 newdata
= """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
4684 <NetworkConnectionSection xmlns="http://www.vmware.com/vcloud/v1.5"
4685 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
4686 xmlns:vssd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
4687 xmlns:common="http://schemas.dmtf.org/wbem/wscim/1/common"
4688 xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
4689 xmlns:vmw="http://www.vmware.com/schema/ovf"
4690 xmlns:ovfenv="http://schemas.dmtf.org/ovf/environment/1"
4691 xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5"
4692 xmlns:ns9="http://www.vmware.com/vcloud/versions"
4693 href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml" ovf:required="false">
4694 <ovf:Info>Specifies the available VM network connections</ovf:Info>
4695 <PrimaryNetworkConnectionIndex>0</PrimaryNetworkConnectionIndex>
4696 <Link rel="edit" href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml"/>
4697 </NetworkConnectionSection>""".format(url
=url_rest_call
)
4698 response
= self
.perform_request(req_type
='PUT',
4703 if response
.status_code
== 403:
4704 add_headers
= {'Content-Type': headers
['Content-Type']}
4705 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, newdata
)
4707 if response
.status_code
!= 202:
4708 self
.logger
.error("REST call {} failed reason : {}"\
4709 "status code : {} ".format(url_rest_call
,
4711 response
.status_code
))
4712 raise vimconn
.vimconnException("remove_primary_network_adapter : Failed to update "\
4713 "network connection section")
4715 nic_task
= self
.get_task_from_response(response
.content
)
4716 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
4717 if result
.get('status') == 'success':
4718 self
.logger
.info("remove_primary_network_adapter(): VM {} conneced to "\
4719 "default NIC type".format(vm_id
))
4721 self
.logger
.error("remove_primary_network_adapter(): VM {} failed to "\
4722 "connect NIC type".format(vm_id
))
4724 def add_network_adapter_to_vms(self
, vapp
, network_name
, primary_nic_index
, nicIndex
, net
, nic_type
=None):
4726 Method to add network adapter type to vm
4728 network_name - name of network
4729 primary_nic_index - int value for primary nic index
4730 nicIndex - int value for nic index
4731 nic_type - specify model name to which add to vm
4736 self
.logger
.info("Add network adapter to VM: network_name {} nicIndex {} nic_type {}".\
4737 format(network_name
, nicIndex
, nic_type
))
4742 if 'floating_ip' in net
: floating_ip
= net
['floating_ip']
4744 # Stub for ip_address feature
4745 if 'ip_address' in net
: ip_address
= net
['ip_address']
4747 if 'mac_address' in net
: mac_address
= net
['mac_address']
4750 allocation_mode
= "POOL"
4752 allocation_mode
= "MANUAL"
4754 allocation_mode
= "DHCP"
4757 for vms
in vapp
.get_all_vms():
4758 vm_id
= vms
.get('id').split(':')[-1]
4760 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
4762 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4763 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4764 response
= self
.perform_request(req_type
='GET',
4768 if response
.status_code
== 403:
4769 response
= self
.retry_rest('GET', url_rest_call
)
4771 if response
.status_code
!= 200:
4772 self
.logger
.error("REST call {} failed reason : {}"\
4773 "status code : {}".format(url_rest_call
,
4775 response
.status_code
))
4776 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
4777 "network connection section")
4779 data
= response
.content
4780 data
= data
.split('<Link rel="edit"')[0]
4781 if '<PrimaryNetworkConnectionIndex>' not in data
:
4782 self
.logger
.debug("add_network_adapter PrimaryNIC not in data")
4783 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
4784 <NetworkConnection network="{}">
4785 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4786 <IsConnected>true</IsConnected>
4787 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4788 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
4790 # Stub for ip_address feature
4792 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4793 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4796 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4797 item
= item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4799 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item
))
4801 self
.logger
.debug("add_network_adapter PrimaryNIC in data")
4802 new_item
= """<NetworkConnection network="{}">
4803 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4804 <IsConnected>true</IsConnected>
4805 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4806 </NetworkConnection>""".format(network_name
, nicIndex
,
4808 # Stub for ip_address feature
4810 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4811 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4814 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4815 new_item
= new_item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4817 data
= data
+ new_item
+ '</NetworkConnectionSection>'
4819 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
4821 response
= self
.perform_request(req_type
='PUT',
4826 if response
.status_code
== 403:
4827 add_headers
= {'Content-Type': headers
['Content-Type']}
4828 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
4830 if response
.status_code
!= 202:
4831 self
.logger
.error("REST call {} failed reason : {}"\
4832 "status code : {} ".format(url_rest_call
,
4834 response
.status_code
))
4835 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
4836 "network connection section")
4838 nic_task
= self
.get_task_from_response(response
.content
)
4839 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
4840 if result
.get('status') == 'success':
4841 self
.logger
.info("add_network_adapter_to_vms(): VM {} conneced to "\
4842 "default NIC type".format(vm_id
))
4844 self
.logger
.error("add_network_adapter_to_vms(): VM {} failed to "\
4845 "connect NIC type".format(vm_id
))
4847 for vms
in vapp
.get_all_vms():
4848 vm_id
= vms
.get('id').split(':')[-1]
4850 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
4852 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4853 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4854 response
= self
.perform_request(req_type
='GET',
4858 if response
.status_code
== 403:
4859 response
= self
.retry_rest('GET', url_rest_call
)
4861 if response
.status_code
!= 200:
4862 self
.logger
.error("REST call {} failed reason : {}"\
4863 "status code : {}".format(url_rest_call
,
4865 response
.status_code
))
4866 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
4867 "network connection section")
4868 data
= response
.content
4869 data
= data
.split('<Link rel="edit"')[0]
4870 if '<PrimaryNetworkConnectionIndex>' not in data
:
4871 self
.logger
.debug("add_network_adapter PrimaryNIC not in data nic_type {}".format(nic_type
))
4872 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
4873 <NetworkConnection network="{}">
4874 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4875 <IsConnected>true</IsConnected>
4876 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4877 <NetworkAdapterType>{}</NetworkAdapterType>
4878 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
4879 allocation_mode
, nic_type
)
4880 # Stub for ip_address feature
4882 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4883 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4886 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4887 item
= item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4889 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item
))
4891 self
.logger
.debug("add_network_adapter PrimaryNIC in data nic_type {}".format(nic_type
))
4892 new_item
= """<NetworkConnection network="{}">
4893 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4894 <IsConnected>true</IsConnected>
4895 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4896 <NetworkAdapterType>{}</NetworkAdapterType>
4897 </NetworkConnection>""".format(network_name
, nicIndex
,
4898 allocation_mode
, nic_type
)
4899 # Stub for ip_address feature
4901 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4902 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4905 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4906 new_item
= new_item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4908 data
= data
+ new_item
+ '</NetworkConnectionSection>'
4910 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
4912 response
= self
.perform_request(req_type
='PUT',
4917 if response
.status_code
== 403:
4918 add_headers
= {'Content-Type': headers
['Content-Type']}
4919 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
4921 if response
.status_code
!= 202:
4922 self
.logger
.error("REST call {} failed reason : {}"\
4923 "status code : {}".format(url_rest_call
,
4925 response
.status_code
))
4926 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
4927 "network connection section")
4929 nic_task
= self
.get_task_from_response(response
.content
)
4930 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
4931 if result
.get('status') == 'success':
4932 self
.logger
.info("add_network_adapter_to_vms(): VM {} "\
4933 "conneced to NIC type {}".format(vm_id
, nic_type
))
4935 self
.logger
.error("add_network_adapter_to_vms(): VM {} "\
4936 "failed to connect NIC type {}".format(vm_id
, nic_type
))
4937 except Exception as exp
:
4938 self
.logger
.error("add_network_adapter_to_vms() : exception occurred "\
4939 "while adding Network adapter")
4940 raise vimconn
.vimconnException(message
=exp
)
4943 def set_numa_affinity(self
, vmuuid
, paired_threads_id
):
4945 Method to assign numa affinity in vm configuration parammeters
4948 paired_threads_id - one or more virtual processor
4954 vcenter_conect
, content
= self
.get_vcenter_content()
4955 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
4957 host_obj
, vm_obj
= self
.get_vm_obj(content
,vm_moref_id
)
4959 config_spec
= vim
.vm
.ConfigSpec()
4960 config_spec
.extraConfig
= []
4961 opt
= vim
.option
.OptionValue()
4962 opt
.key
= 'numa.nodeAffinity'
4963 opt
.value
= str(paired_threads_id
)
4964 config_spec
.extraConfig
.append(opt
)
4965 task
= vm_obj
.ReconfigVM_Task(config_spec
)
4967 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4968 extra_config
= vm_obj
.config
.extraConfig
4970 for opts
in extra_config
:
4971 if 'numa.nodeAffinity' in opts
.key
:
4973 self
.logger
.info("set_numa_affinity: Sucessfully assign numa affinity "\
4974 "value {} for vm {}".format(opt
.value
, vm_obj
))
4978 self
.logger
.error("set_numa_affinity: Failed to assign numa affinity")
4979 except Exception as exp
:
4980 self
.logger
.error("set_numa_affinity : exception occurred while setting numa affinity "\
4981 "for VM {} : {}".format(vm_obj
, vm_moref_id
))
4982 raise vimconn
.vimconnException("set_numa_affinity : Error {} failed to assign numa "\
4983 "affinity".format(exp
))
4986 def cloud_init(self
, vapp
, cloud_config
):
4988 Method to inject ssh-key
4990 cloud_config a dictionary with:
4991 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
4992 'users': (optional) list of users to be inserted, each item is a dict with:
4993 'name': (mandatory) user name,
4994 'key-pairs': (optional) list of strings with the public key to be inserted to the user
4995 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
4996 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
4997 'config-files': (optional). List of files to be transferred. Each item is a dict with:
4998 'dest': (mandatory) string with the destination absolute path
4999 'encoding': (optional, by default text). Can be one of:
5000 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
5001 'content' (mandatory): string with the content of the file
5002 'permissions': (optional) string with file permissions, typically octal notation '0644'
5003 'owner': (optional) file owner, string with the format 'owner:group'
5004 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk
5007 if not isinstance(cloud_config
, dict):
5008 raise Exception("cloud_init : parameter cloud_config is not a dictionary")
5012 if "key-pairs" in cloud_config
:
5013 key_pairs
= cloud_config
["key-pairs"]
5015 if "users" in cloud_config
:
5016 userdata
= cloud_config
["users"]
5018 self
.logger
.debug("cloud_init : Guest os customization started..")
5019 customize_script
= self
.format_script(key_pairs
=key_pairs
, users_list
=userdata
)
5020 customize_script
= customize_script
.replace("&","&")
5021 self
.guest_customization(vapp
, customize_script
)
5023 except Exception as exp
:
5024 self
.logger
.error("cloud_init : exception occurred while injecting "\
5026 raise vimconn
.vimconnException("cloud_init : Error {} failed to inject "\
5027 "ssh-key".format(exp
))
5029 def format_script(self
, key_pairs
=[], users_list
=[]):
5030 bash_script
= """#!/bin/sh
5031 echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
5032 if [ "$1" = "precustomization" ];then
5033 echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
5036 keys
= "\n".join(key_pairs
)
5039 if [ ! -d /root/.ssh ];then
5041 chown root:root /root/.ssh
5042 chmod 700 /root/.ssh
5043 touch /root/.ssh/authorized_keys
5044 chown root:root /root/.ssh/authorized_keys
5045 chmod 600 /root/.ssh/authorized_keys
5046 # make centos with selinux happy
5047 which restorecon && restorecon -Rv /root/.ssh
5049 touch /root/.ssh/authorized_keys
5050 chown root:root /root/.ssh/authorized_keys
5051 chmod 600 /root/.ssh/authorized_keys
5053 echo '{key}' >> /root/.ssh/authorized_keys
5054 """.format(key
=keys
)
5056 bash_script
+= keys_data
5058 for user
in users_list
:
5059 if 'name' in user
: user_name
= user
['name']
5060 if 'key-pairs' in user
:
5061 user_keys
= "\n".join(user
['key-pairs'])
5066 useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
5067 """.format(user_name
=user_name
)
5069 bash_script
+= add_user_name
5072 user_keys_data
= """
5073 mkdir /home/{user_name}/.ssh
5074 chown {user_name}:{user_name} /home/{user_name}/.ssh
5075 chmod 700 /home/{user_name}/.ssh
5076 touch /home/{user_name}/.ssh/authorized_keys
5077 chown {user_name}:{user_name} /home/{user_name}/.ssh/authorized_keys
5078 chmod 600 /home/{user_name}/.ssh/authorized_keys
5079 # make centos with selinux happy
5080 which restorecon && restorecon -Rv /home/{user_name}/.ssh
5081 echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
5082 """.format(user_name
=user_name
,user_key
=user_keys
)
5084 bash_script
+= user_keys_data
5086 return bash_script
+"\n\tfi"
5088 def guest_customization(self
, vapp
, customize_script
):
5090 Method to customize guest os
5092 customize_script - Customize script to be run at first boot of VM.
5094 for vm
in vapp
.get_all_vms():
5095 vm_id
= vm
.get('id').split(':')[-1]
5096 vm_name
= vm
.get('name')
5097 vm_name
= vm_name
.replace('_','-')
5099 vm_customization_url
= "{}/api/vApp/vm-{}/guestCustomizationSection/".format(self
.url
, vm_id
)
5100 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5101 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5103 headers
['Content-Type'] = "application/vnd.vmware.vcloud.guestCustomizationSection+xml"
5105 data
= """<GuestCustomizationSection
5106 xmlns="http://www.vmware.com/vcloud/v1.5"
5107 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
5108 ovf:required="false" href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
5109 <ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
5110 <Enabled>true</Enabled>
5111 <ChangeSid>false</ChangeSid>
5112 <VirtualMachineId>{}</VirtualMachineId>
5113 <JoinDomainEnabled>false</JoinDomainEnabled>
5114 <UseOrgSettings>false</UseOrgSettings>
5115 <AdminPasswordEnabled>false</AdminPasswordEnabled>
5116 <AdminPasswordAuto>true</AdminPasswordAuto>
5117 <AdminAutoLogonEnabled>false</AdminAutoLogonEnabled>
5118 <AdminAutoLogonCount>0</AdminAutoLogonCount>
5119 <ResetPasswordRequired>false</ResetPasswordRequired>
5120 <CustomizationScript>{}</CustomizationScript>
5121 <ComputerName>{}</ComputerName>
5122 <Link href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml" rel="edit"/>
5123 </GuestCustomizationSection>
5124 """.format(vm_customization_url
,
5128 vm_customization_url
)
5130 response
= self
.perform_request(req_type
='PUT',
5131 url
=vm_customization_url
,
5134 if response
.status_code
== 202:
5135 guest_task
= self
.get_task_from_response(response
.content
)
5136 self
.client
.get_task_monitor().wait_for_success(task
=guest_task
)
5137 self
.logger
.info("guest_customization : customized guest os task "\
5138 "completed for VM {}".format(vm_name
))
5140 self
.logger
.error("guest_customization : task for customized guest os"\
5141 "failed for VM {}".format(vm_name
))
5142 raise vimconn
.vimconnException("guest_customization : failed to perform"\
5143 "guest os customization on VM {}".format(vm_name
))
5145 def add_new_disk(self
, vapp_uuid
, disk_size
):
5147 Method to create an empty vm disk
5150 vapp_uuid - is vapp identifier.
5151 disk_size - size of disk to be created in GB
5159 #Disk size in GB, convert it into MB
5160 if disk_size
is not None:
5161 disk_size_mb
= int(disk_size
) * 1024
5162 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
5164 if vm_details
and "vm_virtual_hardware" in vm_details
:
5165 self
.logger
.info("Adding disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
5166 disk_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
5167 status
= self
.add_new_disk_rest(disk_href
, disk_size_mb
)
5169 except Exception as exp
:
5170 msg
= "Error occurred while creating new disk {}.".format(exp
)
5171 self
.rollback_newvm(vapp_uuid
, msg
)
5174 self
.logger
.info("Added new disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
5176 #If failed to add disk, delete VM
5177 msg
= "add_new_disk: Failed to add new disk to {}".format(vm_details
["name"])
5178 self
.rollback_newvm(vapp_uuid
, msg
)
5181 def add_new_disk_rest(self
, disk_href
, disk_size_mb
):
5183 Retrives vApp Disks section & add new empty disk
5186 disk_href: Disk section href to addd disk
5187 disk_size_mb: Disk size in MB
5189 Returns: Status of add new disk task
5192 if self
.client
._session
:
5193 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5194 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5195 response
= self
.perform_request(req_type
='GET',
5199 if response
.status_code
== 403:
5200 response
= self
.retry_rest('GET', disk_href
)
5202 if response
.status_code
!= requests
.codes
.ok
:
5203 self
.logger
.error("add_new_disk_rest: GET REST API call {} failed. Return status code {}"
5204 .format(disk_href
, response
.status_code
))
5207 #Find but type & max of instance IDs assigned to disks
5208 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
5209 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
5211 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
5212 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
5214 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
5215 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
5216 inst_id
= int(item
.find("rasd:InstanceID" ,namespaces
).text
)
5217 if inst_id
> instance_id
:
5218 instance_id
= inst_id
5219 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
5220 bus_subtype
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busSubType"]
5221 bus_type
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busType"]
5223 instance_id
= instance_id
+ 1
5224 new_item
= """<Item>
5225 <rasd:Description>Hard disk</rasd:Description>
5226 <rasd:ElementName>New disk</rasd:ElementName>
5228 xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
5229 vcloud:capacity="{}"
5230 vcloud:busSubType="{}"
5231 vcloud:busType="{}"></rasd:HostResource>
5232 <rasd:InstanceID>{}</rasd:InstanceID>
5233 <rasd:ResourceType>17</rasd:ResourceType>
5234 </Item>""".format(disk_size_mb
, bus_subtype
, bus_type
, instance_id
)
5236 new_data
= response
.content
5237 #Add new item at the bottom
5238 new_data
= new_data
.replace('</Item>\n</RasdItemsList>', '</Item>\n{}\n</RasdItemsList>'.format(new_item
))
5240 # Send PUT request to modify virtual hardware section with new disk
5241 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
5243 response
= self
.perform_request(req_type
='PUT',
5248 if response
.status_code
== 403:
5249 add_headers
= {'Content-Type': headers
['Content-Type']}
5250 response
= self
.retry_rest('PUT', disk_href
, add_headers
, new_data
)
5252 if response
.status_code
!= 202:
5253 self
.logger
.error("PUT REST API call {} failed. Return status code {}. Response Content:{}"
5254 .format(disk_href
, response
.status_code
, response
.content
))
5256 add_disk_task
= self
.get_task_from_response(response
.content
)
5257 result
= self
.client
.get_task_monitor().wait_for_success(task
=add_disk_task
)
5258 if result
.get('status') == 'success':
5261 self
.logger
.error("Add new disk REST task failed to add {} MB disk".format(disk_size_mb
))
5263 except Exception as exp
:
5264 self
.logger
.error("Error occurred calling rest api for creating new disk {}".format(exp
))
5269 def add_existing_disk(self
, catalogs
=None, image_id
=None, size
=None, template_name
=None, vapp_uuid
=None):
5271 Method to add existing disk to vm
5273 catalogs - List of VDC catalogs
5274 image_id - Catalog ID
5275 template_name - Name of template in catalog
5276 vapp_uuid - UUID of vApp
5281 vcenter_conect
, content
= self
.get_vcenter_content()
5282 #find moref-id of vm in image
5283 catalog_vm_info
= self
.get_vapp_template_details(catalogs
=catalogs
,
5287 if catalog_vm_info
and "vm_vcenter_info" in catalog_vm_info
:
5288 if "vm_moref_id" in catalog_vm_info
["vm_vcenter_info"]:
5289 catalog_vm_moref_id
= catalog_vm_info
["vm_vcenter_info"].get("vm_moref_id", None)
5290 if catalog_vm_moref_id
:
5291 self
.logger
.info("Moref_id of VM in catalog : {}" .format(catalog_vm_moref_id
))
5292 host
, catalog_vm_obj
= self
.get_vm_obj(content
, catalog_vm_moref_id
)
5295 disk_info
= self
.find_disk(catalog_vm_obj
)
5297 exp_msg
= "No VM with image id {} found".format(image_id
)
5298 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
5300 exp_msg
= "No Image found with image ID {} ".format(image_id
)
5301 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
5304 self
.logger
.info("Existing disk_info : {}".format(disk_info
))
5306 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
5307 host
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
5309 status
= self
.add_disk(vcenter_conect
=vcenter_conect
,
5311 disk_info
=disk_info
,
5316 self
.logger
.info("Disk from image id {} added to {}".format(image_id
,
5320 msg
= "No disk found with image id {} to add in VM {}".format(
5323 self
.rollback_newvm(vapp_uuid
, msg
, exp_type
="NotFound")
5326 def find_disk(self
, vm_obj
):
5328 Method to find details of existing disk in VM
5330 vm_obj - vCenter object of VM
5331 image_id - Catalog ID
5333 disk_info : dict of disk details
5338 devices
= vm_obj
.config
.hardware
.device
5339 for device
in devices
:
5340 if type(device
) is vim
.vm
.device
.VirtualDisk
:
5341 if isinstance(device
.backing
,vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo
) and hasattr(device
.backing
, 'fileName'):
5342 disk_info
["full_path"] = device
.backing
.fileName
5343 disk_info
["datastore"] = device
.backing
.datastore
5344 disk_info
["capacityKB"] = device
.capacityInKB
5346 except Exception as exp
:
5347 self
.logger
.error("find_disk() : exception occurred while "\
5348 "getting existing disk details :{}".format(exp
))
5352 def add_disk(self
, vcenter_conect
=None, vm
=None, size
=None, vapp_uuid
=None, disk_info
={}):
5354 Method to add existing disk in VM
5356 vcenter_conect - vCenter content object
5357 vm - vCenter vm object
5358 disk_info : dict of disk details
5360 status : status of add disk task
5362 datastore
= disk_info
["datastore"] if "datastore" in disk_info
else None
5363 fullpath
= disk_info
["full_path"] if "full_path" in disk_info
else None
5364 capacityKB
= disk_info
["capacityKB"] if "capacityKB" in disk_info
else None
5365 if size
is not None:
5366 #Convert size from GB to KB
5367 sizeKB
= int(size
) * 1024 * 1024
5368 #compare size of existing disk and user given size.Assign whicherver is greater
5369 self
.logger
.info("Add Existing disk : sizeKB {} , capacityKB {}".format(
5370 sizeKB
, capacityKB
))
5371 if sizeKB
> capacityKB
:
5374 if datastore
and fullpath
and capacityKB
:
5376 spec
= vim
.vm
.ConfigSpec()
5377 # get all disks on a VM, set unit_number to the next available
5379 for dev
in vm
.config
.hardware
.device
:
5380 if hasattr(dev
.backing
, 'fileName'):
5381 unit_number
= int(dev
.unitNumber
) + 1
5382 # unit_number 7 reserved for scsi controller
5383 if unit_number
== 7:
5385 if isinstance(dev
, vim
.vm
.device
.VirtualDisk
):
5386 #vim.vm.device.VirtualSCSIController
5387 controller_key
= dev
.controllerKey
5389 self
.logger
.info("Add Existing disk : unit number {} , controller key {}".format(
5390 unit_number
, controller_key
))
5393 disk_spec
= vim
.vm
.device
.VirtualDeviceSpec()
5394 disk_spec
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
5395 disk_spec
.device
= vim
.vm
.device
.VirtualDisk()
5396 disk_spec
.device
.backing
= \
5397 vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo()
5398 disk_spec
.device
.backing
.thinProvisioned
= True
5399 disk_spec
.device
.backing
.diskMode
= 'persistent'
5400 disk_spec
.device
.backing
.datastore
= datastore
5401 disk_spec
.device
.backing
.fileName
= fullpath
5403 disk_spec
.device
.unitNumber
= unit_number
5404 disk_spec
.device
.capacityInKB
= capacityKB
5405 disk_spec
.device
.controllerKey
= controller_key
5406 dev_changes
.append(disk_spec
)
5407 spec
.deviceChange
= dev_changes
5408 task
= vm
.ReconfigVM_Task(spec
=spec
)
5409 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5411 except Exception as exp
:
5412 exp_msg
= "add_disk() : exception {} occurred while adding disk "\
5413 "{} to vm {}".format(exp
,
5416 self
.rollback_newvm(vapp_uuid
, exp_msg
)
5418 msg
= "add_disk() : Can not add disk to VM with disk info {} ".format(disk_info
)
5419 self
.rollback_newvm(vapp_uuid
, msg
)
5422 def get_vcenter_content(self
):
5424 Get the vsphere content object
5427 vm_vcenter_info
= self
.get_vm_vcenter_info()
5428 except Exception as exp
:
5429 self
.logger
.error("Error occurred while getting vCenter infromationn"\
5430 " for VM : {}".format(exp
))
5431 raise vimconn
.vimconnException(message
=exp
)
5434 if hasattr(ssl
, '_create_unverified_context'):
5435 context
= ssl
._create
_unverified
_context
()
5437 vcenter_conect
= SmartConnect(
5438 host
=vm_vcenter_info
["vm_vcenter_ip"],
5439 user
=vm_vcenter_info
["vm_vcenter_user"],
5440 pwd
=vm_vcenter_info
["vm_vcenter_password"],
5441 port
=int(vm_vcenter_info
["vm_vcenter_port"]),
5444 atexit
.register(Disconnect
, vcenter_conect
)
5445 content
= vcenter_conect
.RetrieveContent()
5446 return vcenter_conect
, content
5449 def get_vm_moref_id(self
, vapp_uuid
):
5451 Get the moref_id of given VM
5455 vm_details
= self
.get_vapp_details_rest(vapp_uuid
, need_admin_access
=True)
5456 if vm_details
and "vm_vcenter_info" in vm_details
:
5457 vm_moref_id
= vm_details
["vm_vcenter_info"].get("vm_moref_id", None)
5460 except Exception as exp
:
5461 self
.logger
.error("Error occurred while getting VM moref ID "\
5462 " for VM : {}".format(exp
))
5466 def get_vapp_template_details(self
, catalogs
=None, image_id
=None , template_name
=None):
5468 Method to get vApp template details
5470 catalogs - list of VDC catalogs
5471 image_id - Catalog ID to find
5472 template_name : template name in catalog
5474 parsed_respond : dict of vApp tempalte details
5476 parsed_response
= {}
5478 vca
= self
.connect_as_admin()
5480 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
5483 org
, vdc
= self
.get_vdc_details()
5484 catalog
= self
.get_catalog_obj(image_id
, catalogs
)
5486 items
= org
.get_catalog_item(catalog
.get('name'), catalog
.get('name'))
5487 catalog_items
= [items
.attrib
]
5489 if len(catalog_items
) == 1:
5490 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5491 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
5493 response
= self
.perform_request(req_type
='GET',
5494 url
=catalog_items
[0].get('href'),
5496 catalogItem
= XmlElementTree
.fromstring(response
.content
)
5497 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
5498 vapp_tempalte_href
= entity
.get("href")
5499 #get vapp details and parse moref id
5501 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
5502 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
5503 'vmw': 'http://www.vmware.com/schema/ovf',
5504 'vm': 'http://www.vmware.com/vcloud/v1.5',
5505 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
5506 'vmext':"http://www.vmware.com/vcloud/extension/v1.5",
5507 'xmlns':"http://www.vmware.com/vcloud/v1.5"
5511 response
= self
.perform_request(req_type
='GET',
5512 url
=vapp_tempalte_href
,
5515 if response
.status_code
!= requests
.codes
.ok
:
5516 self
.logger
.debug("REST API call {} failed. Return status code {}".format(
5517 vapp_tempalte_href
, response
.status_code
))
5520 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
5521 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
5522 if children_section
is not None:
5523 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
5524 if vCloud_extension_section
is not None:
5525 vm_vcenter_info
= {}
5526 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
5527 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
5528 if vmext
is not None:
5529 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
5530 parsed_response
["vm_vcenter_info"]= vm_vcenter_info
5532 except Exception as exp
:
5533 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
5535 return parsed_response
5538 def rollback_newvm(self
, vapp_uuid
, msg
, exp_type
="Genric"):
5540 Method to delete vApp
5542 vapp_uuid - vApp UUID
5543 msg - Error message to be logged
5544 exp_type : Exception type
5549 status
= self
.delete_vminstance(vapp_uuid
)
5552 self
.logger
.error(msg
)
5553 if exp_type
== "Genric":
5554 raise vimconn
.vimconnException(msg
)
5555 elif exp_type
== "NotFound":
5556 raise vimconn
.vimconnNotFoundException(message
=msg
)
5558 def add_sriov(self
, vapp_uuid
, sriov_nets
, vmname_andid
):
5560 Method to attach SRIOV adapters to VM
5563 vapp_uuid - uuid of vApp/VM
5564 sriov_nets - SRIOV devices infromation as specified in VNFD (flavor)
5565 vmname_andid - vmname
5568 The status of add SRIOV adapter task , vm object and
5569 vcenter_conect object
5572 vcenter_conect
, content
= self
.get_vcenter_content()
5573 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
5577 no_of_sriov_devices
= len(sriov_nets
)
5578 if no_of_sriov_devices
> 0:
5579 #Get VM and its host
5580 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
5581 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
5582 if host_obj
and vm_obj
:
5583 #get SRIOV devies from host on which vapp is currently installed
5584 avilable_sriov_devices
= self
.get_sriov_devices(host_obj
,
5585 no_of_sriov_devices
,
5588 if len(avilable_sriov_devices
) == 0:
5589 #find other hosts with active pci devices
5590 new_host_obj
, avilable_sriov_devices
= self
.get_host_and_sriov_devices(
5592 no_of_sriov_devices
,
5595 if new_host_obj
is not None and len(avilable_sriov_devices
)> 0:
5596 #Migrate vm to the host where SRIOV devices are available
5597 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
,
5599 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
5600 if task
is not None:
5601 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5602 self
.logger
.info("Migrate VM status: {}".format(result
))
5603 host_obj
= new_host_obj
5605 self
.logger
.info("Fail to migrate VM : {}".format(result
))
5606 raise vimconn
.vimconnNotFoundException(
5607 "Fail to migrate VM : {} to host {}".format(
5612 if host_obj
is not None and avilable_sriov_devices
is not None and len(avilable_sriov_devices
)> 0:
5613 #Add SRIOV devices one by one
5614 for sriov_net
in sriov_nets
:
5615 network_name
= sriov_net
.get('net_id')
5616 dvs_portgr_name
= self
.create_dvPort_group(network_name
)
5617 if sriov_net
.get('type') == "VF" or sriov_net
.get('type') == "SR-IOV":
5618 #add vlan ID ,Modify portgroup for vlan ID
5619 self
.configure_vlanID(content
, vcenter_conect
, network_name
)
5621 task
= self
.add_sriov_to_vm(content
,
5625 avilable_sriov_devices
[0]
5628 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5630 self
.logger
.info("Added SRIOV {} to VM {}".format(
5631 no_of_sriov_devices
,
5634 self
.logger
.error("Fail to add SRIOV {} to VM {}".format(
5635 no_of_sriov_devices
,
5637 raise vimconn
.vimconnUnexpectedResponse(
5638 "Fail to add SRIOV adapter in VM ".format(str(vm_obj
))
5640 return True, vm_obj
, vcenter_conect
5642 self
.logger
.error("Currently there is no host with"\
5643 " {} number of avaialble SRIOV "\
5644 "VFs required for VM {}".format(
5645 no_of_sriov_devices
,
5648 raise vimconn
.vimconnNotFoundException(
5649 "Currently there is no host with {} "\
5650 "number of avaialble SRIOV devices required for VM {}".format(
5651 no_of_sriov_devices
,
5654 self
.logger
.debug("No infromation about SRIOV devices {} ",sriov_nets
)
5656 except vmodl
.MethodFault
as error
:
5657 self
.logger
.error("Error occurred while adding SRIOV {} ",error
)
5658 return None, vm_obj
, vcenter_conect
5661 def get_sriov_devices(self
,host
, no_of_vfs
):
5663 Method to get the details of SRIOV devices on given host
5665 host - vSphere host object
5666 no_of_vfs - number of VFs needed on host
5669 array of SRIOV devices
5673 for device
in host
.config
.pciPassthruInfo
:
5674 if isinstance(device
,vim
.host
.SriovInfo
) and device
.sriovActive
:
5675 if device
.numVirtualFunction
>= no_of_vfs
:
5676 sriovInfo
.append(device
)
5681 def get_host_and_sriov_devices(self
, content
, no_of_vfs
):
5683 Method to get the details of SRIOV devices infromation on all hosts
5686 content - vSphere host object
5687 no_of_vfs - number of pci VFs needed on host
5690 array of SRIOV devices and host object
5693 sriov_device_objs
= None
5696 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
5697 [vim
.HostSystem
], True)
5698 for host
in container
.view
:
5699 devices
= self
.get_sriov_devices(host
, no_of_vfs
)
5702 sriov_device_objs
= devices
5704 except Exception as exp
:
5705 self
.logger
.error("Error {} occurred while finding SRIOV devices on host: {}".format(exp
, host_obj
))
5707 return host_obj
,sriov_device_objs
5710 def add_sriov_to_vm(self
,content
, vm_obj
, host_obj
, network_name
, sriov_device
):
5712 Method to add SRIOV adapter to vm
5715 host_obj - vSphere host object
5716 vm_obj - vSphere vm object
5717 content - vCenter content object
5718 network_name - name of distributed virtaul portgroup
5719 sriov_device - SRIOV device info
5725 vnic_label
= "sriov nic"
5727 dvs_portgr
= self
.get_dvport_group(network_name
)
5728 network_name
= dvs_portgr
.name
5729 nic
= vim
.vm
.device
.VirtualDeviceSpec()
5731 nic
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
5732 nic
.device
= vim
.vm
.device
.VirtualSriovEthernetCard()
5733 nic
.device
.addressType
= 'assigned'
5734 #nic.device.key = 13016
5735 nic
.device
.deviceInfo
= vim
.Description()
5736 nic
.device
.deviceInfo
.label
= vnic_label
5737 nic
.device
.deviceInfo
.summary
= network_name
5738 nic
.device
.backing
= vim
.vm
.device
.VirtualEthernetCard
.NetworkBackingInfo()
5740 nic
.device
.backing
.network
= self
.get_obj(content
, [vim
.Network
], network_name
)
5741 nic
.device
.backing
.deviceName
= network_name
5742 nic
.device
.backing
.useAutoDetect
= False
5743 nic
.device
.connectable
= vim
.vm
.device
.VirtualDevice
.ConnectInfo()
5744 nic
.device
.connectable
.startConnected
= True
5745 nic
.device
.connectable
.allowGuestControl
= True
5747 nic
.device
.sriovBacking
= vim
.vm
.device
.VirtualSriovEthernetCard
.SriovBackingInfo()
5748 nic
.device
.sriovBacking
.physicalFunctionBacking
= vim
.vm
.device
.VirtualPCIPassthrough
.DeviceBackingInfo()
5749 nic
.device
.sriovBacking
.physicalFunctionBacking
.id = sriov_device
.id
5752 vmconf
= vim
.vm
.ConfigSpec(deviceChange
=devices
)
5753 task
= vm_obj
.ReconfigVM_Task(vmconf
)
5755 except Exception as exp
:
5756 self
.logger
.error("Error {} occurred while adding SRIOV adapter in VM: {}".format(exp
, vm_obj
))
5760 def create_dvPort_group(self
, network_name
):
5762 Method to create disributed virtual portgroup
5765 network_name - name of network/portgroup
5771 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
5772 network_name
=''.join(new_network_name
)
5773 vcenter_conect
, content
= self
.get_vcenter_content()
5775 dv_switch
= self
.get_obj(content
, [vim
.DistributedVirtualSwitch
], self
.dvs_name
)
5777 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
5778 dv_pg_spec
.name
= network_name
5780 dv_pg_spec
.type = vim
.dvs
.DistributedVirtualPortgroup
.PortgroupType
.earlyBinding
5781 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
5782 dv_pg_spec
.defaultPortConfig
.securityPolicy
= vim
.dvs
.VmwareDistributedVirtualSwitch
.SecurityPolicy()
5783 dv_pg_spec
.defaultPortConfig
.securityPolicy
.allowPromiscuous
= vim
.BoolPolicy(value
=False)
5784 dv_pg_spec
.defaultPortConfig
.securityPolicy
.forgedTransmits
= vim
.BoolPolicy(value
=False)
5785 dv_pg_spec
.defaultPortConfig
.securityPolicy
.macChanges
= vim
.BoolPolicy(value
=False)
5787 task
= dv_switch
.AddDVPortgroup_Task([dv_pg_spec
])
5788 self
.wait_for_vcenter_task(task
, vcenter_conect
)
5790 dvPort_group
= self
.get_obj(content
, [vim
.dvs
.DistributedVirtualPortgroup
], network_name
)
5792 self
.logger
.info("Created disributed virtaul port group: {}".format(dvPort_group
))
5793 return dvPort_group
.key
5795 self
.logger
.debug("No disributed virtual switch found with name {}".format(network_name
))
5797 except Exception as exp
:
5798 self
.logger
.error("Error occurred while creating disributed virtaul port group {}"\
5799 " : {}".format(network_name
, exp
))
5802 def reconfig_portgroup(self
, content
, dvPort_group_name
, config_info
={}):
5804 Method to reconfigure disributed virtual portgroup
5807 dvPort_group_name - name of disributed virtual portgroup
5808 content - vCenter content object
5809 config_info - disributed virtual portgroup configuration
5815 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
5817 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
5818 dv_pg_spec
.configVersion
= dvPort_group
.config
.configVersion
5819 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
5820 if "vlanID" in config_info
:
5821 dv_pg_spec
.defaultPortConfig
.vlan
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VlanIdSpec()
5822 dv_pg_spec
.defaultPortConfig
.vlan
.vlanId
= config_info
.get('vlanID')
5824 task
= dvPort_group
.ReconfigureDVPortgroup_Task(spec
=dv_pg_spec
)
5828 except Exception as exp
:
5829 self
.logger
.error("Error occurred while reconfiguraing disributed virtaul port group {}"\
5830 " : {}".format(dvPort_group_name
, exp
))
5834 def destroy_dvport_group(self
, dvPort_group_name
):
5836 Method to destroy disributed virtual portgroup
5839 network_name - name of network/portgroup
5842 True if portgroup successfully got deleted else false
5844 vcenter_conect
, content
= self
.get_vcenter_content()
5847 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
5849 task
= dvPort_group
.Destroy_Task()
5850 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5852 except vmodl
.MethodFault
as exp
:
5853 self
.logger
.error("Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
5854 exp
, dvPort_group_name
))
5858 def get_dvport_group(self
, dvPort_group_name
):
5860 Method to get disributed virtual portgroup
5863 network_name - name of network/portgroup
5868 vcenter_conect
, content
= self
.get_vcenter_content()
5871 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, [vim
.dvs
.DistributedVirtualPortgroup
], True)
5872 for item
in container
.view
:
5873 if item
.key
== dvPort_group_name
:
5877 except vmodl
.MethodFault
as exp
:
5878 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
5879 exp
, dvPort_group_name
))
5882 def get_vlanID_from_dvs_portgr(self
, dvPort_group_name
):
5884 Method to get disributed virtual portgroup vlanID
5887 network_name - name of network/portgroup
5894 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
5896 vlanId
= dvPort_group
.config
.defaultPortConfig
.vlan
.vlanId
5897 except vmodl
.MethodFault
as exp
:
5898 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
5899 exp
, dvPort_group_name
))
5903 def configure_vlanID(self
, content
, vcenter_conect
, dvPort_group_name
):
5905 Method to configure vlanID in disributed virtual portgroup vlanID
5908 network_name - name of network/portgroup
5913 vlanID
= self
.get_vlanID_from_dvs_portgr(dvPort_group_name
)
5916 vlanID
= self
.genrate_vlanID(dvPort_group_name
)
5917 config
= {"vlanID":vlanID
}
5918 task
= self
.reconfig_portgroup(content
, dvPort_group_name
,
5921 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5923 self
.logger
.info("Reconfigured Port group {} for vlan ID {}".format(
5924 dvPort_group_name
,vlanID
))
5926 self
.logger
.error("Fail reconfigure portgroup {} for vlanID{}".format(
5927 dvPort_group_name
, vlanID
))
5930 def genrate_vlanID(self
, network_name
):
5932 Method to get unused vlanID
5934 network_name - name of network/portgroup
5940 if self
.config
.get('vlanID_range') == None:
5941 raise vimconn
.vimconnConflictException("You must provide a 'vlanID_range' "\
5942 "at config value before creating sriov network with vlan tag")
5943 if "used_vlanIDs" not in self
.persistent_info
:
5944 self
.persistent_info
["used_vlanIDs"] = {}
5946 used_ids
= self
.persistent_info
["used_vlanIDs"].values()
5948 #used_ids = list(self.persistent_info["used_vlanIDs"].values())
5950 for vlanID_range
in self
.config
.get('vlanID_range'):
5951 start_vlanid
, end_vlanid
= vlanID_range
.split("-")
5952 if start_vlanid
> end_vlanid
:
5953 raise vimconn
.vimconnConflictException("Invalid vlan ID range {}".format(
5956 for id in xrange(int(start_vlanid
), int(end_vlanid
) + 1):
5958 #for id in range(int(start_vlanid), int(end_vlanid) + 1):
5959 if id not in used_ids
:
5961 self
.persistent_info
["used_vlanIDs"][network_name
] = vlan_id
5964 raise vimconn
.vimconnConflictException("All Vlan IDs are in use")
5967 def get_obj(self
, content
, vimtype
, name
):
5969 Get the vsphere object associated with a given text name
5972 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, vimtype
, True)
5973 for item
in container
.view
:
5974 if item
.name
== name
:
5980 def insert_media_to_vm(self
, vapp
, image_id
):
5982 Method to insert media CD-ROM (ISO image) from catalog to vm.
5983 vapp - vapp object to get vm id
5984 Image_id - image id for cdrom to be inerted to vm
5986 # create connection object
5987 vca
= self
.connect()
5989 # fetching catalog details
5990 rest_url
= "{}/api/catalog/{}".format(self
.url
, image_id
)
5992 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5993 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
5994 response
= self
.perform_request(req_type
='GET',
5998 if response
.status_code
!= 200:
5999 self
.logger
.error("REST call {} failed reason : {}"\
6000 "status code : {}".format(url_rest_call
,
6002 response
.status_code
))
6003 raise vimconn
.vimconnException("insert_media_to_vm(): Failed to get "\
6005 # searching iso name and id
6006 iso_name
,media_id
= self
.get_media_details(vca
, response
.content
)
6008 if iso_name
and media_id
:
6009 data
="""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
6010 <ns6:MediaInsertOrEjectParams
6011 xmlns="http://www.vmware.com/vcloud/versions" xmlns:ns2="http://schemas.dmtf.org/ovf/envelope/1" xmlns:ns3="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/common" xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" xmlns:ns6="http://www.vmware.com/vcloud/v1.5" xmlns:ns7="http://www.vmware.com/schema/ovf" xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1" xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">
6013 type="application/vnd.vmware.vcloud.media+xml"
6015 id="urn:vcloud:media:{}"
6016 href="https://{}/api/media/{}"/>
6017 </ns6:MediaInsertOrEjectParams>""".format(iso_name
, media_id
,
6020 for vms
in vapp
.get_all_vms():
6021 vm_id
= vms
.get('id').split(':')[-1]
6023 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.mediaInsertOrEjectParams+xml'
6024 rest_url
= "{}/api/vApp/vm-{}/media/action/insertMedia".format(self
.url
,vm_id
)
6026 response
= self
.perform_request(req_type
='POST',
6031 if response
.status_code
!= 202:
6032 self
.logger
.error("Failed to insert CD-ROM to vm")
6033 raise vimconn
.vimconnException("insert_media_to_vm() : Failed to insert"\
6036 task
= self
.get_task_from_response(response
.content
)
6037 result
= self
.client
.get_task_monitor().wait_for_success(task
=task
)
6038 if result
.get('status') == 'success':
6039 self
.logger
.info("insert_media_to_vm(): Sucessfully inserted media ISO"\
6040 " image to vm {}".format(vm_id
))
6042 except Exception as exp
:
6043 self
.logger
.error("insert_media_to_vm() : exception occurred "\
6044 "while inserting media CD-ROM")
6045 raise vimconn
.vimconnException(message
=exp
)
6048 def get_media_details(self
, vca
, content
):
6050 Method to get catalog item details
6051 vca - connection object
6052 content - Catalog details
6053 Return - Media name, media id
6055 cataloghref_list
= []
6058 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
6059 for child
in vm_list_xmlroot
.iter():
6060 if 'CatalogItem' in child
.tag
:
6061 cataloghref_list
.append(child
.attrib
.get('href'))
6062 if cataloghref_list
is not None:
6063 for href
in cataloghref_list
:
6065 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6066 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
6067 response
= self
.perform_request(req_type
='GET',
6070 if response
.status_code
!= 200:
6071 self
.logger
.error("REST call {} failed reason : {}"\
6072 "status code : {}".format(href
,
6074 response
.status_code
))
6075 raise vimconn
.vimconnException("get_media_details : Failed to get "\
6076 "catalogitem details")
6077 list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
6078 for child
in list_xmlroot
.iter():
6079 if 'Entity' in child
.tag
:
6080 if 'media' in child
.attrib
.get('href'):
6081 name
= child
.attrib
.get('name')
6082 media_id
= child
.attrib
.get('href').split('/').pop()
6083 return name
,media_id
6085 self
.logger
.debug("Media name and id not found")
6087 except Exception as exp
:
6088 self
.logger
.error("get_media_details : exception occurred "\
6089 "getting media details")
6090 raise vimconn
.vimconnException(message
=exp
)
6093 def retry_rest(self
, method
, url
, add_headers
=None, data
=None):
6094 """ Method to get Token & retry respective REST request
6096 api - REST API - Can be one of 'GET' or 'PUT' or 'POST'
6097 url - request url to be used
6098 add_headers - Additional headers (optional)
6099 data - Request payload data to be passed in request
6101 response - Response of request
6108 if self
.client
._session
:
6109 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6110 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
6113 headers
.update(add_headers
)
6116 response
= self
.perform_request(req_type
='GET',
6119 elif method
== 'PUT':
6120 response
= self
.perform_request(req_type
='PUT',
6124 elif method
== 'POST':
6125 response
= self
.perform_request(req_type
='POST',
6129 elif method
== 'DELETE':
6130 response
= self
.perform_request(req_type
='DELETE',
6136 def get_token(self
):
6137 """ Generate a new token if expired
6140 The return client object that letter can be used to connect to vCloud director as admin for VDC
6143 self
.logger
.debug("Generate token for vca {} as {} to datacenter {}.".format(self
.org_name
,
6147 client
= Client(host
, verify_ssl_certs
=False)
6148 client
.set_credentials(BasicLoginCredentials(self
.user
, self
.org_name
, self
.passwd
))
6150 self
.client
= client
6153 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
6154 "{} as user: {}".format(self
.org_name
, self
.user
))
6157 raise vimconn
.vimconnConnectionException("Failed while reconnecting vCD")
6160 def get_vdc_details(self
):
6161 """ Get VDC details using pyVcloud Lib
6163 Returns org and vdc object
6165 org
= Org(self
.client
, resource
=self
.client
.get_org())
6166 vdc
= org
.get_vdc(self
.tenant_name
)
6168 #Retry once, if failed by refreshing token
6171 vdc
= org
.get_vdc(self
.tenant_name
)
6176 def perform_request(self
, req_type
, url
, headers
=None, data
=None):
6177 """Perform the POST/PUT/GET/DELETE request."""
6179 #Log REST request details
6180 self
.log_request(req_type
, url
=url
, headers
=headers
, data
=data
)
6181 # perform request and return its result
6182 if req_type
== 'GET':
6183 response
= requests
.get(url
=url
,
6186 elif req_type
== 'PUT':
6187 response
= requests
.put(url
=url
,
6191 elif req_type
== 'POST':
6192 response
= requests
.post(url
=url
,
6196 elif req_type
== 'DELETE':
6197 response
= requests
.delete(url
=url
,
6200 #Log the REST response
6201 self
.log_response(response
)
6206 def log_request(self
, req_type
, url
=None, headers
=None, data
=None):
6207 """Logs REST request details"""
6209 if req_type
is not None:
6210 self
.logger
.debug("Request type: {}".format(req_type
))
6213 self
.logger
.debug("Request url: {}".format(url
))
6215 if headers
is not None:
6216 for header
in headers
:
6217 self
.logger
.debug("Request header: {}: {}".format(header
, headers
[header
]))
6219 if data
is not None:
6220 self
.logger
.debug("Request data: {}".format(data
))
6223 def log_response(self
, response
):
6224 """Logs REST response details"""
6226 self
.logger
.debug("Response status code: {} ".format(response
.status_code
))
6229 def get_task_from_response(self
, content
):
6231 content - API response content(response.content)
6234 xmlroot
= XmlElementTree
.fromstring(content
)
6235 if xmlroot
.tag
.split('}')[1] == "Task":
6239 if ele
.tag
.split("}")[1] == "Tasks":
6245 def power_on_vapp(self
,vapp_id
, vapp_name
):
6248 vapp_name - vAapp name
6249 return - Task object
6251 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6252 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
6254 poweron_href
= "{}/api/vApp/vapp-{}/power/action/powerOn".format(self
.url
,
6256 response
= self
.perform_request(req_type
='POST',
6260 if response
.status_code
!= 202:
6261 self
.logger
.error("REST call {} failed reason : {}"\
6262 "status code : {} ".format(poweron_href
,
6264 response
.status_code
))
6265 raise vimconn
.vimconnException("power_on_vapp() : Failed to power on "\
6266 "vApp {}".format(vapp_name
))
6268 poweron_task
= self
.get_task_from_response(response
.content
)