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
178 # Disable warnings from self-signed certificates.
179 requests
.packages
.urllib3
.disable_warnings()
181 if tenant_name
is not None:
182 orgnameandtenant
= tenant_name
.split(":")
183 if len(orgnameandtenant
) == 2:
184 self
.tenant_name
= orgnameandtenant
[1]
185 self
.org_name
= orgnameandtenant
[0]
187 self
.tenant_name
= tenant_name
188 if "orgname" in config
:
189 self
.org_name
= config
['orgname']
192 self
.logger
.setLevel(getattr(logging
, log_level
))
195 self
.admin_user
= config
['admin_username']
196 self
.admin_password
= config
['admin_password']
198 raise vimconn
.vimconnException(message
="Error admin username or admin password is empty.")
201 self
.nsx_manager
= config
['nsx_manager']
202 self
.nsx_user
= config
['nsx_user']
203 self
.nsx_password
= config
['nsx_password']
205 raise vimconn
.vimconnException(message
="Error: nsx manager or nsx user or nsx password is empty in Config")
207 self
.vcenter_ip
= config
.get("vcenter_ip", None)
208 self
.vcenter_port
= config
.get("vcenter_port", None)
209 self
.vcenter_user
= config
.get("vcenter_user", None)
210 self
.vcenter_password
= config
.get("vcenter_password", None)
212 # ############# Stub code for SRIOV #################
214 # self.dvs_name = config['dv_switch_name']
216 # raise vimconn.vimconnException(message="Error: distributed virtaul switch name is empty in Config")
218 # self.vlanID_range = config.get("vlanID_range", None)
224 raise vimconn
.vimconnException('url param can not be NoneType')
226 if not self
.url_admin
: # try to use normal url
227 self
.url_admin
= self
.url
229 logging
.debug("UUID: {} name: {} tenant_id: {} tenant name {}".format(self
.id, self
.org_name
,
230 self
.tenant_id
, self
.tenant_name
))
231 logging
.debug("vcd url {} vcd username: {} vcd password: {}".format(self
.url
, self
.user
, self
.passwd
))
232 logging
.debug("vcd admin username {} vcd admin passowrd {}".format(self
.admin_user
, self
.admin_password
))
234 # initialize organization
235 if self
.user
is not None and self
.passwd
is not None and self
.url
:
236 self
.init_organization()
238 def __getitem__(self
, index
):
241 if index
== 'tenant_id':
242 return self
.tenant_id
243 if index
== 'tenant_name':
244 return self
.tenant_name
247 elif index
== 'org_name':
249 elif index
== 'org_uuid':
251 elif index
== 'user':
253 elif index
== 'passwd':
257 elif index
== 'url_admin':
258 return self
.url_admin
259 elif index
== "config":
262 raise KeyError("Invalid key '%s'" % str(index
))
264 def __setitem__(self
, index
, value
):
267 if index
== 'tenant_id':
268 self
.tenant_id
= value
269 if index
== 'tenant_name':
270 self
.tenant_name
= value
273 elif index
== 'org_name':
274 self
.org_name
= value
275 elif index
== 'org_uuid':
276 self
.org_uuid
= value
277 elif index
== 'user':
279 elif index
== 'passwd':
283 elif index
== 'url_admin':
284 self
.url_admin
= value
286 raise KeyError("Invalid key '%s'" % str(index
))
288 def connect_as_admin(self
):
289 """ Method connect as pvdc admin user to vCloud director.
290 There are certain action that can be done only by provider vdc admin user.
291 Organization creation / provider network creation etc.
294 The return client object that latter can be used to connect to vcloud director as admin for provider vdc
297 self
.logger
.debug("Logging into vCD {} as admin.".format(self
.org_name
))
302 client_as_admin
= Client(host
, verify_ssl_certs
=False)
303 client_as_admin
.set_credentials(BasicLoginCredentials(self
.admin_user
, org
, self
.admin_password
))
304 except Exception as e
:
305 raise vimconn
.vimconnException(
306 "Can't connect to a vCloud director as: {} with exception {}".format(self
.admin_user
, e
))
308 return client_as_admin
311 """ Method connect as normal user to vCloud director.
314 The return client object that latter can be used to connect to vCloud director as admin for VDC
318 self
.logger
.debug("Logging into vCD {} as {} to datacenter {}.".format(self
.org_name
,
322 client
= Client(host
, verify_ssl_certs
=False)
323 client
.set_credentials(BasicLoginCredentials(self
.user
, self
.org_name
, self
.passwd
))
325 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
326 "{} as user: {}".format(self
.org_name
, self
.user
))
330 def init_organization(self
):
331 """ Method initialize organization UUID and VDC parameters.
333 At bare minimum client must provide organization name that present in vCloud director and VDC.
335 The VDC - UUID ( tenant_id) will be initialized at the run time if client didn't call constructor.
336 The Org - UUID will be initialized at the run time if data center present in vCloud director.
339 The return vca object that letter can be used to connect to vcloud direct as admin
341 client
= self
.connect()
343 raise vimconn
.vimconnConnectionException("Failed to connect vCD.")
347 if self
.org_uuid
is None:
348 org_list
= client
.get_org_list()
349 for org
in org_list
.Org
:
350 # we set org UUID at the init phase but we can do it only when we have valid credential.
351 if org
.get('name') == self
.org_name
:
352 self
.org_uuid
= org
.get('href').split('/')[-1]
353 self
.logger
.debug("Setting organization UUID {}".format(self
.org_uuid
))
356 raise vimconn
.vimconnException("Vcloud director organization {} not found".format(self
.org_name
))
358 # if well good we require for org details
359 org_details_dict
= self
.get_org(org_uuid
=self
.org_uuid
)
361 # we have two case if we want to initialize VDC ID or VDC name at run time
362 # tenant_name provided but no tenant id
363 if self
.tenant_id
is None and self
.tenant_name
is not None and 'vdcs' in org_details_dict
:
364 vdcs_dict
= org_details_dict
['vdcs']
365 for vdc
in vdcs_dict
:
366 if vdcs_dict
[vdc
] == self
.tenant_name
:
368 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
372 raise vimconn
.vimconnException("Tenant name indicated but not present in vcloud director.")
373 # case two we have tenant_id but we don't have tenant name so we find and set it.
374 if self
.tenant_id
is not None and self
.tenant_name
is None and 'vdcs' in org_details_dict
:
375 vdcs_dict
= org_details_dict
['vdcs']
376 for vdc
in vdcs_dict
:
377 if vdc
== self
.tenant_id
:
378 self
.tenant_name
= vdcs_dict
[vdc
]
379 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
383 raise vimconn
.vimconnException("Tenant id indicated but not present in vcloud director")
384 self
.logger
.debug("Setting organization uuid {}".format(self
.org_uuid
))
386 self
.logger
.debug("Failed initialize organization UUID for org {}".format(self
.org_name
))
387 self
.logger
.debug(traceback
.format_exc())
390 def new_tenant(self
, tenant_name
=None, tenant_description
=None):
391 """ Method adds a new tenant to VIM with this name.
392 This action requires access to create VDC action in vCloud director.
395 tenant_name is tenant_name to be created.
396 tenant_description not used for this call
399 returns the tenant identifier in UUID format.
400 If action is failed method will throw vimconn.vimconnException method
402 vdc_task
= self
.create_vdc(vdc_name
=tenant_name
)
403 if vdc_task
is not None:
404 vdc_uuid
, value
= vdc_task
.popitem()
405 self
.logger
.info("Created new vdc {} and uuid: {}".format(tenant_name
, vdc_uuid
))
408 raise vimconn
.vimconnException("Failed create tenant {}".format(tenant_name
))
410 def delete_tenant(self
, tenant_id
=None):
411 """ Delete a tenant from VIM
413 tenant_id is tenant_id to be deleted.
416 returns the tenant identifier in UUID format.
417 If action is failed method will throw exception
419 vca
= self
.connect_as_admin()
421 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
423 if tenant_id
is not None:
426 url_list
= [self
.url
, '/api/vdc/', tenant_id
]
427 orgvdc_herf
= ''.join(url_list
)
429 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
430 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
431 response
= self
.perform_request(req_type
='GET',
435 if response
.status_code
!= requests
.codes
.ok
:
436 self
.logger
.debug("delete_tenant():GET REST API call {} failed. "\
437 "Return status code {}".format(orgvdc_herf
,
438 response
.status_code
))
439 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
441 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
442 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
444 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
445 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
446 vdc_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
447 vdc_remove_href
= vdc_remove_href
+ '?recursive=true&force=true'
449 response
= self
.perform_request(req_type
='DELETE',
453 if response
.status_code
== 202:
457 self
.logger
.debug("delete_tenant(): DELETE REST API call {} failed. "\
458 "Return status code {}".format(vdc_remove_href
,
459 response
.status_code
))
460 raise vimconn
.vimconnException("Fail to delete tenant with ID {}".format(tenant_id
))
462 self
.logger
.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id
))
463 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
466 def get_tenant_list(self
, filter_dict
={}):
467 """Obtain tenants of VIM
468 filter_dict can contain the following keys:
469 name: filter by tenant name
470 id: filter by tenant uuid/id
472 Returns the tenant list of dictionaries:
473 [{'name':'<name>, 'id':'<id>, ...}, ...]
476 org_dict
= self
.get_org(self
.org_uuid
)
477 vdcs_dict
= org_dict
['vdcs']
482 entry
= {'name': vdcs_dict
[k
], 'id': k
}
483 # if caller didn't specify dictionary we return all tenants.
484 if filter_dict
is not None and filter_dict
:
485 filtered_entry
= entry
.copy()
486 filtered_dict
= set(entry
.keys()) - set(filter_dict
)
487 for unwanted_key
in filtered_dict
: del entry
[unwanted_key
]
488 if filter_dict
== entry
:
489 vdclist
.append(filtered_entry
)
491 vdclist
.append(entry
)
493 self
.logger
.debug("Error in get_tenant_list()")
494 self
.logger
.debug(traceback
.format_exc())
495 raise vimconn
.vimconnException("Incorrect state. {}")
499 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False):
500 """Adds a tenant network to VIM
502 net_type can be 'bridge','data'.'ptp'.
503 ip_profile is a dict containing the IP parameters of the network
505 Returns the network identifier"""
507 self
.logger
.debug("new_network tenant {} net_type {} ip_profile {} shared {}"
508 .format(net_name
, net_type
, ip_profile
, shared
))
514 # ############# Stub code for SRIOV #################
515 # if net_type == "data" or net_type == "ptp":
516 # if self.config.get('dv_switch_name') == None:
517 # raise vimconn.vimconnConflictException("You must provide 'dv_switch_name' at config value")
518 # network_uuid = self.create_dvPort_group(net_name)
520 network_uuid
= self
.create_network(network_name
=net_name
, net_type
=net_type
,
521 ip_profile
=ip_profile
, isshared
=isshared
)
522 if network_uuid
is not None:
525 raise vimconn
.vimconnUnexpectedResponse("Failed create a new network {}".format(net_name
))
527 def get_vcd_network_list(self
):
528 """ Method available organization for a logged in tenant
531 The return vca object that letter can be used to connect to vcloud direct as admin
534 self
.logger
.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
536 if not self
.tenant_name
:
537 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
539 org
, vdc
= self
.get_vdc_details()
541 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self
.tenant_name
))
543 vdc_uuid
= vdc
.get('id').split(":")[3]
544 if self
.client
._session
:
545 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
546 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
547 response
= self
.perform_request(req_type
='GET',
550 if response
.status_code
!= 200:
551 self
.logger
.error("Failed to get vdc content")
552 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
554 content
= XmlElementTree
.fromstring(response
.content
)
559 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
561 response
= self
.perform_request(req_type
='GET',
565 if response
.status_code
!= 200:
566 self
.logger
.error("Failed to get network content")
567 raise vimconn
.vimconnNotFoundException("Failed to get network content")
569 net_details
= XmlElementTree
.fromstring(response
.content
)
572 net_uuid
= net_details
.get('id').split(":")
573 if len(net_uuid
) != 4:
576 net_uuid
= net_uuid
[3]
578 self
.logger
.debug("Adding {} to a list vcd id {} network {}".format(net_uuid
,
580 net_details
.get('name')))
581 filter_dict
["name"] = net_details
.get('name')
582 filter_dict
["id"] = net_uuid
583 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
587 filter_dict
["shared"] = shared
588 filter_dict
["tenant_id"] = vdc_uuid
589 if int(net_details
.get('status')) == 1:
590 filter_dict
["admin_state_up"] = True
592 filter_dict
["admin_state_up"] = False
593 filter_dict
["status"] = "ACTIVE"
594 filter_dict
["type"] = "bridge"
595 network_list
.append(filter_dict
)
596 self
.logger
.debug("get_vcd_network_list adding entry {}".format(filter_dict
))
598 self
.logger
.debug("Error in get_vcd_network_list", exc_info
=True)
601 self
.logger
.debug("get_vcd_network_list returning {}".format(network_list
))
604 def get_network_list(self
, filter_dict
={}):
605 """Obtain tenant networks of VIM
607 name: network name OR/AND
608 id: network uuid OR/AND
609 shared: boolean OR/AND
610 tenant_id: tenant OR/AND
611 admin_state_up: boolean
614 [{key : value , key : value}]
616 Returns the network list of dictionaries:
617 [{<the fields at Filter_dict plus some VIM specific>}, ...]
621 self
.logger
.debug("get_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
623 if not self
.tenant_name
:
624 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
626 org
, vdc
= self
.get_vdc_details()
628 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}.".format(self
.tenant_name
))
631 vdcid
= vdc
.get('id').split(":")[3]
633 if self
.client
._session
:
634 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
635 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
636 response
= self
.perform_request(req_type
='GET',
639 if response
.status_code
!= 200:
640 self
.logger
.error("Failed to get vdc content")
641 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
643 content
= XmlElementTree
.fromstring(response
.content
)
647 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
649 response
= self
.perform_request(req_type
='GET',
653 if response
.status_code
!= 200:
654 self
.logger
.error("Failed to get network content")
655 raise vimconn
.vimconnNotFoundException("Failed to get network content")
657 net_details
= XmlElementTree
.fromstring(response
.content
)
660 net_uuid
= net_details
.get('id').split(":")
661 if len(net_uuid
) != 4:
664 net_uuid
= net_uuid
[3]
666 self
.logger
.debug("Adding {} to a list vcd id {} network {}".format(net_uuid
,
668 net_details
.get('name')))
669 filter_entry
["name"] = net_details
.get('name')
670 filter_entry
["id"] = net_uuid
671 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
675 filter_entry
["shared"] = shared
676 filter_entry
["tenant_id"] = vdcid
677 if int(net_details
.get('status')) == 1:
678 filter_entry
["admin_state_up"] = True
680 filter_entry
["admin_state_up"] = False
681 filter_entry
["status"] = "ACTIVE"
682 filter_entry
["type"] = "bridge"
683 filtered_entry
= filter_entry
.copy()
685 if filter_dict
is not None and filter_dict
:
686 # we remove all the key : value we don't care and match only
688 filtered_dict
= set(filter_entry
.keys()) - set(filter_dict
)
689 for unwanted_key
in filtered_dict
: del filter_entry
[unwanted_key
]
690 if filter_dict
== filter_entry
:
691 network_list
.append(filtered_entry
)
693 network_list
.append(filtered_entry
)
694 except Exception as e
:
695 self
.logger
.debug("Error in get_network_list",exc_info
=True)
696 if isinstance(e
, vimconn
.vimconnException
):
699 raise vimconn
.vimconnNotFoundException("Failed : Networks list not found {} ".format(e
))
701 self
.logger
.debug("Returning {}".format(network_list
))
704 def get_network(self
, net_id
):
705 """Method obtains network details of net_id VIM network
706 Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
709 org
, vdc
= self
.get_vdc_details()
710 vdc_id
= vdc
.get('id').split(":")[3]
711 if self
.client
._session
:
712 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
713 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
714 response
= self
.perform_request(req_type
='GET',
717 if response
.status_code
!= 200:
718 self
.logger
.error("Failed to get vdc content")
719 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
721 content
= XmlElementTree
.fromstring(response
.content
)
726 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
728 response
= self
.perform_request(req_type
='GET',
732 if response
.status_code
!= 200:
733 self
.logger
.error("Failed to get network content")
734 raise vimconn
.vimconnNotFoundException("Failed to get network content")
736 net_details
= XmlElementTree
.fromstring(response
.content
)
738 vdc_network_id
= net_details
.get('id').split(":")
739 if len(vdc_network_id
) == 4 and vdc_network_id
[3] == net_id
:
740 filter_dict
["name"] = net_details
.get('name')
741 filter_dict
["id"] = vdc_network_id
[3]
742 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
746 filter_dict
["shared"] = shared
747 filter_dict
["tenant_id"] = vdc_id
748 if int(net_details
.get('status')) == 1:
749 filter_dict
["admin_state_up"] = True
751 filter_dict
["admin_state_up"] = False
752 filter_dict
["status"] = "ACTIVE"
753 filter_dict
["type"] = "bridge"
754 self
.logger
.debug("Returning {}".format(filter_dict
))
757 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
758 except Exception as e
:
759 self
.logger
.debug("Error in get_network")
760 self
.logger
.debug(traceback
.format_exc())
761 if isinstance(e
, vimconn
.vimconnException
):
764 raise vimconn
.vimconnNotFoundException("Failed : Network not found {} ".format(e
))
768 def delete_network(self
, net_id
):
770 Method Deletes a tenant network from VIM, provide the network id.
772 Returns the network identifier or raise an exception
775 # ############# Stub code for SRIOV #################
776 # dvport_group = self.get_dvport_group(net_id)
779 # status = self.destroy_dvport_group(net_id)
781 # # Remove vlanID from persistent info
782 # if net_id in self.persistent_info["used_vlanIDs"]:
783 # del self.persistent_info["used_vlanIDs"][net_id]
787 vcd_network
= self
.get_vcd_network(network_uuid
=net_id
)
788 if vcd_network
is not None and vcd_network
:
789 if self
.delete_network_action(network_uuid
=net_id
):
792 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
794 def refresh_nets_status(self
, net_list
):
795 """Get the status of the networks
796 Params: the list of network identifiers
797 Returns a dictionary with:
798 net_id: #VIM id of this network
799 status: #Mandatory. Text with one of:
800 # DELETED (not found at vim)
801 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
802 # OTHER (Vim reported other status not understood)
803 # ERROR (VIM indicates an ERROR status)
804 # ACTIVE, INACTIVE, DOWN (admin down),
805 # BUILD (on building process)
807 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
808 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
816 vcd_network
= self
.get_vcd_network(network_uuid
=net
)
817 if vcd_network
is not None and vcd_network
:
818 if vcd_network
['status'] == '1':
824 errormsg
= 'Network not found.'
826 dict_entry
[net
] = {'status': status
, 'error_msg': errormsg
,
827 'vim_info': yaml
.safe_dump(vcd_network
)}
829 self
.logger
.debug("Error in refresh_nets_status")
830 self
.logger
.debug(traceback
.format_exc())
834 def get_flavor(self
, flavor_id
):
835 """Obtain flavor details from the VIM
836 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
838 if flavor_id
not in vimconnector
.flavorlist
:
839 raise vimconn
.vimconnNotFoundException("Flavor not found.")
840 return vimconnector
.flavorlist
[flavor_id
]
842 def new_flavor(self
, flavor_data
):
843 """Adds a tenant flavor to VIM
844 flavor_data contains a dictionary with information, keys:
846 ram: memory (cloud type) in MBytes
847 vpcus: cpus (cloud type)
848 extended: EPA parameters
849 - numas: #items requested in same NUMA
850 memory: number of 1G huge pages memory
851 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
852 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
853 - name: interface name
854 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
855 bandwidth: X Gbps; requested guarantee bandwidth
856 vpci: requested virtual PCI address
860 Returns the flavor identifier"""
862 # generate a new uuid put to internal dict and return it.
863 self
.logger
.debug("Creating new flavor - flavor_data: {}".format(flavor_data
))
864 new_flavor
=flavor_data
865 ram
= flavor_data
.get(FLAVOR_RAM_KEY
, 1024)
866 cpu
= flavor_data
.get(FLAVOR_VCPUS_KEY
, 1)
867 disk
= flavor_data
.get(FLAVOR_DISK_KEY
, 0)
869 if not isinstance(ram
, int):
870 raise vimconn
.vimconnException("Non-integer value for ram")
871 elif not isinstance(cpu
, int):
872 raise vimconn
.vimconnException("Non-integer value for cpu")
873 elif not isinstance(disk
, int):
874 raise vimconn
.vimconnException("Non-integer value for disk")
876 extended_flv
= flavor_data
.get("extended")
878 numas
=extended_flv
.get("numas")
881 #overwrite ram and vcpus
882 ram
= numa
['memory']*1024
883 if 'paired-threads' in numa
:
884 cpu
= numa
['paired-threads']*2
885 elif 'cores' in numa
:
887 elif 'threads' in numa
:
888 cpu
= numa
['threads']
890 new_flavor
[FLAVOR_RAM_KEY
] = ram
891 new_flavor
[FLAVOR_VCPUS_KEY
] = cpu
892 new_flavor
[FLAVOR_DISK_KEY
] = disk
893 # generate a new uuid put to internal dict and return it.
894 flavor_id
= uuid
.uuid4()
895 vimconnector
.flavorlist
[str(flavor_id
)] = new_flavor
896 self
.logger
.debug("Created flavor - {} : {}".format(flavor_id
, new_flavor
))
898 return str(flavor_id
)
900 def delete_flavor(self
, flavor_id
):
901 """Deletes a tenant flavor from VIM identify by its id
903 Returns the used id or raise an exception
905 if flavor_id
not in vimconnector
.flavorlist
:
906 raise vimconn
.vimconnNotFoundException("Flavor not found.")
908 vimconnector
.flavorlist
.pop(flavor_id
, None)
911 def new_image(self
, image_dict
):
913 Adds a tenant image to VIM
915 200, image-id if the image is created
916 <0, message if there is an error
919 return self
.get_image_id_from_path(image_dict
['location'])
921 def delete_image(self
, image_id
):
923 Deletes a tenant image from VIM
925 image_id is ID of Image to be deleted
927 returns the image identifier in UUID format or raises an exception on error
929 conn
= self
.connect_as_admin()
931 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
932 # Get Catalog details
933 url_list
= [self
.url
, '/api/catalog/', image_id
]
934 catalog_herf
= ''.join(url_list
)
936 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
937 'x-vcloud-authorization': conn
._session
.headers
['x-vcloud-authorization']}
939 response
= self
.perform_request(req_type
='GET',
943 if response
.status_code
!= requests
.codes
.ok
:
944 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
945 "Return status code {}".format(catalog_herf
,
946 response
.status_code
))
947 raise vimconn
.vimconnNotFoundException("Fail to get image {}".format(image_id
))
949 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
950 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
952 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
953 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
955 catalogItems_section
= lxmlroot_respond
.find("xmlns:CatalogItems",namespaces
)
956 catalogItems
= catalogItems_section
.iterfind("xmlns:CatalogItem",namespaces
)
957 for catalogItem
in catalogItems
:
958 catalogItem_href
= catalogItem
.attrib
['href']
960 response
= self
.perform_request(req_type
='GET',
961 url
=catalogItem_href
,
964 if response
.status_code
!= requests
.codes
.ok
:
965 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
966 "Return status code {}".format(catalog_herf
,
967 response
.status_code
))
968 raise vimconn
.vimconnNotFoundException("Fail to get catalogItem {} for catalog {}".format(
972 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
973 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
975 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
976 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
977 catalogitem_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
980 response
= self
.perform_request(req_type
='DELETE',
981 url
=catalogitem_remove_href
,
983 if response
.status_code
== requests
.codes
.no_content
:
984 self
.logger
.debug("Deleted Catalog item {}".format(catalogItem
))
986 raise vimconn
.vimconnException("Fail to delete Catalog Item {}".format(catalogItem
))
989 url_list
= [self
.url
, '/api/admin/catalog/', image_id
]
990 catalog_remove_herf
= ''.join(url_list
)
991 response
= self
.perform_request(req_type
='DELETE',
992 url
=catalog_remove_herf
,
995 if response
.status_code
== requests
.codes
.no_content
:
996 self
.logger
.debug("Deleted Catalog {}".format(image_id
))
999 raise vimconn
.vimconnException("Fail to delete Catalog {}".format(image_id
))
1002 def catalog_exists(self
, catalog_name
, catalogs
):
1005 :param catalog_name:
1009 for catalog
in catalogs
:
1010 if catalog
['name'] == catalog_name
:
1014 def create_vimcatalog(self
, vca
=None, catalog_name
=None):
1015 """ Create new catalog entry in vCloud director.
1018 vca: vCloud director.
1019 catalog_name catalog that client wish to create. Note no validation done for a name.
1020 Client must make sure that provide valid string representation.
1022 Return (bool) True if catalog created.
1026 result
= vca
.create_catalog(catalog_name
, catalog_name
)
1027 if result
is not None:
1029 catalogs
= vca
.list_catalogs()
1032 return self
.catalog_exists(catalog_name
, catalogs
)
1034 # noinspection PyIncorrectDocstring
1035 def upload_ovf(self
, vca
=None, catalog_name
=None, image_name
=None, media_file_name
=None,
1036 description
='', progress
=False, chunk_bytes
=128 * 1024):
1038 Uploads a OVF file to a vCloud catalog
1045 :param catalog_name: (str): The name of the catalog to upload the media.
1046 :param media_file_name: (str): The name of the local media file to upload.
1047 :return: (bool) True if the media file was successfully uploaded, false otherwise.
1049 os
.path
.isfile(media_file_name
)
1050 statinfo
= os
.stat(media_file_name
)
1052 # find a catalog entry where we upload OVF.
1053 # create vApp Template and check the status if vCD able to read OVF it will respond with appropirate
1055 # if VCD can parse OVF we upload VMDK file
1057 for catalog
in vca
.list_catalogs():
1058 if catalog_name
!= catalog
['name']:
1060 catalog_href
= "{}/api/catalog/{}/action/upload".format(self
.url
, catalog
['id'])
1062 <UploadVAppTemplateParams name="{}" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>{} vApp Template</Description></UploadVAppTemplateParams>
1063 """.format(catalog_name
, description
)
1066 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1067 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1068 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
1070 response
= self
.perform_request(req_type
='POST',
1075 if response
.status_code
== requests
.codes
.created
:
1076 catalogItem
= XmlElementTree
.fromstring(response
.content
)
1077 entity
= [child
for child
in catalogItem
if
1078 child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
1079 href
= entity
.get('href')
1082 response
= self
.perform_request(req_type
='GET',
1086 if response
.status_code
== requests
.codes
.ok
:
1087 headers
['Content-Type'] = 'Content-Type text/xml'
1088 result
= re
.search('rel="upload:default"\shref="(.*?\/descriptor.ovf)"',response
.content
)
1090 transfer_href
= result
.group(1)
1092 response
= self
.perform_request(req_type
='PUT',
1095 data
=open(media_file_name
, 'rb'))
1096 if response
.status_code
!= requests
.codes
.ok
:
1098 "Failed create vApp template for catalog name {} and image {}".format(catalog_name
,
1102 # TODO fix this with aync block
1105 self
.logger
.debug("vApp template for catalog name {} and image {}".format(catalog_name
, media_file_name
))
1107 # uploading VMDK file
1108 # check status of OVF upload and upload remaining files.
1109 response
= self
.perform_request(req_type
='GET',
1113 if response
.status_code
== requests
.codes
.ok
:
1114 result
= re
.search('rel="upload:default"\s*href="(.*?vmdk)"',response
.content
)
1116 link_href
= result
.group(1)
1117 # we skip ovf since it already uploaded.
1118 if 'ovf' in link_href
:
1120 # The OVF file and VMDK must be in a same directory
1121 head
, tail
= os
.path
.split(media_file_name
)
1122 file_vmdk
= head
+ '/' + link_href
.split("/")[-1]
1123 if not os
.path
.isfile(file_vmdk
):
1125 statinfo
= os
.stat(file_vmdk
)
1126 if statinfo
.st_size
== 0:
1128 hrefvmdk
= link_href
1131 widgets
= ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
1132 FileTransferSpeed()]
1133 progress_bar
= ProgressBar(widgets
=widgets
, maxval
=statinfo
.st_size
).start()
1135 bytes_transferred
= 0
1136 f
= open(file_vmdk
, 'rb')
1137 while bytes_transferred
< statinfo
.st_size
:
1138 my_bytes
= f
.read(chunk_bytes
)
1139 if len(my_bytes
) <= chunk_bytes
:
1140 headers
['Content-Range'] = 'bytes %s-%s/%s' % (
1141 bytes_transferred
, len(my_bytes
) - 1, statinfo
.st_size
)
1142 headers
['Content-Length'] = str(len(my_bytes
))
1143 response
= requests
.put(url
=hrefvmdk
,
1147 if response
.status_code
== requests
.codes
.ok
:
1148 bytes_transferred
+= len(my_bytes
)
1150 progress_bar
.update(bytes_transferred
)
1153 'file upload failed with error: [%s] %s' % (response
.status_code
,
1160 progress_bar
.finish()
1164 self
.logger
.debug("Failed retrieve vApp template for catalog name {} for OVF {}".
1165 format(catalog_name
, media_file_name
))
1167 except Exception as exp
:
1168 self
.logger
.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1169 .format(catalog_name
,media_file_name
, exp
))
1170 raise vimconn
.vimconnException(
1171 "Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1172 .format(catalog_name
,media_file_name
, exp
))
1174 self
.logger
.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name
, media_file_name
))
1177 def upload_vimimage(self
, vca
=None, catalog_name
=None, media_name
=None, medial_file_name
=None, progress
=False):
1178 """Upload media file"""
1179 # TODO add named parameters for readability
1181 return self
.upload_ovf(vca
=vca
, catalog_name
=catalog_name
, image_name
=media_name
.split(".")[0],
1182 media_file_name
=medial_file_name
, description
='medial_file_name', progress
=progress
)
1184 def validate_uuid4(self
, uuid_string
=None):
1185 """ Method validate correct format of UUID.
1187 Return: true if string represent valid uuid
1190 val
= uuid
.UUID(uuid_string
, version
=4)
1195 def get_catalogid(self
, catalog_name
=None, catalogs
=None):
1196 """ Method check catalog and return catalog ID in UUID format.
1199 catalog_name: catalog name as string
1200 catalogs: list of catalogs.
1202 Return: catalogs uuid
1205 for catalog
in catalogs
:
1206 if catalog
['name'] == catalog_name
:
1207 catalog_id
= catalog
['id']
1211 def get_catalogbyid(self
, catalog_uuid
=None, catalogs
=None):
1212 """ Method check catalog and return catalog name lookup done by catalog UUID.
1215 catalog_name: catalog name as string
1216 catalogs: list of catalogs.
1218 Return: catalogs name or None
1221 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1224 for catalog
in catalogs
:
1225 catalog_id
= catalog
.get('id')
1226 if catalog_id
== catalog_uuid
:
1227 return catalog
.get('name')
1230 def get_catalog_obj(self
, catalog_uuid
=None, catalogs
=None):
1231 """ Method check catalog and return catalog name lookup done by catalog UUID.
1234 catalog_name: catalog name as string
1235 catalogs: list of catalogs.
1237 Return: catalogs name or None
1240 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1243 for catalog
in catalogs
:
1244 catalog_id
= catalog
.get('id')
1245 if catalog_id
== catalog_uuid
:
1249 def get_image_id_from_path(self
, path
=None, progress
=False):
1250 """ Method upload OVF image to vCloud director.
1252 Each OVF image represented as single catalog entry in vcloud director.
1253 The method check for existing catalog entry. The check done by file name without file extension.
1255 if given catalog name already present method will respond with existing catalog uuid otherwise
1256 it will create new catalog entry and upload OVF file to newly created catalog.
1258 If method can't create catalog entry or upload a file it will throw exception.
1260 Method accept boolean flag progress that will output progress bar. It useful method
1261 for standalone upload use case. In case to test large file upload.
1264 path: - valid path to OVF file.
1265 progress - boolean progress bar show progress bar.
1267 Return: if image uploaded correct method will provide image catalog UUID.
1271 raise vimconn
.vimconnException("Image path can't be None.")
1273 if not os
.path
.isfile(path
):
1274 raise vimconn
.vimconnException("Can't read file. File not found.")
1276 if not os
.access(path
, os
.R_OK
):
1277 raise vimconn
.vimconnException("Can't read file. Check file permission to read.")
1279 self
.logger
.debug("get_image_id_from_path() client requesting {} ".format(path
))
1281 dirpath
, filename
= os
.path
.split(path
)
1282 flname
, file_extension
= os
.path
.splitext(path
)
1283 if file_extension
!= '.ovf':
1284 self
.logger
.debug("Wrong file extension {} connector support only OVF container.".format(file_extension
))
1285 raise vimconn
.vimconnException("Wrong container. vCloud director supports only OVF.")
1287 catalog_name
= os
.path
.splitext(filename
)[0]
1288 catalog_md5_name
= hashlib
.md5(path
).hexdigest()
1289 self
.logger
.debug("File name {} Catalog Name {} file path {} "
1290 "vdc catalog name {}".format(filename
, catalog_name
, path
, catalog_md5_name
))
1293 org
,vdc
= self
.get_vdc_details()
1294 catalogs
= org
.list_catalogs()
1295 except Exception as exp
:
1296 self
.logger
.debug("Failed get catalogs() with Exception {} ".format(exp
))
1297 raise vimconn
.vimconnException("Failed get catalogs() with Exception {} ".format(exp
))
1299 if len(catalogs
) == 0:
1300 self
.logger
.info("Creating a new catalog entry {} in vcloud director".format(catalog_name
))
1301 result
= self
.create_vimcatalog(org
, catalog_md5_name
)
1303 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1305 result
= self
.upload_vimimage(vca
=org
, catalog_name
=catalog_md5_name
,
1306 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1308 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_name
))
1309 return self
.get_catalogid(catalog_name
, catalogs
)
1311 for catalog
in catalogs
:
1312 # search for existing catalog if we find same name we return ID
1313 # TODO optimize this
1314 if catalog
['name'] == catalog_md5_name
:
1315 self
.logger
.debug("Found existing catalog entry for {} "
1316 "catalog id {}".format(catalog_name
,
1317 self
.get_catalogid(catalog_md5_name
, catalogs
)))
1318 return self
.get_catalogid(catalog_md5_name
, catalogs
)
1320 # if we didn't find existing catalog we create a new one and upload image.
1321 self
.logger
.debug("Creating new catalog entry {} - {}".format(catalog_name
, catalog_md5_name
))
1322 result
= self
.create_vimcatalog(org
, catalog_md5_name
)
1324 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1326 result
= self
.upload_vimimage(vca
=org
, catalog_name
=catalog_md5_name
,
1327 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1329 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_md5_name
))
1331 return self
.get_catalogid(catalog_md5_name
, org
.list_catalogs())
1333 def get_image_list(self
, filter_dict
={}):
1334 '''Obtain tenant images from VIM
1338 checksum: image checksum
1339 location: image path
1340 Returns the image list of dictionaries:
1341 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1346 org
, vdc
= self
.get_vdc_details()
1348 catalogs
= org
.list_catalogs()
1349 if len(catalogs
) == 0:
1352 for catalog
in catalogs
:
1353 catalog_uuid
= catalog
.get('id')
1354 name
= catalog
.get('name')
1356 if filter_dict
.get("name") and filter_dict
["name"] != name
:
1358 if filter_dict
.get("id") and filter_dict
["id"] != catalog_uuid
:
1360 filtered_dict
["name"] = name
1361 filtered_dict
["id"] = catalog_uuid
1362 image_list
.append(filtered_dict
)
1364 self
.logger
.debug("List of already created catalog items: {}".format(image_list
))
1366 except Exception as exp
:
1367 raise vimconn
.vimconnException("Exception occured while retriving catalog items {}".format(exp
))
1369 def get_vappid(self
, vdc
=None, vapp_name
=None):
1370 """ Method takes vdc object and vApp name and returns vapp uuid or None
1373 vdc: The VDC object.
1374 vapp_name: is application vappp name identifier
1377 The return vApp name otherwise None
1379 if vdc
is None or vapp_name
is None:
1381 # UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
1383 refs
= filter(lambda ref
: ref
.name
== vapp_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1384 vdc
.ResourceEntities
.ResourceEntity
)
1386 #refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
1387 # if ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
1389 return refs
[0].href
.split("vapp")[1][1:]
1390 except Exception as e
:
1391 self
.logger
.exception(e
)
1395 def check_vapp(self
, vdc
=None, vapp_uuid
=None):
1396 """ Method Method returns True or False if vapp deployed in vCloud director
1399 vca: Connector to VCA
1400 vdc: The VDC object.
1401 vappid: vappid is application identifier
1404 The return True if vApp deployed
1409 refs
= filter(lambda ref
:
1410 ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1411 vdc
.ResourceEntities
.ResourceEntity
)
1413 #refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
1414 # if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
1416 vappid
= ref
.href
.split("vapp")[1][1:]
1417 # find vapp with respected vapp uuid
1418 if vappid
== vapp_uuid
:
1420 except Exception as e
:
1421 self
.logger
.exception(e
)
1425 def get_namebyvappid(self
, vapp_uuid
=None):
1426 """Method returns vApp name from vCD and lookup done by vapp_id.
1429 vapp_uuid: vappid is application identifier
1432 The return vApp name otherwise None
1435 if self
.client
and vapp_uuid
:
1436 vapp_call
= "{}/api/vApp/vapp-{}".format(self
.url
, vapp_uuid
)
1437 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1438 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1440 response
= self
.perform_request(req_type
='GET',
1443 #Retry login if session expired & retry sending request
1444 if response
.status_code
== 403:
1445 response
= self
.retry_rest('GET', vapp_call
)
1447 tree
= XmlElementTree
.fromstring(response
.content
)
1448 return tree
.attrib
['name']
1449 except Exception as e
:
1450 self
.logger
.exception(e
)
1454 def new_vminstance(self
, name
=None, description
="", start
=False, image_id
=None, flavor_id
=None, net_list
=[],
1455 cloud_config
=None, disk_list
=None, availability_zone_index
=None, availability_zone_list
=None):
1456 """Adds a VM instance to VIM
1458 'start': (boolean) indicates if VM must start or created in pause mode.
1459 'image_id','flavor_id': image and flavor VIM id to use for the VM
1460 'net_list': list of interfaces, each one is a dictionary with:
1461 'name': (optional) name for the interface.
1462 'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
1463 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
1464 'model': (optional and only have sense for type==virtual) interface model: virtio, e2000, ...
1465 'mac_address': (optional) mac address to assign to this interface
1466 #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
1467 the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
1468 'type': (mandatory) can be one of:
1469 'virtual', in this case always connected to a network of type 'net_type=bridge'
1470 'PCI-PASSTHROUGH' or 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
1471 can created unconnected
1472 'SR-IOV' or 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
1473 'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
1474 are allocated on the same physical NIC
1475 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS
1476 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing
1477 or True, it must apply the default VIM behaviour
1478 After execution the method will add the key:
1479 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this
1480 interface. 'net_list' is modified
1481 'cloud_config': (optional) dictionary with:
1482 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1483 'users': (optional) list of users to be inserted, each item is a dict with:
1484 'name': (mandatory) user name,
1485 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1486 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
1487 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
1488 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1489 'dest': (mandatory) string with the destination absolute path
1490 'encoding': (optional, by default text). Can be one of:
1491 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1492 'content' (mandatory): string with the content of the file
1493 'permissions': (optional) string with file permissions, typically octal notation '0644'
1494 'owner': (optional) file owner, string with the format 'owner:group'
1495 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1496 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1497 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1498 'size': (mandatory) string with the size of the disk in GB
1499 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1500 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1501 availability_zone_index is None
1502 Returns a tuple with the instance identifier and created_items or raises an exception on error
1503 created_items can be None or a dictionary where this method can include key-values that will be passed to
1504 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1505 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1508 self
.logger
.info("Creating new instance for entry {}".format(name
))
1509 self
.logger
.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {} disk_list {}".format(
1510 description
, start
, image_id
, flavor_id
, net_list
, cloud_config
, disk_list
))
1512 #new vm name = vmname + tenant_id + uuid
1513 new_vm_name
= [name
, '-', str(uuid
.uuid4())]
1514 vmname_andid
= ''.join(new_vm_name
)
1516 for net
in net_list
:
1517 if net
['type'] == "SR-IOV" or net
['type'] == "PCI-PASSTHROUGH":
1518 raise vimconn
.vimconnNotSupportedException(
1519 "Current vCD version does not support type : {}".format(net
['type']))
1521 if len(net_list
) > 10:
1522 raise vimconn
.vimconnNotSupportedException(
1523 "The VM hardware versions 7 and above support upto 10 NICs only")
1525 # if vm already deployed we return existing uuid
1526 # we check for presence of VDC, Catalog entry and Flavor.
1527 org
, vdc
= self
.get_vdc_details()
1529 raise vimconn
.vimconnNotFoundException(
1530 "new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name
))
1531 catalogs
= org
.list_catalogs()
1532 if catalogs
is None:
1533 #Retry once, if failed by refreshing token
1535 org
= Org(self
.client
, resource
=self
.client
.get_org())
1536 catalogs
= org
.list_catalogs()
1537 if catalogs
is None:
1538 raise vimconn
.vimconnNotFoundException(
1539 "new_vminstance(): Failed create vApp {}: (Failed retrieve catalogs list)".format(name
))
1541 catalog_hash_name
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1542 if catalog_hash_name
:
1543 self
.logger
.info("Found catalog entry {} for image id {}".format(catalog_hash_name
, image_id
))
1545 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1546 "(Failed retrieve catalog information {})".format(name
, image_id
))
1549 # Set vCPU and Memory based on flavor.
1555 if flavor_id
is not None:
1556 if flavor_id
not in vimconnector
.flavorlist
:
1557 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1558 "Failed retrieve flavor information "
1559 "flavor id {}".format(name
, flavor_id
))
1562 flavor
= vimconnector
.flavorlist
[flavor_id
]
1563 vm_cpus
= flavor
[FLAVOR_VCPUS_KEY
]
1564 vm_memory
= flavor
[FLAVOR_RAM_KEY
]
1565 vm_disk
= flavor
[FLAVOR_DISK_KEY
]
1566 extended
= flavor
.get("extended", None)
1568 numas
=extended
.get("numas", None)
1570 except Exception as exp
:
1571 raise vimconn
.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id
, exp
))
1573 # image upload creates template name as catalog name space Template.
1574 templateName
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1579 # client must provide at least one entry in net_list if not we report error
1580 #If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
1581 #If no mgmt, then the 1st NN in netlist is considered as primary net.
1583 primary_netname
= None
1584 network_mode
= 'bridged'
1585 if net_list
is not None and len(net_list
) > 0:
1586 for net
in net_list
:
1587 if 'use' in net
and net
['use'] == 'mgmt' and not primary_net
:
1589 if primary_net
is None:
1590 primary_net
= net_list
[0]
1593 primary_net_id
= primary_net
['net_id']
1594 network_dict
= self
.get_vcd_network(network_uuid
=primary_net_id
)
1595 if 'name' in network_dict
:
1596 primary_netname
= network_dict
['name']
1599 raise vimconn
.vimconnException("Corrupted flavor. {}".format(primary_net
))
1601 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name
))
1603 # use: 'data', 'bridge', 'mgmt'
1604 # create vApp. Set vcpu and ram based on flavor id.
1606 vdc_obj
= VDC(self
.client
, resource
=org
.get_vdc(self
.tenant_name
))
1608 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed to get VDC object")
1611 items
= org
.get_catalog_item(catalog_hash_name
, catalog_hash_name
)
1612 catalog_items
= [items
.attrib
]
1614 if len(catalog_items
) == 1:
1616 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1617 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1619 response
= self
.perform_request(req_type
='GET',
1620 url
=catalog_items
[0].get('href'),
1622 catalogItem
= XmlElementTree
.fromstring(response
.content
)
1623 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
1624 vapp_tempalte_href
= entity
.get("href")
1626 response
= self
.perform_request(req_type
='GET',
1627 url
=vapp_tempalte_href
,
1629 if response
.status_code
!= requests
.codes
.ok
:
1630 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vapp_tempalte_href
,
1631 response
.status_code
))
1633 result
= (response
.content
).replace("\n"," ")
1635 src
= re
.search('<Vm goldMaster="false"\sstatus="\d+"\sname="(.*?)"\s'
1636 'id="(\w+:\w+:vm:.*?)"\shref="(.*?)"\s'
1637 'type="application/vnd\.vmware\.vcloud\.vm\+xml',result
)
1639 vm_name
= src
.group(1)
1640 vm_id
= src
.group(2)
1641 vm_href
= src
.group(3)
1643 cpus
= re
.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
1644 memory_mb
= re
.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
1645 cores
= re
.search('<vmw:CoresPerSocket ovf:required.*?>(\d+)</vmw:CoresPerSocket>',result
).group(1)
1647 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'
1648 vdc_id
= vdc
.get('id').split(':')[-1]
1649 instantiate_vapp_href
= "{}/api/vdc/{}/action/instantiateVAppTemplate".format(self
.url
,
1651 data
= """<?xml version="1.0" encoding="UTF-8"?>
1652 <InstantiateVAppTemplateParams
1653 xmlns="http://www.vmware.com/vcloud/v1.5"
1657 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1658 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1">
1659 <Description>Vapp instantiation</Description>
1660 <InstantiationParams>
1661 <NetworkConfigSection>
1662 <ovf:Info>Configuration parameters for logical networks</ovf:Info>
1663 <NetworkConfig networkName="None">
1665 <ParentNetwork href=""/>
1666 <FenceMode>bridged</FenceMode>
1669 </NetworkConfigSection>
1670 <LeaseSettingsSection
1671 type="application/vnd.vmware.vcloud.leaseSettingsSection+xml">
1672 <ovf:Info>Lease Settings</ovf:Info>
1673 <StorageLeaseInSeconds>172800</StorageLeaseInSeconds>
1674 <StorageLeaseExpiration>2014-04-25T08:08:16.438-07:00</StorageLeaseExpiration>
1675 </LeaseSettingsSection>
1676 </InstantiationParams>
1679 <Source href="{}" id="{}" name="{}"
1680 type="application/vnd.vmware.vcloud.vm+xml"/>
1682 <NeedsCustomization>false</NeedsCustomization>
1684 <InstantiationParams>
1685 <NetworkConnectionSection>
1686 <ovf:Info>Specifies the available VM network connections</ovf:Info>
1687 <NetworkConnection network="{}">
1688 <NetworkConnectionIndex>0</NetworkConnectionIndex>
1689 <IsConnected>true</IsConnected>
1690 <IpAddressAllocationMode>DHCP</IpAddressAllocationMode>
1691 </NetworkConnection>
1692 </NetworkConnectionSection><ovf:VirtualHardwareSection>
1693 <ovf:Info>Virtual hardware requirements</ovf:Info>
1694 <ovf:Item xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
1695 xmlns:vmw="http://www.vmware.com/schema/ovf">
1696 <rasd:AllocationUnits>hertz * 10^6</rasd:AllocationUnits>
1697 <rasd:Description>Number of Virtual CPUs</rasd:Description>
1698 <rasd:ElementName xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="str">{cpu} virtual CPU(s)</rasd:ElementName>
1699 <rasd:InstanceID>4</rasd:InstanceID>
1700 <rasd:Reservation>0</rasd:Reservation>
1701 <rasd:ResourceType>3</rasd:ResourceType>
1702 <rasd:VirtualQuantity xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="int">{cpu}</rasd:VirtualQuantity>
1703 <rasd:Weight>0</rasd:Weight>
1704 <vmw:CoresPerSocket ovf:required="false">{core}</vmw:CoresPerSocket>
1705 </ovf:Item><ovf:Item xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData">
1706 <rasd:AllocationUnits>byte * 2^20</rasd:AllocationUnits>
1707 <rasd:Description>Memory Size</rasd:Description>
1708 <rasd:ElementName xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="str">{memory} MB of memory</rasd:ElementName>
1709 <rasd:InstanceID>5</rasd:InstanceID>
1710 <rasd:Reservation>0</rasd:Reservation>
1711 <rasd:ResourceType>4</rasd:ResourceType>
1712 <rasd:VirtualQuantity xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="int">{memory}</rasd:VirtualQuantity>
1713 <rasd:Weight>0</rasd:Weight>
1715 </ovf:VirtualHardwareSection>
1716 </InstantiationParams>
1718 <AllEULAsAccepted>false</AllEULAsAccepted>
1719 </InstantiateVAppTemplateParams>""".format(vmname_andid
,
1729 response
= self
.perform_request(req_type
='POST',
1730 url
=instantiate_vapp_href
,
1734 if response
.status_code
!= 201:
1735 self
.logger
.error("REST call {} failed reason : {}"\
1736 "status code : {}".format(instantiate_vapp_href
,
1738 response
.status_code
))
1739 raise vimconn
.vimconnException("new_vminstance(): Failed to create"\
1740 "vAapp {}".format(vmname_andid
))
1742 vapptask
= self
.get_task_from_response(response
.content
)
1744 if vapptask
is None and retry
==1:
1745 self
.get_token() # Retry getting token
1750 if vapptask
is None or vapptask
is False:
1751 raise vimconn
.vimconnUnexpectedResponse(
1752 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1754 # wait for task to complete
1755 result
= self
.client
.get_task_monitor().wait_for_success(task
=vapptask
)
1757 if result
.get('status') == 'success':
1758 self
.logger
.debug("new_vminstance(): Sucessfully created Vapp {}".format(vmname_andid
))
1760 raise vimconn
.vimconnUnexpectedResponse(
1761 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1763 except Exception as exp
:
1764 raise vimconn
.vimconnUnexpectedResponse(
1765 "new_vminstance(): failed to create vApp {} with Exception:{}".format(vmname_andid
, exp
))
1767 # we should have now vapp in undeployed state.
1769 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
1770 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1771 vapp_uuid
= vapp_resource
.get('id').split(':')[-1]
1772 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1774 except Exception as exp
:
1775 raise vimconn
.vimconnUnexpectedResponse(
1776 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
1777 .format(vmname_andid
, exp
))
1779 if vapp_uuid
is None:
1780 raise vimconn
.vimconnUnexpectedResponse(
1781 "new_vminstance(): Failed to retrieve vApp {} after creation".format(
1784 #Add PCI passthrough/SRIOV configrations
1786 pci_devices_info
= []
1788 reserve_memory
= False
1790 for net
in net_list
:
1791 if net
["type"] == "PF" or net
["type"] == "PCI-PASSTHROUGH":
1792 pci_devices_info
.append(net
)
1793 elif (net
["type"] == "VF" or net
["type"] == "SR-IOV" or net
["type"] == "VFnotShared") and 'net_id'in net
:
1794 sriov_net_info
.append(net
)
1797 if len(pci_devices_info
) > 0:
1798 self
.logger
.info("Need to add PCI devices {} into VM {}".format(pci_devices_info
,
1800 PCI_devices_status
, vm_obj
, vcenter_conect
= self
.add_pci_devices(vapp_uuid
,
1803 if PCI_devices_status
:
1804 self
.logger
.info("Added PCI devives {} to VM {}".format(
1808 reserve_memory
= True
1810 self
.logger
.info("Fail to add PCI devives {} to VM {}".format(
1817 #Assuming there is only one disk in ovf and fast provisioning in organization vDC is disabled
1818 result
= self
.modify_vm_disk(vapp_uuid
, vm_disk
)
1820 self
.logger
.debug("Modified Disk size of VM {} ".format(vmname_andid
))
1822 #Add new or existing disks to vApp
1824 added_existing_disk
= False
1825 for disk
in disk_list
:
1826 if 'device_type' in disk
and disk
['device_type'] == 'cdrom':
1827 image_id
= disk
['image_id']
1828 # Adding CD-ROM to VM
1829 # will revisit code once specification ready to support this feature
1830 self
.insert_media_to_vm(vapp
, image_id
)
1831 elif "image_id" in disk
and disk
["image_id"] is not None:
1832 self
.logger
.debug("Adding existing disk from image {} to vm {} ".format(
1833 disk
["image_id"] , vapp_uuid
))
1834 self
.add_existing_disk(catalogs
=catalogs
,
1835 image_id
=disk
["image_id"],
1836 size
= disk
["size"],
1837 template_name
=templateName
,
1840 added_existing_disk
= True
1842 #Wait till added existing disk gets reflected into vCD database/API
1843 if added_existing_disk
:
1845 added_existing_disk
= False
1846 self
.add_new_disk(vapp_uuid
, disk
['size'])
1849 # Assigning numa affinity setting
1851 if 'paired-threads-id' in numa
:
1852 paired_threads_id
= numa
['paired-threads-id']
1853 self
.set_numa_affinity(vapp_uuid
, paired_threads_id
)
1855 # add NICs & connect to networks in netlist
1857 self
.logger
.info("Request to connect VM to a network: {}".format(net_list
))
1859 primary_nic_index
= 0
1860 for net
in net_list
:
1861 # openmano uses network id in UUID format.
1862 # vCloud Director need a name so we do reverse operation from provided UUID we lookup a name
1863 # [{'use': 'bridge', 'net_id': '527d4bf7-566a-41e7-a9e7-ca3cdd9cef4f', 'type': 'virtual',
1864 # 'vpci': '0000:00:11.0', 'name': 'eth0'}]
1866 if 'net_id' not in net
:
1869 #Using net_id as a vim_id i.e. vim interface id, as do not have saperate vim interface id
1870 #Same will be returned in refresh_vms_status() as vim_interface_id
1871 net
['vim_id'] = net
['net_id'] # Provide the same VIM identifier as the VIM network
1873 interface_net_id
= net
['net_id']
1874 interface_net_name
= self
.get_network_name_by_id(network_uuid
=interface_net_id
)
1875 interface_network_mode
= net
['use']
1877 if interface_network_mode
== 'mgmt':
1878 primary_nic_index
= nicIndex
1880 """- POOL (A static IP address is allocated automatically from a pool of addresses.)
1881 - DHCP (The IP address is obtained from a DHCP service.)
1882 - MANUAL (The IP address is assigned manually in the IpAddress element.)
1883 - NONE (No IP addressing mode specified.)"""
1885 if primary_netname
is not None:
1886 nets
= filter(lambda n
: n
.get('name') == interface_net_name
, self
.get_network_list())
1888 #nets = [n for n in self.get_network_list() if n.get('name') == interface_net_name]
1890 self
.logger
.info("new_vminstance(): Found requested network: {}".format(nets
[0].get('name')))
1892 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
1893 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1894 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1895 # connect network to VM - with all DHCP by default
1896 task
= vapp
.connect_org_vdc_network(nets
[0].get('name'))
1898 self
.client
.get_task_monitor().wait_for_success(task
=task
)
1900 type_list
= ('PF', 'PCI-PASSTHROUGH', 'VF', 'SR-IOV', 'VFnotShared')
1901 if 'type' in net
and net
['type'] not in type_list
:
1902 # fetching nic type from vnf
1904 if net
['model'] is not None and net
['model'].lower() == 'virtio':
1905 nic_type
= 'VMXNET3'
1907 nic_type
= net
['model']
1909 self
.logger
.info("new_vminstance(): adding network adapter "\
1910 "to a network {}".format(nets
[0].get('name')))
1911 self
.add_network_adapter_to_vms(vapp
, nets
[0].get('name'),
1917 self
.logger
.info("new_vminstance(): adding network adapter "\
1918 "to a network {}".format(nets
[0].get('name')))
1919 self
.add_network_adapter_to_vms(vapp
, nets
[0].get('name'),
1925 # cloud-init for ssh-key injection
1927 self
.cloud_init(vapp
,cloud_config
)
1929 # ############# Stub code for SRIOV #################
1931 # if len(sriov_net_info) > 0:
1932 # self.logger.info("Need to add SRIOV adapters {} into VM {}".format(sriov_net_info,
1934 # sriov_status, vm_obj, vcenter_conect = self.add_sriov(vapp_uuid,
1938 # self.logger.info("Added SRIOV {} to VM {}".format(
1942 # reserve_memory = True
1944 # self.logger.info("Fail to add SRIOV {} to VM {}".format(
1949 # If VM has PCI devices or SRIOV reserve memory for VM
1951 memReserve
= vm_obj
.config
.hardware
.memoryMB
1952 spec
= vim
.vm
.ConfigSpec()
1953 spec
.memoryAllocation
= vim
.ResourceAllocationInfo(reservation
=memReserve
)
1954 task
= vm_obj
.ReconfigVM_Task(spec
=spec
)
1956 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
1957 self
.logger
.info("Reserved memory {} MB for "
1958 "VM VM status: {}".format(str(memReserve
), result
))
1960 self
.logger
.info("Fail to reserved memory {} to VM {}".format(
1961 str(memReserve
), str(vm_obj
)))
1963 self
.logger
.debug("new_vminstance(): starting power on vApp {} ".format(vmname_andid
))
1965 vapp_id
= vapp_resource
.get('id').split(':')[-1]
1966 poweron_task
= self
.power_on_vapp(vapp_id
, vmname_andid
)
1967 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
1968 if result
.get('status') == 'success':
1969 self
.logger
.info("new_vminstance(): Successfully power on "\
1970 "vApp {}".format(vmname_andid
))
1972 self
.logger
.error("new_vminstance(): failed to power on vApp "\
1973 "{}".format(vmname_andid
))
1975 except Exception as exp
:
1976 # it might be a case if specific mandatory entry in dict is empty or some other pyVcloud exception
1977 self
.logger
.error("new_vminstance(): Failed create new vm instance {} with exception {}"
1979 raise vimconn
.vimconnException("new_vminstance(): Failed create new vm instance {} with exception {}"
1982 # check if vApp deployed and if that the case return vApp UUID otherwise -1
1985 while wait_time
<= MAX_WAIT_TIME
:
1987 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1988 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1989 except Exception as exp
:
1990 raise vimconn
.vimconnUnexpectedResponse(
1991 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
1992 .format(vmname_andid
, exp
))
1994 #if vapp and vapp.me.deployed:
1995 if vapp
and vapp_resource
.get('deployed') == 'true':
1996 vapp_uuid
= vapp_resource
.get('id').split(':')[-1]
1999 self
.logger
.debug("new_vminstance(): Wait for vApp {} to deploy".format(name
))
2000 time
.sleep(INTERVAL_TIME
)
2002 wait_time
+=INTERVAL_TIME
2004 if vapp_uuid
is not None:
2005 return vapp_uuid
, None
2007 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name
))
2011 ## based on current discussion
2015 # created: '2016-09-08T11:51:58'
2016 # description: simple-instance.linux1.1
2017 # flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
2018 # hostId: e836c036-74e7-11e6-b249-0800273e724c
2019 # image: dde30fe6-75a9-11e6-ad5f-0800273e724c
2024 def get_vminstance(self
, vim_vm_uuid
=None):
2025 """Returns the VM instance information from VIM"""
2027 self
.logger
.debug("Client requesting vm instance {} ".format(vim_vm_uuid
))
2029 org
, vdc
= self
.get_vdc_details()
2031 raise vimconn
.vimconnConnectionException(
2032 "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2034 vm_info_dict
= self
.get_vapp_details_rest(vapp_uuid
=vim_vm_uuid
)
2035 if not vm_info_dict
:
2036 self
.logger
.debug("get_vminstance(): Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
2037 raise vimconn
.vimconnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
2039 status_key
= vm_info_dict
['status']
2042 vm_dict
= {'created': vm_info_dict
['created'],
2043 'description': vm_info_dict
['name'],
2044 'status': vcdStatusCode2manoFormat
[int(status_key
)],
2045 'hostId': vm_info_dict
['vmuuid'],
2047 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
2049 if 'interfaces' in vm_info_dict
:
2050 vm_dict
['interfaces'] = vm_info_dict
['interfaces']
2052 vm_dict
['interfaces'] = []
2054 vm_dict
= {'created': '',
2056 'status': vcdStatusCode2manoFormat
[int(-1)],
2057 'hostId': vm_info_dict
['vmuuid'],
2058 'error_msg': "Inconsistency state",
2059 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
2063 def delete_vminstance(self
, vm__vim_uuid
, created_items
=None):
2064 """Method poweroff and remove VM instance from vcloud director network.
2067 vm__vim_uuid: VM UUID
2070 Returns the instance identifier
2073 self
.logger
.debug("Client requesting delete vm instance {} ".format(vm__vim_uuid
))
2075 org
, vdc
= self
.get_vdc_details()
2076 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2078 self
.logger
.debug("delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(
2080 raise vimconn
.vimconnException(
2081 "delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2084 vapp_name
= self
.get_namebyvappid(vm__vim_uuid
)
2085 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2086 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2087 if vapp_name
is None:
2088 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2089 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2091 self
.logger
.info("Deleting vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
2093 # Delete vApp and wait for status change if task executed and vApp is None.
2096 if vapp_resource
.get('deployed') == 'true':
2097 self
.logger
.info("Powering off vApp {}".format(vapp_name
))
2101 while wait_time
<= MAX_WAIT_TIME
:
2102 power_off_task
= vapp
.power_off()
2103 result
= self
.client
.get_task_monitor().wait_for_success(task
=power_off_task
)
2105 if result
.get('status') == 'success':
2109 self
.logger
.info("Wait for vApp {} to power off".format(vapp_name
))
2110 time
.sleep(INTERVAL_TIME
)
2112 wait_time
+=INTERVAL_TIME
2114 self
.logger
.debug("delete_vminstance(): Failed to power off VM instance {} ".format(vm__vim_uuid
))
2116 self
.logger
.info("delete_vminstance(): Powered off VM instance {} ".format(vm__vim_uuid
))
2119 self
.logger
.info("Undeploy vApp {}".format(vapp_name
))
2122 while wait_time
<= MAX_WAIT_TIME
:
2123 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2125 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2126 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2127 undeploy_task
= vapp
.undeploy()
2129 result
= self
.client
.get_task_monitor().wait_for_success(task
=undeploy_task
)
2130 if result
.get('status') == 'success':
2134 self
.logger
.debug("Wait for vApp {} to undeploy".format(vapp_name
))
2135 time
.sleep(INTERVAL_TIME
)
2137 wait_time
+=INTERVAL_TIME
2140 self
.logger
.debug("delete_vminstance(): Failed to undeploy vApp {} ".format(vm__vim_uuid
))
2143 self
.logger
.info("Start deletion of vApp {} ".format(vapp_name
))
2145 if vapp
is not None:
2149 while wait_time
<= MAX_WAIT_TIME
:
2150 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2152 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2153 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2155 delete_task
= vdc_obj
.delete_vapp(vapp
.name
, force
=True)
2157 result
= self
.client
.get_task_monitor().wait_for_success(task
=delete_task
)
2158 if result
.get('status') == 'success':
2161 self
.logger
.debug("Wait for vApp {} to delete".format(vapp_name
))
2162 time
.sleep(INTERVAL_TIME
)
2164 wait_time
+=INTERVAL_TIME
2167 self
.logger
.debug("delete_vminstance(): Failed delete uuid {} ".format(vm__vim_uuid
))
2169 self
.logger
.info("Deleted vm instance {} sccessfully".format(vm__vim_uuid
))
2172 self
.logger
.debug(traceback
.format_exc())
2173 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
2176 def refresh_vms_status(self
, vm_list
):
2177 """Get the status of the virtual machines and their interfaces/ports
2178 Params: the list of VM identifiers
2179 Returns a dictionary with:
2180 vm_id: #VIM id of this Virtual Machine
2181 status: #Mandatory. Text with one of:
2182 # DELETED (not found at vim)
2183 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2184 # OTHER (Vim reported other status not understood)
2185 # ERROR (VIM indicates an ERROR status)
2186 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
2187 # CREATING (on building process), ERROR
2188 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
2190 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2191 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2193 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2194 mac_address: #Text format XX:XX:XX:XX:XX:XX
2195 vim_net_id: #network id where this interface is connected
2196 vim_interface_id: #interface/port VIM id
2197 ip_address: #null, or text with IPv4, IPv6 address
2200 self
.logger
.debug("Client requesting refresh vm status for {} ".format(vm_list
))
2202 org
,vdc
= self
.get_vdc_details()
2204 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2208 for vmuuid
in vm_list
:
2209 vapp_name
= self
.get_namebyvappid(vmuuid
)
2210 if vapp_name
is not None:
2213 vm_pci_details
= self
.get_vm_pci_details(vmuuid
)
2214 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2215 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2216 the_vapp
= VApp(self
.client
, resource
=vapp_resource
)
2219 for vm
in the_vapp
.get_all_vms():
2220 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2221 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2222 response
= self
.perform_request(req_type
='GET',
2226 if response
.status_code
!= 200:
2227 self
.logger
.error("refresh_vms_status : REST call {} failed reason : {}"\
2228 "status code : {}".format(vm
.get('href'),
2230 response
.status_code
))
2231 raise vimconn
.vimconnException("refresh_vms_status : Failed to get "\
2233 xmlroot
= XmlElementTree
.fromstring(response
.content
)
2235 result
= response
.content
.replace("\n"," ")
2236 hdd_mb
= re
.search('vcloud:capacity="(\d+)"\svcloud:storageProfileOverrideVmDefault=',result
).group(1)
2237 vm_details
['hdd_mb'] = int(hdd_mb
) if hdd_mb
else None
2238 cpus
= re
.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
2239 vm_details
['cpus'] = int(cpus
) if cpus
else None
2240 memory_mb
= re
.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
2241 vm_details
['memory_mb'] = int(memory_mb
) if memory_mb
else None
2242 vm_details
['status'] = vcdStatusCode2manoFormat
[int(xmlroot
.get('status'))]
2243 vm_details
['id'] = xmlroot
.get('id')
2244 vm_details
['name'] = xmlroot
.get('name')
2245 vm_info
= [vm_details
]
2247 vm_info
[0].update(vm_pci_details
)
2249 vm_dict
= {'status': vcdStatusCode2manoFormat
[int(vapp_resource
.get('status'))],
2250 'error_msg': vcdStatusCode2manoFormat
[int(vapp_resource
.get('status'))],
2251 'vim_info': yaml
.safe_dump(vm_info
), 'interfaces': []}
2256 networks
= re
.findall('<NetworkConnection needsCustomization=.*?</NetworkConnection>',result
)
2257 for network
in networks
:
2258 mac_s
= re
.search('<MACAddress>(.*?)</MACAddress>',network
)
2259 vm_mac
= mac_s
.group(1) if mac_s
else None
2260 ip_s
= re
.search('<IpAddress>(.*?)</IpAddress>',network
)
2261 vm_ip
= ip_s
.group(1) if ip_s
else None
2264 if not nsx_edge_list
:
2265 nsx_edge_list
= self
.get_edge_details()
2266 if nsx_edge_list
is None:
2267 raise vimconn
.vimconnException("refresh_vms_status:"\
2268 "Failed to get edge details from NSX Manager")
2269 if vm_mac
is not None:
2270 vm_ip
= self
.get_ipaddr_from_NSXedge(nsx_edge_list
, vm_mac
)
2272 net_s
= re
.search('network="(.*?)"',network
)
2273 network_name
= net_s
.group(1) if net_s
else None
2275 vm_net_id
= self
.get_network_id_by_name(network_name
)
2276 interface
= {"mac_address": vm_mac
,
2277 "vim_net_id": vm_net_id
,
2278 "vim_interface_id": vm_net_id
,
2279 "ip_address": vm_ip
}
2281 vm_dict
["interfaces"].append(interface
)
2283 # add a vm to vm dict
2284 vms_dict
.setdefault(vmuuid
, vm_dict
)
2285 self
.logger
.debug("refresh_vms_status : vm info {}".format(vm_dict
))
2286 except Exception as exp
:
2287 self
.logger
.debug("Error in response {}".format(exp
))
2288 self
.logger
.debug(traceback
.format_exc())
2293 def get_edge_details(self
):
2294 """Get the NSX edge list from NSX Manager
2295 Returns list of NSX edges
2298 rheaders
= {'Content-Type': 'application/xml'}
2299 nsx_api_url
= '/api/4.0/edges'
2301 self
.logger
.debug("Get edge details from NSX Manager {} {}".format(self
.nsx_manager
, nsx_api_url
))
2304 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2305 auth
= (self
.nsx_user
, self
.nsx_password
),
2306 verify
= False, headers
= rheaders
)
2307 if resp
.status_code
== requests
.codes
.ok
:
2308 paged_Edge_List
= XmlElementTree
.fromstring(resp
.text
)
2309 for edge_pages
in paged_Edge_List
:
2310 if edge_pages
.tag
== 'edgePage':
2311 for edge_summary
in edge_pages
:
2312 if edge_summary
.tag
== 'pagingInfo':
2313 for element
in edge_summary
:
2314 if element
.tag
== 'totalCount' and element
.text
== '0':
2315 raise vimconn
.vimconnException("get_edge_details: No NSX edges details found: {}"
2316 .format(self
.nsx_manager
))
2318 if edge_summary
.tag
== 'edgeSummary':
2319 for element
in edge_summary
:
2320 if element
.tag
== 'id':
2321 edge_list
.append(element
.text
)
2323 raise vimconn
.vimconnException("get_edge_details: No NSX edge details found: {}"
2324 .format(self
.nsx_manager
))
2327 raise vimconn
.vimconnException("get_edge_details: "\
2328 "No NSX edge details found: {}"
2329 .format(self
.nsx_manager
))
2331 self
.logger
.debug("get_edge_details: Found NSX edges {}".format(edge_list
))
2334 self
.logger
.debug("get_edge_details: "
2335 "Failed to get NSX edge details from NSX Manager: {}"
2336 .format(resp
.content
))
2339 except Exception as exp
:
2340 self
.logger
.debug("get_edge_details: "\
2341 "Failed to get NSX edge details from NSX Manager: {}"
2343 raise vimconn
.vimconnException("get_edge_details: "\
2344 "Failed to get NSX edge details from NSX Manager: {}"
2348 def get_ipaddr_from_NSXedge(self
, nsx_edges
, mac_address
):
2349 """Get IP address details from NSX edges, using the MAC address
2350 PARAMS: nsx_edges : List of NSX edges
2351 mac_address : Find IP address corresponding to this MAC address
2352 Returns: IP address corrresponding to the provided MAC address
2356 rheaders
= {'Content-Type': 'application/xml'}
2358 self
.logger
.debug("get_ipaddr_from_NSXedge: Finding IP addr from NSX edge")
2361 for edge
in nsx_edges
:
2362 nsx_api_url
= '/api/4.0/edges/'+ edge
+'/dhcp/leaseInfo'
2364 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2365 auth
= (self
.nsx_user
, self
.nsx_password
),
2366 verify
= False, headers
= rheaders
)
2368 if resp
.status_code
== requests
.codes
.ok
:
2369 dhcp_leases
= XmlElementTree
.fromstring(resp
.text
)
2370 for child
in dhcp_leases
:
2371 if child
.tag
== 'dhcpLeaseInfo':
2372 dhcpLeaseInfo
= child
2373 for leaseInfo
in dhcpLeaseInfo
:
2374 for elem
in leaseInfo
:
2375 if (elem
.tag
)=='macAddress':
2376 edge_mac_addr
= elem
.text
2377 if (elem
.tag
)=='ipAddress':
2379 if edge_mac_addr
is not None:
2380 if edge_mac_addr
== mac_address
:
2381 self
.logger
.debug("Found ip addr {} for mac {} at NSX edge {}"
2382 .format(ip_addr
, mac_address
,edge
))
2385 self
.logger
.debug("get_ipaddr_from_NSXedge: "\
2386 "Error occurred while getting DHCP lease info from NSX Manager: {}"
2387 .format(resp
.content
))
2389 self
.logger
.debug("get_ipaddr_from_NSXedge: No IP addr found in any NSX edge")
2392 except XmlElementTree
.ParseError
as Err
:
2393 self
.logger
.debug("ParseError in response from NSX Manager {}".format(Err
.message
), exc_info
=True)
2396 def action_vminstance(self
, vm__vim_uuid
=None, action_dict
=None, created_items
={}):
2397 """Send and action over a VM instance from VIM
2398 Returns the vm_id if the action was successfully sent to the VIM"""
2400 self
.logger
.debug("Received action for vm {} and action dict {}".format(vm__vim_uuid
, action_dict
))
2401 if vm__vim_uuid
is None or action_dict
is None:
2402 raise vimconn
.vimconnException("Invalid request. VM id or action is None.")
2404 org
, vdc
= self
.get_vdc_details()
2406 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2408 vapp_name
= self
.get_namebyvappid(vm__vim_uuid
)
2409 if vapp_name
is None:
2410 self
.logger
.debug("action_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2411 raise vimconn
.vimconnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2413 self
.logger
.info("Action_vminstance vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
2416 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2417 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2418 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2419 if "start" in action_dict
:
2420 self
.logger
.info("action_vminstance: Power on vApp: {}".format(vapp_name
))
2421 poweron_task
= self
.power_on_vapp(vm__vim_uuid
, vapp_name
)
2422 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
2423 self
.instance_actions_result("start", result
, vapp_name
)
2424 elif "rebuild" in action_dict
:
2425 self
.logger
.info("action_vminstance: Rebuild vApp: {}".format(vapp_name
))
2426 rebuild_task
= vapp
.deploy(power_on
=True)
2427 result
= self
.client
.get_task_monitor().wait_for_success(task
=rebuild_task
)
2428 self
.instance_actions_result("rebuild", result
, vapp_name
)
2429 elif "pause" in action_dict
:
2430 self
.logger
.info("action_vminstance: pause vApp: {}".format(vapp_name
))
2431 pause_task
= vapp
.undeploy(action
='suspend')
2432 result
= self
.client
.get_task_monitor().wait_for_success(task
=pause_task
)
2433 self
.instance_actions_result("pause", result
, vapp_name
)
2434 elif "resume" in action_dict
:
2435 self
.logger
.info("action_vminstance: resume vApp: {}".format(vapp_name
))
2436 poweron_task
= self
.power_on_vapp(vm__vim_uuid
, vapp_name
)
2437 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
2438 self
.instance_actions_result("resume", result
, vapp_name
)
2439 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
2440 action_name
, value
= action_dict
.items()[0]
2442 #action_name , value = list(action_dict.items())[0]
2443 self
.logger
.info("action_vminstance: {} vApp: {}".format(action_name
, vapp_name
))
2444 shutdown_task
= vapp
.shutdown()
2445 result
= self
.client
.get_task_monitor().wait_for_success(task
=shutdown_task
)
2446 if action_name
== "shutdown":
2447 self
.instance_actions_result("shutdown", result
, vapp_name
)
2449 self
.instance_actions_result("shutoff", result
, vapp_name
)
2450 elif "forceOff" in action_dict
:
2451 result
= vapp
.undeploy(action
='powerOff')
2452 self
.instance_actions_result("forceOff", result
, vapp_name
)
2453 elif "reboot" in action_dict
:
2454 self
.logger
.info("action_vminstance: reboot vApp: {}".format(vapp_name
))
2455 reboot_task
= vapp
.reboot()
2456 self
.client
.get_task_monitor().wait_for_success(task
=reboot_task
)
2458 raise vimconn
.vimconnException("action_vminstance: Invalid action {} or action is None.".format(action_dict
))
2460 except Exception as exp
:
2461 self
.logger
.debug("action_vminstance: Failed with Exception {}".format(exp
))
2462 raise vimconn
.vimconnException("action_vminstance: Failed with Exception {}".format(exp
))
2464 def instance_actions_result(self
, action
, result
, vapp_name
):
2465 if result
.get('status') == 'success':
2466 self
.logger
.info("action_vminstance: Sucessfully {} the vApp: {}".format(action
, vapp_name
))
2468 self
.logger
.error("action_vminstance: Failed to {} vApp: {}".format(action
, vapp_name
))
2470 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
2472 Get a console for the virtual machine
2474 vm_id: uuid of the VM
2475 console_type, can be:
2476 "novnc" (by default), "xvpvnc" for VNC types,
2477 "rdp-html5" for RDP types, "spice-html5" for SPICE types
2478 Returns dict with the console parameters:
2479 protocol: ssh, ftp, http, https, ...
2480 server: usually ip address
2481 port: the http, ssh, ... port
2482 suffix: extra text, e.g. the http path and query string
2484 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2486 # NOT USED METHODS in current version
2488 def host_vim2gui(self
, host
, server_dict
):
2489 """Transform host dictionary from VIM format to GUI format,
2490 and append to the server_dict
2492 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2494 def get_hosts_info(self
):
2495 """Get the information of deployed hosts
2496 Returns the hosts content"""
2497 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2499 def get_hosts(self
, vim_tenant
):
2500 """Get the hosts and deployed instances
2501 Returns the hosts content"""
2502 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2504 def get_processor_rankings(self
):
2505 """Get the processor rankings in the VIM database"""
2506 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2508 def new_host(self
, host_data
):
2509 """Adds a new host to VIM"""
2510 '''Returns status code of the VIM response'''
2511 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2513 def new_external_port(self
, port_data
):
2514 """Adds a external port to VIM"""
2515 '''Returns the port identifier'''
2516 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2518 def new_external_network(self
, net_name
, net_type
):
2519 """Adds a external network to VIM (shared)"""
2520 '''Returns the network identifier'''
2521 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2523 def connect_port_network(self
, port_id
, network_id
, admin
=False):
2524 """Connects a external port to a network"""
2525 '''Returns status code of the VIM response'''
2526 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2528 def new_vminstancefromJSON(self
, vm_data
):
2529 """Adds a VM instance to VIM"""
2530 '''Returns the instance identifier'''
2531 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2533 def get_network_name_by_id(self
, network_uuid
=None):
2534 """Method gets vcloud director network named based on supplied uuid.
2537 network_uuid: network_id
2540 The return network name.
2543 if not network_uuid
:
2547 org_dict
= self
.get_org(self
.org_uuid
)
2548 if 'networks' in org_dict
:
2549 org_network_dict
= org_dict
['networks']
2550 for net_uuid
in org_network_dict
:
2551 if net_uuid
== network_uuid
:
2552 return org_network_dict
[net_uuid
]
2554 self
.logger
.debug("Exception in get_network_name_by_id")
2555 self
.logger
.debug(traceback
.format_exc())
2559 def get_network_id_by_name(self
, network_name
=None):
2560 """Method gets vcloud director network uuid based on supplied name.
2563 network_name: network_name
2565 The return network uuid.
2566 network_uuid: network_id
2569 if not network_name
:
2570 self
.logger
.debug("get_network_id_by_name() : Network name is empty")
2574 org_dict
= self
.get_org(self
.org_uuid
)
2575 if org_dict
and 'networks' in org_dict
:
2576 org_network_dict
= org_dict
['networks']
2577 for net_uuid
,net_name
in org_network_dict
.iteritems():
2579 #for net_uuid,net_name in org_network_dict.items():
2580 if net_name
== network_name
:
2583 except KeyError as exp
:
2584 self
.logger
.debug("get_network_id_by_name() : KeyError- {} ".format(exp
))
2588 def list_org_action(self
):
2590 Method leverages vCloud director and query for available organization for particular user
2593 vca - is active VCA connection.
2594 vdc_name - is a vdc name that will be used to query vms action
2597 The return XML respond
2599 url_list
= [self
.url
, '/api/org']
2600 vm_list_rest_call
= ''.join(url_list
)
2602 if self
.client
._session
:
2603 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2604 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2606 response
= self
.perform_request(req_type
='GET',
2607 url
=vm_list_rest_call
,
2610 if response
.status_code
== 403:
2611 response
= self
.retry_rest('GET', vm_list_rest_call
)
2613 if response
.status_code
== requests
.codes
.ok
:
2614 return response
.content
2618 def get_org_action(self
, org_uuid
=None):
2620 Method leverages vCloud director and retrieve available object for organization.
2623 org_uuid - vCD organization uuid
2624 self.client - is active connection.
2627 The return XML respond
2630 if org_uuid
is None:
2633 url_list
= [self
.url
, '/api/org/', org_uuid
]
2634 vm_list_rest_call
= ''.join(url_list
)
2636 if self
.client
._session
:
2637 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2638 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2640 #response = requests.get(vm_list_rest_call, headers=headers, verify=False)
2641 response
= self
.perform_request(req_type
='GET',
2642 url
=vm_list_rest_call
,
2644 if response
.status_code
== 403:
2645 response
= self
.retry_rest('GET', vm_list_rest_call
)
2647 if response
.status_code
== requests
.codes
.ok
:
2648 return response
.content
2651 def get_org(self
, org_uuid
=None):
2653 Method retrieves available organization in vCloud Director
2656 org_uuid - is a organization uuid.
2659 The return dictionary with following key
2660 "network" - for network list under the org
2661 "catalogs" - for network list under the org
2662 "vdcs" - for vdc list under org
2667 if org_uuid
is None:
2670 content
= self
.get_org_action(org_uuid
=org_uuid
)
2675 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2676 for child
in vm_list_xmlroot
:
2677 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.vdc+xml':
2678 vdc_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2679 org_dict
['vdcs'] = vdc_list
2680 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.orgNetwork+xml':
2681 network_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2682 org_dict
['networks'] = network_list
2683 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
2684 catalog_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2685 org_dict
['catalogs'] = catalog_list
2691 def get_org_list(self
):
2693 Method retrieves available organization in vCloud Director
2696 vca - is active VCA connection.
2699 The return dictionary and key for each entry VDC UUID
2704 content
= self
.list_org_action()
2706 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2707 for vm_xml
in vm_list_xmlroot
:
2708 if vm_xml
.tag
.split("}")[1] == 'Org':
2709 org_uuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2710 org_dict
[org_uuid
[0]] = vm_xml
.attrib
['name']
2716 def vms_view_action(self
, vdc_name
=None):
2717 """ Method leverages vCloud director vms query call
2720 vca - is active VCA connection.
2721 vdc_name - is a vdc name that will be used to query vms action
2724 The return XML respond
2726 vca
= self
.connect()
2727 if vdc_name
is None:
2730 url_list
= [vca
.host
, '/api/vms/query']
2731 vm_list_rest_call
= ''.join(url_list
)
2733 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2734 refs
= filter(lambda ref
: ref
.name
== vdc_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vdc+xml',
2735 vca
.vcloud_session
.organization
.Link
)
2737 #refs = [ref for ref in vca.vcloud_session.organization.Link if ref.name == vdc_name and\
2738 # ref.type_ == 'application/vnd.vmware.vcloud.vdc+xml']
2740 response
= Http
.get(url
=vm_list_rest_call
,
2741 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2744 if response
.status_code
== requests
.codes
.ok
:
2745 return response
.content
2749 def get_vapp_list(self
, vdc_name
=None):
2751 Method retrieves vApp list deployed vCloud director and returns a dictionary
2752 contains a list of all vapp deployed for queried VDC.
2753 The key for a dictionary is vApp UUID
2757 vca - is active VCA connection.
2758 vdc_name - is a vdc name that will be used to query vms action
2761 The return dictionary and key for each entry vapp UUID
2765 if vdc_name
is None:
2768 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2770 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2771 for vm_xml
in vm_list_xmlroot
:
2772 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
2773 if vm_xml
.attrib
['isVAppTemplate'] == 'true':
2774 rawuuid
= vm_xml
.attrib
['container'].split('/')[-1:]
2775 if 'vappTemplate-' in rawuuid
[0]:
2776 # vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
2777 # vm and use raw UUID as key
2778 vapp_dict
[rawuuid
[0][13:]] = vm_xml
.attrib
2784 def get_vm_list(self
, vdc_name
=None):
2786 Method retrieves VM's list deployed vCloud director. It returns a dictionary
2787 contains a list of all VM's deployed for queried VDC.
2788 The key for a dictionary is VM UUID
2792 vca - is active VCA connection.
2793 vdc_name - is a vdc name that will be used to query vms action
2796 The return dictionary and key for each entry vapp UUID
2800 if vdc_name
is None:
2803 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2805 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2806 for vm_xml
in vm_list_xmlroot
:
2807 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
2808 if vm_xml
.attrib
['isVAppTemplate'] == 'false':
2809 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2810 if 'vm-' in rawuuid
[0]:
2811 # vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
2812 # vm and use raw UUID as key
2813 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2819 def get_vapp(self
, vdc_name
=None, vapp_name
=None, isuuid
=False):
2821 Method retrieves VM deployed vCloud director. It returns VM attribute as dictionary
2822 contains a list of all VM's deployed for queried VDC.
2823 The key for a dictionary is VM UUID
2827 vca - is active VCA connection.
2828 vdc_name - is a vdc name that will be used to query vms action
2831 The return dictionary and key for each entry vapp UUID
2834 vca
= self
.connect()
2836 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2838 if vdc_name
is None:
2841 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2843 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2844 for vm_xml
in vm_list_xmlroot
:
2845 if vm_xml
.tag
.split("}")[1] == 'VMRecord' and vm_xml
.attrib
['isVAppTemplate'] == 'false':
2846 # lookup done by UUID
2848 if vapp_name
in vm_xml
.attrib
['container']:
2849 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2850 if 'vm-' in rawuuid
[0]:
2851 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2853 # lookup done by Name
2855 if vapp_name
in vm_xml
.attrib
['name']:
2856 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2857 if 'vm-' in rawuuid
[0]:
2858 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2865 def get_network_action(self
, network_uuid
=None):
2867 Method leverages vCloud director and query network based on network uuid
2870 vca - is active VCA connection.
2871 network_uuid - is a network uuid
2874 The return XML respond
2877 if network_uuid
is None:
2880 url_list
= [self
.url
, '/api/network/', network_uuid
]
2881 vm_list_rest_call
= ''.join(url_list
)
2883 if self
.client
._session
:
2884 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2885 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2887 response
= self
.perform_request(req_type
='GET',
2888 url
=vm_list_rest_call
,
2890 #Retry login if session expired & retry sending request
2891 if response
.status_code
== 403:
2892 response
= self
.retry_rest('GET', vm_list_rest_call
)
2894 if response
.status_code
== requests
.codes
.ok
:
2895 return response
.content
2899 def get_vcd_network(self
, network_uuid
=None):
2901 Method retrieves available network from vCloud Director
2904 network_uuid - is VCD network UUID
2906 Each element serialized as key : value pair
2908 Following keys available for access. network_configuration['Gateway'}
2912 <IsInherited>true</IsInherited>
2913 <Gateway>172.16.252.100</Gateway>
2914 <Netmask>255.255.255.0</Netmask>
2915 <Dns1>172.16.254.201</Dns1>
2916 <Dns2>172.16.254.202</Dns2>
2917 <DnsSuffix>vmwarelab.edu</DnsSuffix>
2918 <IsEnabled>true</IsEnabled>
2921 <StartAddress>172.16.252.1</StartAddress>
2922 <EndAddress>172.16.252.99</EndAddress>
2927 <FenceMode>bridged</FenceMode>
2930 The return dictionary and key for each entry vapp UUID
2933 network_configuration
= {}
2934 if network_uuid
is None:
2938 content
= self
.get_network_action(network_uuid
=network_uuid
)
2939 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2941 network_configuration
['status'] = vm_list_xmlroot
.get("status")
2942 network_configuration
['name'] = vm_list_xmlroot
.get("name")
2943 network_configuration
['uuid'] = vm_list_xmlroot
.get("id").split(":")[3]
2945 for child
in vm_list_xmlroot
:
2946 if child
.tag
.split("}")[1] == 'IsShared':
2947 network_configuration
['isShared'] = child
.text
.strip()
2948 if child
.tag
.split("}")[1] == 'Configuration':
2949 for configuration
in child
.iter():
2950 tagKey
= configuration
.tag
.split("}")[1].strip()
2952 network_configuration
[tagKey
] = configuration
.text
.strip()
2953 return network_configuration
2954 except Exception as exp
:
2955 self
.logger
.debug("get_vcd_network: Failed with Exception {}".format(exp
))
2956 raise vimconn
.vimconnException("get_vcd_network: Failed with Exception {}".format(exp
))
2958 return network_configuration
2960 def delete_network_action(self
, network_uuid
=None):
2962 Method delete given network from vCloud director
2965 network_uuid - is a network uuid that client wish to delete
2968 The return None or XML respond or false
2970 client
= self
.connect_as_admin()
2972 raise vimconn
.vimconnConnectionException("Failed to connect vCD as admin")
2973 if network_uuid
is None:
2976 url_list
= [self
.url
, '/api/admin/network/', network_uuid
]
2977 vm_list_rest_call
= ''.join(url_list
)
2980 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2981 'x-vcloud-authorization': client
._session
.headers
['x-vcloud-authorization']}
2982 response
= self
.perform_request(req_type
='DELETE',
2983 url
=vm_list_rest_call
,
2985 if response
.status_code
== 202:
2990 def create_network(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
2991 ip_profile
=None, isshared
='true'):
2993 Method create network in vCloud director
2996 network_name - is network name to be created.
2997 net_type - can be 'bridge','data','ptp','mgmt'.
2998 ip_profile is a dict containing the IP parameters of the network
2999 isshared - is a boolean
3000 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3001 It optional attribute. by default if no parent network indicate the first available will be used.
3004 The return network uuid or return None
3007 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
3008 content
= self
.create_network_rest(network_name
=''.join(new_network_name
),
3009 ip_profile
=ip_profile
,
3011 parent_network_uuid
=parent_network_uuid
,
3014 self
.logger
.debug("Failed create network {}.".format(network_name
))
3018 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3019 vcd_uuid
= vm_list_xmlroot
.get('id').split(":")
3020 if len(vcd_uuid
) == 4:
3021 self
.logger
.info("Created new network name: {} uuid: {}".format(network_name
, vcd_uuid
[3]))
3024 self
.logger
.debug("Failed create network {}".format(network_name
))
3027 def create_network_rest(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
3028 ip_profile
=None, isshared
='true'):
3030 Method create network in vCloud director
3033 network_name - is network name to be created.
3034 net_type - can be 'bridge','data','ptp','mgmt'.
3035 ip_profile is a dict containing the IP parameters of the network
3036 isshared - is a boolean
3037 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3038 It optional attribute. by default if no parent network indicate the first available will be used.
3041 The return network uuid or return None
3043 client_as_admin
= self
.connect_as_admin()
3044 if not client_as_admin
:
3045 raise vimconn
.vimconnConnectionException("Failed to connect vCD.")
3046 if network_name
is None:
3049 url_list
= [self
.url
, '/api/admin/vdc/', self
.tenant_id
]
3050 vm_list_rest_call
= ''.join(url_list
)
3052 if client_as_admin
._session
:
3053 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3054 'x-vcloud-authorization': client_as_admin
._session
.headers
['x-vcloud-authorization']}
3056 response
= self
.perform_request(req_type
='GET',
3057 url
=vm_list_rest_call
,
3060 provider_network
= None
3061 available_networks
= None
3062 add_vdc_rest_url
= None
3064 if response
.status_code
!= requests
.codes
.ok
:
3065 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3066 response
.status_code
))
3070 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3071 for child
in vm_list_xmlroot
:
3072 if child
.tag
.split("}")[1] == 'ProviderVdcReference':
3073 provider_network
= child
.attrib
.get('href')
3074 # application/vnd.vmware.admin.providervdc+xml
3075 if child
.tag
.split("}")[1] == 'Link':
3076 if child
.attrib
.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
3077 and child
.attrib
.get('rel') == 'add':
3078 add_vdc_rest_url
= child
.attrib
.get('href')
3080 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3081 self
.logger
.debug("Respond body {}".format(response
.content
))
3084 # find pvdc provided available network
3085 response
= self
.perform_request(req_type
='GET',
3086 url
=provider_network
,
3088 if response
.status_code
!= requests
.codes
.ok
:
3089 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3090 response
.status_code
))
3093 if parent_network_uuid
is None:
3095 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3096 for child
in vm_list_xmlroot
.iter():
3097 if child
.tag
.split("}")[1] == 'AvailableNetworks':
3098 for networks
in child
.iter():
3099 # application/vnd.vmware.admin.network+xml
3100 if networks
.attrib
.get('href') is not None:
3101 available_networks
= networks
.attrib
.get('href')
3107 #Configure IP profile of the network
3108 ip_profile
= ip_profile
if ip_profile
is not None else DEFAULT_IP_PROFILE
3110 if 'subnet_address' not in ip_profile
or ip_profile
['subnet_address'] is None:
3111 subnet_rand
= random
.randint(0, 255)
3112 ip_base
= "192.168.{}.".format(subnet_rand
)
3113 ip_profile
['subnet_address'] = ip_base
+ "0/24"
3115 ip_base
= ip_profile
['subnet_address'].rsplit('.',1)[0] + '.'
3117 if 'gateway_address' not in ip_profile
or ip_profile
['gateway_address'] is None:
3118 ip_profile
['gateway_address']=ip_base
+ "1"
3119 if 'dhcp_count' not in ip_profile
or ip_profile
['dhcp_count'] is None:
3120 ip_profile
['dhcp_count']=DEFAULT_IP_PROFILE
['dhcp_count']
3121 if 'dhcp_enabled' not in ip_profile
or ip_profile
['dhcp_enabled'] is None:
3122 ip_profile
['dhcp_enabled']=DEFAULT_IP_PROFILE
['dhcp_enabled']
3123 if 'dhcp_start_address' not in ip_profile
or ip_profile
['dhcp_start_address'] is None:
3124 ip_profile
['dhcp_start_address']=ip_base
+ "3"
3125 if 'ip_version' not in ip_profile
or ip_profile
['ip_version'] is None:
3126 ip_profile
['ip_version']=DEFAULT_IP_PROFILE
['ip_version']
3127 if 'dns_address' not in ip_profile
or ip_profile
['dns_address'] is None:
3128 ip_profile
['dns_address']=ip_base
+ "2"
3130 gateway_address
=ip_profile
['gateway_address']
3131 dhcp_count
=int(ip_profile
['dhcp_count'])
3132 subnet_address
=self
.convert_cidr_to_netmask(ip_profile
['subnet_address'])
3134 if ip_profile
['dhcp_enabled']==True:
3137 dhcp_enabled
='false'
3138 dhcp_start_address
=ip_profile
['dhcp_start_address']
3140 #derive dhcp_end_address from dhcp_start_address & dhcp_count
3141 end_ip_int
= int(netaddr
.IPAddress(dhcp_start_address
))
3142 end_ip_int
+= dhcp_count
- 1
3143 dhcp_end_address
= str(netaddr
.IPAddress(end_ip_int
))
3145 ip_version
=ip_profile
['ip_version']
3146 dns_address
=ip_profile
['dns_address']
3147 except KeyError as exp
:
3148 self
.logger
.debug("Create Network REST: Key error {}".format(exp
))
3149 raise vimconn
.vimconnException("Create Network REST: Key error{}".format(exp
))
3151 # either use client provided UUID or search for a first available
3152 # if both are not defined we return none
3153 if parent_network_uuid
is not None:
3154 url_list
= [self
.url
, '/api/admin/network/', parent_network_uuid
]
3155 add_vdc_rest_url
= ''.join(url_list
)
3157 #Creating all networks as Direct Org VDC type networks.
3158 #Unused in case of Underlay (data/ptp) network interface.
3159 fence_mode
="bridged"
3160 is_inherited
='false'
3161 dns_list
= dns_address
.split(";")
3164 if len(dns_list
) >= 2:
3165 dns2_text
= "\n <Dns2>{}</Dns2>\n".format(dns_list
[1])
3166 data
= """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
3167 <Description>Openmano created</Description>
3171 <IsInherited>{1:s}</IsInherited>
3172 <Gateway>{2:s}</Gateway>
3173 <Netmask>{3:s}</Netmask>
3174 <Dns1>{4:s}</Dns1>{5:s}
3175 <IsEnabled>{6:s}</IsEnabled>
3178 <StartAddress>{7:s}</StartAddress>
3179 <EndAddress>{8:s}</EndAddress>
3184 <ParentNetwork href="{9:s}"/>
3185 <FenceMode>{10:s}</FenceMode>
3187 <IsShared>{11:s}</IsShared>
3188 </OrgVdcNetwork> """.format(escape(network_name
), is_inherited
, gateway_address
,
3189 subnet_address
, dns1
, dns2_text
, dhcp_enabled
,
3190 dhcp_start_address
, dhcp_end_address
, available_networks
,
3191 fence_mode
, isshared
)
3193 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
3195 response
= self
.perform_request(req_type
='POST',
3196 url
=add_vdc_rest_url
,
3200 if response
.status_code
!= 201:
3201 self
.logger
.debug("Create Network POST REST API call failed. Return status code {}, Response content: {}"
3202 .format(response
.status_code
,response
.content
))
3204 network_task
= self
.get_task_from_response(response
.content
)
3205 self
.logger
.debug("Create Network REST : Waiting for Network creation complete")
3207 result
= self
.client
.get_task_monitor().wait_for_success(task
=network_task
)
3208 if result
.get('status') == 'success':
3209 return response
.content
3211 self
.logger
.debug("create_network_rest task failed. Network Create response : {}"
3212 .format(response
.content
))
3213 except Exception as exp
:
3214 self
.logger
.debug("create_network_rest : Exception : {} ".format(exp
))
3218 def convert_cidr_to_netmask(self
, cidr_ip
=None):
3220 Method sets convert CIDR netmask address to normal IP format
3222 cidr_ip : CIDR IP address
3224 netmask : Converted netmask
3226 if cidr_ip
is not None:
3228 network
, net_bits
= cidr_ip
.split('/')
3229 netmask
= socket
.inet_ntoa(struct
.pack(">I", (0xffffffff << (32 - int(net_bits
))) & 0xffffffff))
3235 def get_provider_rest(self
, vca
=None):
3237 Method gets provider vdc view from vcloud director
3240 network_name - is network name to be created.
3241 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3242 It optional attribute. by default if no parent network indicate the first available will be used.
3245 The return xml content of respond or None
3248 url_list
= [self
.url
, '/api/admin']
3250 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3251 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3252 response
= self
.perform_request(req_type
='GET',
3253 url
=''.join(url_list
),
3256 if response
.status_code
== requests
.codes
.ok
:
3257 return response
.content
3260 def create_vdc(self
, vdc_name
=None):
3264 xml_content
= self
.create_vdc_from_tmpl_rest(vdc_name
=vdc_name
)
3265 if xml_content
is not None:
3267 task_resp_xmlroot
= XmlElementTree
.fromstring(xml_content
)
3268 for child
in task_resp_xmlroot
:
3269 if child
.tag
.split("}")[1] == 'Owner':
3270 vdc_id
= child
.attrib
.get('href').split("/")[-1]
3271 vdc_dict
[vdc_id
] = task_resp_xmlroot
.get('href')
3274 self
.logger
.debug("Respond body {}".format(xml_content
))
3278 def create_vdc_from_tmpl_rest(self
, vdc_name
=None):
3280 Method create vdc in vCloud director based on VDC template.
3281 it uses pre-defined template.
3284 vdc_name - name of a new vdc.
3287 The return xml content of respond or None
3289 # pre-requesite atleast one vdc template should be available in vCD
3290 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
3291 vca
= self
.connect_as_admin()
3293 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
3294 if vdc_name
is None:
3297 url_list
= [self
.url
, '/api/vdcTemplates']
3298 vm_list_rest_call
= ''.join(url_list
)
3300 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3301 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
3302 response
= self
.perform_request(req_type
='GET',
3303 url
=vm_list_rest_call
,
3306 # container url to a template
3307 vdc_template_ref
= None
3309 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3310 for child
in vm_list_xmlroot
:
3311 # application/vnd.vmware.admin.providervdc+xml
3312 # we need find a template from witch we instantiate VDC
3313 if child
.tag
.split("}")[1] == 'VdcTemplate':
3314 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml':
3315 vdc_template_ref
= child
.attrib
.get('href')
3317 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3318 self
.logger
.debug("Respond body {}".format(response
.content
))
3321 # if we didn't found required pre defined template we return None
3322 if vdc_template_ref
is None:
3327 url_list
= [self
.url
, '/api/org/', self
.org_uuid
, '/action/instantiate']
3328 vm_list_rest_call
= ''.join(url_list
)
3329 data
= """<InstantiateVdcTemplateParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
3330 <Source href="{1:s}"></Source>
3331 <Description>opnemano</Description>
3332 </InstantiateVdcTemplateParams>""".format(vdc_name
, vdc_template_ref
)
3334 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVdcTemplateParams+xml'
3336 response
= self
.perform_request(req_type
='POST',
3337 url
=vm_list_rest_call
,
3341 vdc_task
= self
.get_task_from_response(response
.content
)
3342 self
.client
.get_task_monitor().wait_for_success(task
=vdc_task
)
3344 # if we all ok we respond with content otherwise by default None
3345 if response
.status_code
>= 200 and response
.status_code
< 300:
3346 return response
.content
3349 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3350 self
.logger
.debug("Respond body {}".format(response
.content
))
3354 def create_vdc_rest(self
, vdc_name
=None):
3356 Method create network in vCloud director
3359 vdc_name - vdc name to be created
3364 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
3366 vca
= self
.connect_as_admin()
3368 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
3369 if vdc_name
is None:
3372 url_list
= [self
.url
, '/api/admin/org/', self
.org_uuid
]
3373 vm_list_rest_call
= ''.join(url_list
)
3376 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3377 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3378 response
= self
.perform_request(req_type
='GET',
3379 url
=vm_list_rest_call
,
3382 provider_vdc_ref
= None
3383 add_vdc_rest_url
= None
3384 available_networks
= None
3386 if response
.status_code
!= requests
.codes
.ok
:
3387 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3388 response
.status_code
))
3392 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3393 for child
in vm_list_xmlroot
:
3394 # application/vnd.vmware.admin.providervdc+xml
3395 if child
.tag
.split("}")[1] == 'Link':
3396 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
3397 and child
.attrib
.get('rel') == 'add':
3398 add_vdc_rest_url
= child
.attrib
.get('href')
3400 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3401 self
.logger
.debug("Respond body {}".format(response
.content
))
3404 response
= self
.get_provider_rest(vca
=vca
)
3406 vm_list_xmlroot
= XmlElementTree
.fromstring(response
)
3407 for child
in vm_list_xmlroot
:
3408 if child
.tag
.split("}")[1] == 'ProviderVdcReferences':
3409 for sub_child
in child
:
3410 provider_vdc_ref
= sub_child
.attrib
.get('href')
3412 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3413 self
.logger
.debug("Respond body {}".format(response
))
3416 if add_vdc_rest_url
is not None and provider_vdc_ref
is not None:
3417 data
= """ <CreateVdcParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5"><Description>{1:s}</Description>
3418 <AllocationModel>ReservationPool</AllocationModel>
3419 <ComputeCapacity><Cpu><Units>MHz</Units><Allocated>2048</Allocated><Limit>2048</Limit></Cpu>
3420 <Memory><Units>MB</Units><Allocated>2048</Allocated><Limit>2048</Limit></Memory>
3421 </ComputeCapacity><NicQuota>0</NicQuota><NetworkQuota>100</NetworkQuota>
3422 <VdcStorageProfile><Enabled>true</Enabled><Units>MB</Units><Limit>20480</Limit><Default>true</Default></VdcStorageProfile>
3423 <ProviderVdcReference
3424 name="Main Provider"
3426 <UsesFastProvisioning>true</UsesFastProvisioning></CreateVdcParams>""".format(escape(vdc_name
),
3430 headers
['Content-Type'] = 'application/vnd.vmware.admin.createVdcParams+xml'
3432 response
= self
.perform_request(req_type
='POST',
3433 url
=add_vdc_rest_url
,
3437 # if we all ok we respond with content otherwise by default None
3438 if response
.status_code
== 201:
3439 return response
.content
3442 def get_vapp_details_rest(self
, vapp_uuid
=None, need_admin_access
=False):
3444 Method retrieve vapp detail from vCloud director
3447 vapp_uuid - is vapp identifier.
3450 The return network uuid or return None
3456 if need_admin_access
:
3457 vca
= self
.connect_as_admin()
3462 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
3463 if vapp_uuid
is None:
3466 url_list
= [self
.url
, '/api/vApp/vapp-', vapp_uuid
]
3467 get_vapp_restcall
= ''.join(url_list
)
3470 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3471 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
3472 response
= self
.perform_request(req_type
='GET',
3473 url
=get_vapp_restcall
,
3476 if response
.status_code
== 403:
3477 if need_admin_access
== False:
3478 response
= self
.retry_rest('GET', get_vapp_restcall
)
3480 if response
.status_code
!= requests
.codes
.ok
:
3481 self
.logger
.debug("REST API call {} failed. Return status code {}".format(get_vapp_restcall
,
3482 response
.status_code
))
3483 return parsed_respond
3486 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
3487 parsed_respond
['ovfDescriptorUploaded'] = xmlroot_respond
.attrib
['ovfDescriptorUploaded']
3489 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
3490 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
3491 'vmw': 'http://www.vmware.com/schema/ovf',
3492 'vm': 'http://www.vmware.com/vcloud/v1.5',
3493 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
3494 "vmext":"http://www.vmware.com/vcloud/extension/v1.5",
3495 "xmlns":"http://www.vmware.com/vcloud/v1.5"
3498 created_section
= xmlroot_respond
.find('vm:DateCreated', namespaces
)
3499 if created_section
is not None:
3500 parsed_respond
['created'] = created_section
.text
3502 network_section
= xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig', namespaces
)
3503 if network_section
is not None and 'networkName' in network_section
.attrib
:
3504 parsed_respond
['networkname'] = network_section
.attrib
['networkName']
3506 ipscopes_section
= \
3507 xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig/vm:Configuration/vm:IpScopes',
3509 if ipscopes_section
is not None:
3510 for ipscope
in ipscopes_section
:
3511 for scope
in ipscope
:
3512 tag_key
= scope
.tag
.split("}")[1]
3513 if tag_key
== 'IpRanges':
3514 ip_ranges
= scope
.getchildren()
3515 for ipblock
in ip_ranges
:
3516 for block
in ipblock
:
3517 parsed_respond
[block
.tag
.split("}")[1]] = block
.text
3519 parsed_respond
[tag_key
] = scope
.text
3521 # parse children section for other attrib
3522 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
3523 if children_section
is not None:
3524 parsed_respond
['name'] = children_section
.attrib
['name']
3525 parsed_respond
['nestedHypervisorEnabled'] = children_section
.attrib
['nestedHypervisorEnabled'] \
3526 if "nestedHypervisorEnabled" in children_section
.attrib
else None
3527 parsed_respond
['deployed'] = children_section
.attrib
['deployed']
3528 parsed_respond
['status'] = children_section
.attrib
['status']
3529 parsed_respond
['vmuuid'] = children_section
.attrib
['id'].split(":")[-1]
3530 network_adapter
= children_section
.find('vm:NetworkConnectionSection', namespaces
)
3532 for adapters
in network_adapter
:
3533 adapter_key
= adapters
.tag
.split("}")[1]
3534 if adapter_key
== 'PrimaryNetworkConnectionIndex':
3535 parsed_respond
['primarynetwork'] = adapters
.text
3536 if adapter_key
== 'NetworkConnection':
3538 if 'network' in adapters
.attrib
:
3539 vnic
['network'] = adapters
.attrib
['network']
3540 for adapter
in adapters
:
3541 setting_key
= adapter
.tag
.split("}")[1]
3542 vnic
[setting_key
] = adapter
.text
3543 nic_list
.append(vnic
)
3545 for link
in children_section
:
3546 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
3547 if link
.attrib
['rel'] == 'screen:acquireTicket':
3548 parsed_respond
['acquireTicket'] = link
.attrib
3549 if link
.attrib
['rel'] == 'screen:acquireMksTicket':
3550 parsed_respond
['acquireMksTicket'] = link
.attrib
3552 parsed_respond
['interfaces'] = nic_list
3553 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
3554 if vCloud_extension_section
is not None:
3555 vm_vcenter_info
= {}
3556 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
3557 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
3558 if vmext
is not None:
3559 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
3560 parsed_respond
["vm_vcenter_info"]= vm_vcenter_info
3562 virtual_hardware_section
= children_section
.find('ovf:VirtualHardwareSection', namespaces
)
3563 vm_virtual_hardware_info
= {}
3564 if virtual_hardware_section
is not None:
3565 for item
in virtual_hardware_section
.iterfind('ovf:Item',namespaces
):
3566 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
3567 disk_size
= item
.find("rasd:HostResource" ,namespaces
3568 ).attrib
["{"+namespaces
['vm']+"}capacity"]
3570 vm_virtual_hardware_info
["disk_size"]= disk_size
3573 for link
in virtual_hardware_section
:
3574 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
3575 if link
.attrib
['rel'] == 'edit' and link
.attrib
['href'].endswith("/disks"):
3576 vm_virtual_hardware_info
["disk_edit_href"] = link
.attrib
['href']
3579 parsed_respond
["vm_virtual_hardware"]= vm_virtual_hardware_info
3580 except Exception as exp
:
3581 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
3582 return parsed_respond
3584 def acquire_console(self
, vm_uuid
=None):
3588 if self
.client
._session
:
3589 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3590 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3591 vm_dict
= self
.get_vapp_details_rest(vapp_uuid
=vm_uuid
)
3592 console_dict
= vm_dict
['acquireTicket']
3593 console_rest_call
= console_dict
['href']
3595 response
= self
.perform_request(req_type
='POST',
3596 url
=console_rest_call
,
3599 if response
.status_code
== 403:
3600 response
= self
.retry_rest('POST', console_rest_call
)
3602 if response
.status_code
== requests
.codes
.ok
:
3603 return response
.content
3607 def modify_vm_disk(self
, vapp_uuid
, flavor_disk
):
3609 Method retrieve vm disk details
3612 vapp_uuid - is vapp identifier.
3613 flavor_disk - disk size as specified in VNFD (flavor)
3616 The return network uuid or return None
3620 #Flavor disk is in GB convert it into MB
3621 flavor_disk
= int(flavor_disk
) * 1024
3622 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
3624 vm_name
= vm_details
["name"]
3625 self
.logger
.info("VM: {} flavor_disk :{}".format(vm_name
, flavor_disk
))
3627 if vm_details
and "vm_virtual_hardware" in vm_details
:
3628 vm_disk
= int(vm_details
["vm_virtual_hardware"]["disk_size"])
3629 disk_edit_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
3631 self
.logger
.info("VM: {} VM_disk :{}".format(vm_name
, vm_disk
))
3633 if flavor_disk
> vm_disk
:
3634 status
= self
.modify_vm_disk_rest(disk_edit_href
,flavor_disk
)
3635 self
.logger
.info("Modify disk of VM {} from {} to {} MB".format(vm_name
,
3636 vm_disk
, flavor_disk
))
3639 self
.logger
.info("No need to modify disk of VM {}".format(vm_name
))
3642 except Exception as exp
:
3643 self
.logger
.info("Error occurred while modifing disk size {}".format(exp
))
3646 def modify_vm_disk_rest(self
, disk_href
, disk_size
):
3648 Method retrieve modify vm disk size
3651 disk_href - vCD API URL to GET and PUT disk data
3652 disk_size - disk size as specified in VNFD (flavor)
3655 The return network uuid or return None
3657 if disk_href
is None or disk_size
is None:
3660 if self
.client
._session
:
3661 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3662 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3663 response
= self
.perform_request(req_type
='GET',
3667 if response
.status_code
== 403:
3668 response
= self
.retry_rest('GET', disk_href
)
3670 if response
.status_code
!= requests
.codes
.ok
:
3671 self
.logger
.debug("GET REST API call {} failed. Return status code {}".format(disk_href
,
3672 response
.status_code
))
3675 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
3676 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
3678 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
3679 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
3681 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
3682 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
3683 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
3684 if disk_item
is not None:
3685 disk_item
.attrib
["{"+namespaces
['xmlns']+"}capacity"] = str(disk_size
)
3688 data
= lxmlElementTree
.tostring(lxmlroot_respond
, encoding
='utf8', method
='xml',
3689 xml_declaration
=True)
3691 #Send PUT request to modify disk size
3692 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
3694 response
= self
.perform_request(req_type
='PUT',
3698 if response
.status_code
== 403:
3699 add_headers
= {'Content-Type': headers
['Content-Type']}
3700 response
= self
.retry_rest('PUT', disk_href
, add_headers
, data
)
3702 if response
.status_code
!= 202:
3703 self
.logger
.debug("PUT REST API call {} failed. Return status code {}".format(disk_href
,
3704 response
.status_code
))
3706 modify_disk_task
= self
.get_task_from_response(response
.content
)
3707 result
= self
.client
.get_task_monitor().wait_for_success(task
=modify_disk_task
)
3708 if result
.get('status') == 'success':
3714 except Exception as exp
:
3715 self
.logger
.info("Error occurred calling rest api for modifing disk size {}".format(exp
))
3718 def add_pci_devices(self
, vapp_uuid
, pci_devices
, vmname_andid
):
3720 Method to attach pci devices to VM
3723 vapp_uuid - uuid of vApp/VM
3724 pci_devices - pci devices infromation as specified in VNFD (flavor)
3727 The status of add pci device task , vm object and
3728 vcenter_conect object
3731 self
.logger
.info("Add pci devices {} into vApp {}".format(pci_devices
, vapp_uuid
))
3732 vcenter_conect
, content
= self
.get_vcenter_content()
3733 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
3737 no_of_pci_devices
= len(pci_devices
)
3738 if no_of_pci_devices
> 0:
3739 #Get VM and its host
3740 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
3741 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
3742 if host_obj
and vm_obj
:
3743 #get PCI devies from host on which vapp is currently installed
3744 avilable_pci_devices
= self
.get_pci_devices(host_obj
, no_of_pci_devices
)
3746 if avilable_pci_devices
is None:
3747 #find other hosts with active pci devices
3748 new_host_obj
, avilable_pci_devices
= self
.get_host_and_PCIdevices(
3753 if new_host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
3754 #Migrate vm to the host where PCI devices are availble
3755 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
, new_host_obj
))
3756 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
3757 if task
is not None:
3758 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
3759 self
.logger
.info("Migrate VM status: {}".format(result
))
3760 host_obj
= new_host_obj
3762 self
.logger
.info("Fail to migrate VM : {}".format(result
))
3763 raise vimconn
.vimconnNotFoundException(
3764 "Fail to migrate VM : {} to host {}".format(
3769 if host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
3770 #Add PCI devices one by one
3771 for pci_device
in avilable_pci_devices
:
3772 task
= self
.add_pci_to_vm(host_obj
, vm_obj
, pci_device
)
3774 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
3776 self
.logger
.info("Added PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
3778 self
.logger
.error("Fail to add PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
3779 return True, vm_obj
, vcenter_conect
3781 self
.logger
.error("Currently there is no host with"\
3782 " {} number of avaialble PCI devices required for VM {}".format(
3786 raise vimconn
.vimconnNotFoundException(
3787 "Currently there is no host with {} "\
3788 "number of avaialble PCI devices required for VM {}".format(
3792 self
.logger
.debug("No infromation about PCI devices {} ",pci_devices
)
3794 except vmodl
.MethodFault
as error
:
3795 self
.logger
.error("Error occurred while adding PCI devices {} ",error
)
3796 return None, vm_obj
, vcenter_conect
3798 def get_vm_obj(self
, content
, mob_id
):
3800 Method to get the vsphere VM object associated with a given morf ID
3802 vapp_uuid - uuid of vApp/VM
3803 content - vCenter content object
3804 mob_id - mob_id of VM
3812 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
3813 [vim
.VirtualMachine
], True
3815 for vm
in container
.view
:
3816 mobID
= vm
._GetMoId
()
3819 host_obj
= vm_obj
.runtime
.host
3821 except Exception as exp
:
3822 self
.logger
.error("Error occurred while finding VM object : {}".format(exp
))
3823 return host_obj
, vm_obj
3825 def get_pci_devices(self
, host
, need_devices
):
3827 Method to get the details of pci devices on given host
3829 host - vSphere host object
3830 need_devices - number of pci devices needed on host
3833 array of pci devices
3837 used_devices_ids
= []
3841 pciPassthruInfo
= host
.config
.pciPassthruInfo
3842 pciDevies
= host
.hardware
.pciDevice
3844 for pci_status
in pciPassthruInfo
:
3845 if pci_status
.passthruActive
:
3846 for device
in pciDevies
:
3847 if device
.id == pci_status
.id:
3848 all_device_ids
.append(device
.id)
3849 all_devices
.append(device
)
3851 #check if devices are in use
3852 avalible_devices
= all_devices
3854 if vm
.runtime
.powerState
== vim
.VirtualMachinePowerState
.poweredOn
:
3855 vm_devices
= vm
.config
.hardware
.device
3856 for device
in vm_devices
:
3857 if type(device
) is vim
.vm
.device
.VirtualPCIPassthrough
:
3858 if device
.backing
.id in all_device_ids
:
3859 for use_device
in avalible_devices
:
3860 if use_device
.id == device
.backing
.id:
3861 avalible_devices
.remove(use_device
)
3862 used_devices_ids
.append(device
.backing
.id)
3863 self
.logger
.debug("Device {} from devices {}"\
3864 "is in use".format(device
.backing
.id,
3867 if len(avalible_devices
) < need_devices
:
3868 self
.logger
.debug("Host {} don't have {} number of active devices".format(host
,
3870 self
.logger
.debug("found only {} devives {}".format(len(avalible_devices
),
3874 required_devices
= avalible_devices
[:need_devices
]
3875 self
.logger
.info("Found {} PCI devivces on host {} but required only {}".format(
3876 len(avalible_devices
),
3879 self
.logger
.info("Retruning {} devices as {}".format(need_devices
,
3881 return required_devices
3883 except Exception as exp
:
3884 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host
))
3888 def get_host_and_PCIdevices(self
, content
, need_devices
):
3890 Method to get the details of pci devices infromation on all hosts
3893 content - vSphere host object
3894 need_devices - number of pci devices needed on host
3897 array of pci devices and host object
3900 pci_device_objs
= None
3903 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
3904 [vim
.HostSystem
], True)
3905 for host
in container
.view
:
3906 devices
= self
.get_pci_devices(host
, need_devices
)
3909 pci_device_objs
= devices
3911 except Exception as exp
:
3912 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host_obj
))
3914 return host_obj
,pci_device_objs
3916 def relocate_vm(self
, dest_host
, vm
) :
3918 Method to get the relocate VM to new host
3921 dest_host - vSphere host object
3922 vm - vSphere VM object
3929 relocate_spec
= vim
.vm
.RelocateSpec(host
=dest_host
)
3930 task
= vm
.Relocate(relocate_spec
)
3931 self
.logger
.info("Migrating {} to destination host {}".format(vm
, dest_host
))
3932 except Exception as exp
:
3933 self
.logger
.error("Error occurred while relocate VM {} to new host {}: {}".format(
3934 dest_host
, vm
, exp
))
3937 def wait_for_vcenter_task(self
, task
, actionName
='job', hideResult
=False):
3939 Waits and provides updates on a vSphere task
3941 while task
.info
.state
== vim
.TaskInfo
.State
.running
:
3944 if task
.info
.state
== vim
.TaskInfo
.State
.success
:
3945 if task
.info
.result
is not None and not hideResult
:
3946 self
.logger
.info('{} completed successfully, result: {}'.format(
3950 self
.logger
.info('Task {} completed successfully.'.format(actionName
))
3952 self
.logger
.error('{} did not complete successfully: {} '.format(
3957 return task
.info
.result
3959 def add_pci_to_vm(self
,host_object
, vm_object
, host_pci_dev
):
3961 Method to add pci device in given VM
3964 host_object - vSphere host object
3965 vm_object - vSphere VM object
3966 host_pci_dev - host_pci_dev must be one of the devices from the
3967 host_object.hardware.pciDevice list
3968 which is configured as a PCI passthrough device
3974 if vm_object
and host_object
and host_pci_dev
:
3976 #Add PCI device to VM
3977 pci_passthroughs
= vm_object
.environmentBrowser
.QueryConfigTarget(host
=None).pciPassthrough
3978 systemid_by_pciid
= {item
.pciDevice
.id: item
.systemId
for item
in pci_passthroughs
}
3980 if host_pci_dev
.id not in systemid_by_pciid
:
3981 self
.logger
.error("Device {} is not a passthrough device ".format(host_pci_dev
))
3984 deviceId
= hex(host_pci_dev
.deviceId
% 2**16).lstrip('0x')
3985 backing
= vim
.VirtualPCIPassthroughDeviceBackingInfo(deviceId
=deviceId
,
3987 systemId
=systemid_by_pciid
[host_pci_dev
.id],
3988 vendorId
=host_pci_dev
.vendorId
,
3989 deviceName
=host_pci_dev
.deviceName
)
3991 hba_object
= vim
.VirtualPCIPassthrough(key
=-100, backing
=backing
)
3993 new_device_config
= vim
.VirtualDeviceConfigSpec(device
=hba_object
)
3994 new_device_config
.operation
= "add"
3995 vmConfigSpec
= vim
.vm
.ConfigSpec()
3996 vmConfigSpec
.deviceChange
= [new_device_config
]
3998 task
= vm_object
.ReconfigVM_Task(spec
=vmConfigSpec
)
3999 self
.logger
.info("Adding PCI device {} into VM {} from host {} ".format(
4000 host_pci_dev
, vm_object
, host_object
)
4002 except Exception as exp
:
4003 self
.logger
.error("Error occurred while adding pci devive {} to VM {}: {}".format(
4009 def get_vm_vcenter_info(self
):
4011 Method to get details of vCenter and vm
4014 vapp_uuid - uuid of vApp or VM
4017 Moref Id of VM and deails of vCenter
4019 vm_vcenter_info
= {}
4021 if self
.vcenter_ip
is not None:
4022 vm_vcenter_info
["vm_vcenter_ip"] = self
.vcenter_ip
4024 raise vimconn
.vimconnException(message
="vCenter IP is not provided."\
4025 " Please provide vCenter IP while attaching datacenter to tenant in --config")
4026 if self
.vcenter_port
is not None:
4027 vm_vcenter_info
["vm_vcenter_port"] = self
.vcenter_port
4029 raise vimconn
.vimconnException(message
="vCenter port is not provided."\
4030 " Please provide vCenter port while attaching datacenter to tenant in --config")
4031 if self
.vcenter_user
is not None:
4032 vm_vcenter_info
["vm_vcenter_user"] = self
.vcenter_user
4034 raise vimconn
.vimconnException(message
="vCenter user is not provided."\
4035 " Please provide vCenter user while attaching datacenter to tenant in --config")
4037 if self
.vcenter_password
is not None:
4038 vm_vcenter_info
["vm_vcenter_password"] = self
.vcenter_password
4040 raise vimconn
.vimconnException(message
="vCenter user password is not provided."\
4041 " Please provide vCenter user password while attaching datacenter to tenant in --config")
4043 return vm_vcenter_info
4046 def get_vm_pci_details(self
, vmuuid
):
4048 Method to get VM PCI device details from vCenter
4051 vm_obj - vSphere VM object
4054 dict of PCI devives attached to VM
4057 vm_pci_devices_info
= {}
4059 vcenter_conect
, content
= self
.get_vcenter_content()
4060 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
4062 #Get VM and its host
4064 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4065 if host_obj
and vm_obj
:
4066 vm_pci_devices_info
["host_name"]= host_obj
.name
4067 vm_pci_devices_info
["host_ip"]= host_obj
.config
.network
.vnic
[0].spec
.ip
.ipAddress
4068 for device
in vm_obj
.config
.hardware
.device
:
4069 if type(device
) == vim
.vm
.device
.VirtualPCIPassthrough
:
4070 device_details
={'devide_id':device
.backing
.id,
4071 'pciSlotNumber':device
.slotInfo
.pciSlotNumber
,
4073 vm_pci_devices_info
[device
.deviceInfo
.label
] = device_details
4075 self
.logger
.error("Can not connect to vCenter while getting "\
4076 "PCI devices infromationn")
4077 return vm_pci_devices_info
4078 except Exception as exp
:
4079 self
.logger
.error("Error occurred while getting VM infromationn"\
4080 " for VM : {}".format(exp
))
4081 raise vimconn
.vimconnException(message
=exp
)
4083 def add_network_adapter_to_vms(self
, vapp
, network_name
, primary_nic_index
, nicIndex
, net
, nic_type
=None):
4085 Method to add network adapter type to vm
4087 network_name - name of network
4088 primary_nic_index - int value for primary nic index
4089 nicIndex - int value for nic index
4090 nic_type - specify model name to which add to vm
4099 if 'floating_ip' in net
: floating_ip
= net
['floating_ip']
4101 # Stub for ip_address feature
4102 if 'ip_address' in net
: ip_address
= net
['ip_address']
4104 if 'mac_address' in net
: mac_address
= net
['mac_address']
4107 allocation_mode
= "POOL"
4109 allocation_mode
= "MANUAL"
4111 allocation_mode
= "DHCP"
4114 for vms
in vapp
.get_all_vms():
4115 vm_id
= vms
.get('id').split(':')[-1]
4117 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
4119 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4120 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4121 response
= self
.perform_request(req_type
='GET',
4125 if response
.status_code
== 403:
4126 response
= self
.retry_rest('GET', url_rest_call
)
4128 if response
.status_code
!= 200:
4129 self
.logger
.error("REST call {} failed reason : {}"\
4130 "status code : {}".format(url_rest_call
,
4132 response
.status_code
))
4133 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
4134 "network connection section")
4136 data
= response
.content
4137 data
= data
.split('<Link rel="edit"')[0]
4138 if '<PrimaryNetworkConnectionIndex>' not in data
:
4139 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
4140 <NetworkConnection network="{}">
4141 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4142 <IsConnected>true</IsConnected>
4143 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4144 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
4146 # Stub for ip_address feature
4148 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4149 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4152 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4153 item
= item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4155 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item
))
4157 new_item
= """<NetworkConnection network="{}">
4158 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4159 <IsConnected>true</IsConnected>
4160 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4161 </NetworkConnection>""".format(network_name
, nicIndex
,
4163 # Stub for ip_address feature
4165 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4166 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4169 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4170 new_item
= new_item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4172 data
= data
+ new_item
+ '</NetworkConnectionSection>'
4174 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
4176 response
= self
.perform_request(req_type
='PUT',
4181 if response
.status_code
== 403:
4182 add_headers
= {'Content-Type': headers
['Content-Type']}
4183 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
4185 if response
.status_code
!= 202:
4186 self
.logger
.error("REST call {} failed reason : {}"\
4187 "status code : {} ".format(url_rest_call
,
4189 response
.status_code
))
4190 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
4191 "network connection section")
4193 nic_task
= self
.get_task_from_response(response
.content
)
4194 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
4195 if result
.get('status') == 'success':
4196 self
.logger
.info("add_network_adapter_to_vms(): VM {} conneced to "\
4197 "default NIC type".format(vm_id
))
4199 self
.logger
.error("add_network_adapter_to_vms(): VM {} failed to "\
4200 "connect NIC type".format(vm_id
))
4202 for vms
in vapp
.get_all_vms():
4203 vm_id
= vms
.get('id').split(':')[-1]
4206 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
4208 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4209 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4210 response
= self
.perform_request(req_type
='GET',
4214 if response
.status_code
== 403:
4215 response
= self
.retry_rest('GET', url_rest_call
)
4217 if response
.status_code
!= 200:
4218 self
.logger
.error("REST call {} failed reason : {}"\
4219 "status code : {}".format(url_rest_call
,
4221 response
.status_code
))
4222 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
4223 "network connection section")
4224 data
= response
.content
4225 data
= data
.split('<Link rel="edit"')[0]
4226 if '<PrimaryNetworkConnectionIndex>' not in data
:
4227 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
4228 <NetworkConnection network="{}">
4229 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4230 <IsConnected>true</IsConnected>
4231 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4232 <NetworkAdapterType>{}</NetworkAdapterType>
4233 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
4234 allocation_mode
, nic_type
)
4235 # Stub for ip_address feature
4237 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4238 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4241 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4242 item
= item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4244 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item
))
4246 new_item
= """<NetworkConnection network="{}">
4247 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
4248 <IsConnected>true</IsConnected>
4249 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
4250 <NetworkAdapterType>{}</NetworkAdapterType>
4251 </NetworkConnection>""".format(network_name
, nicIndex
,
4252 allocation_mode
, nic_type
)
4253 # Stub for ip_address feature
4255 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
4256 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
4259 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
4260 new_item
= new_item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
4262 data
= data
+ new_item
+ '</NetworkConnectionSection>'
4264 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
4266 response
= self
.perform_request(req_type
='PUT',
4271 if response
.status_code
== 403:
4272 add_headers
= {'Content-Type': headers
['Content-Type']}
4273 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
4275 if response
.status_code
!= 202:
4276 self
.logger
.error("REST call {} failed reason : {}"\
4277 "status code : {}".format(url_rest_call
,
4279 response
.status_code
))
4280 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
4281 "network connection section")
4283 nic_task
= self
.get_task_from_response(response
.content
)
4284 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
4285 if result
.get('status') == 'success':
4286 self
.logger
.info("add_network_adapter_to_vms(): VM {} "\
4287 "conneced to NIC type {}".format(vm_id
, nic_type
))
4289 self
.logger
.error("add_network_adapter_to_vms(): VM {} "\
4290 "failed to connect NIC type {}".format(vm_id
, nic_type
))
4291 except Exception as exp
:
4292 self
.logger
.error("add_network_adapter_to_vms() : exception occurred "\
4293 "while adding Network adapter")
4294 raise vimconn
.vimconnException(message
=exp
)
4297 def set_numa_affinity(self
, vmuuid
, paired_threads_id
):
4299 Method to assign numa affinity in vm configuration parammeters
4302 paired_threads_id - one or more virtual processor
4308 vcenter_conect
, content
= self
.get_vcenter_content()
4309 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
4311 host_obj
, vm_obj
= self
.get_vm_obj(content
,vm_moref_id
)
4313 config_spec
= vim
.vm
.ConfigSpec()
4314 config_spec
.extraConfig
= []
4315 opt
= vim
.option
.OptionValue()
4316 opt
.key
= 'numa.nodeAffinity'
4317 opt
.value
= str(paired_threads_id
)
4318 config_spec
.extraConfig
.append(opt
)
4319 task
= vm_obj
.ReconfigVM_Task(config_spec
)
4321 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4322 extra_config
= vm_obj
.config
.extraConfig
4324 for opts
in extra_config
:
4325 if 'numa.nodeAffinity' in opts
.key
:
4327 self
.logger
.info("set_numa_affinity: Sucessfully assign numa affinity "\
4328 "value {} for vm {}".format(opt
.value
, vm_obj
))
4332 self
.logger
.error("set_numa_affinity: Failed to assign numa affinity")
4333 except Exception as exp
:
4334 self
.logger
.error("set_numa_affinity : exception occurred while setting numa affinity "\
4335 "for VM {} : {}".format(vm_obj
, vm_moref_id
))
4336 raise vimconn
.vimconnException("set_numa_affinity : Error {} failed to assign numa "\
4337 "affinity".format(exp
))
4340 def cloud_init(self
, vapp
, cloud_config
):
4342 Method to inject ssh-key
4344 cloud_config a dictionary with:
4345 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
4346 'users': (optional) list of users to be inserted, each item is a dict with:
4347 'name': (mandatory) user name,
4348 'key-pairs': (optional) list of strings with the public key to be inserted to the user
4349 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
4350 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
4351 'config-files': (optional). List of files to be transferred. Each item is a dict with:
4352 'dest': (mandatory) string with the destination absolute path
4353 'encoding': (optional, by default text). Can be one of:
4354 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
4355 'content' (mandatory): string with the content of the file
4356 'permissions': (optional) string with file permissions, typically octal notation '0644'
4357 'owner': (optional) file owner, string with the format 'owner:group'
4358 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk
4361 if not isinstance(cloud_config
, dict):
4362 raise Exception("cloud_init : parameter cloud_config is not a dictionary")
4366 if "key-pairs" in cloud_config
:
4367 key_pairs
= cloud_config
["key-pairs"]
4369 if "users" in cloud_config
:
4370 userdata
= cloud_config
["users"]
4372 self
.logger
.debug("cloud_init : Guest os customization started..")
4373 customize_script
= self
.format_script(key_pairs
=key_pairs
, users_list
=userdata
)
4374 customize_script
= customize_script
.replace("&","&")
4375 self
.guest_customization(vapp
, customize_script
)
4377 except Exception as exp
:
4378 self
.logger
.error("cloud_init : exception occurred while injecting "\
4380 raise vimconn
.vimconnException("cloud_init : Error {} failed to inject "\
4381 "ssh-key".format(exp
))
4383 def format_script(self
, key_pairs
=[], users_list
=[]):
4384 bash_script
= """#!/bin/sh
4385 echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
4386 if [ "$1" = "precustomization" ];then
4387 echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
4390 keys
= "\n".join(key_pairs
)
4393 if [ ! -d /root/.ssh ];then
4395 chown root:root /root/.ssh
4396 chmod 700 /root/.ssh
4397 touch /root/.ssh/authorized_keys
4398 chown root:root /root/.ssh/authorized_keys
4399 chmod 600 /root/.ssh/authorized_keys
4400 # make centos with selinux happy
4401 which restorecon && restorecon -Rv /root/.ssh
4403 touch /root/.ssh/authorized_keys
4404 chown root:root /root/.ssh/authorized_keys
4405 chmod 600 /root/.ssh/authorized_keys
4407 echo '{key}' >> /root/.ssh/authorized_keys
4408 """.format(key
=keys
)
4410 bash_script
+= keys_data
4412 for user
in users_list
:
4413 if 'name' in user
: user_name
= user
['name']
4414 if 'key-pairs' in user
:
4415 user_keys
= "\n".join(user
['key-pairs'])
4420 useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
4421 """.format(user_name
=user_name
)
4423 bash_script
+= add_user_name
4426 user_keys_data
= """
4427 mkdir /home/{user_name}/.ssh
4428 chown {user_name}:{user_name} /home/{user_name}/.ssh
4429 chmod 700 /home/{user_name}/.ssh
4430 touch /home/{user_name}/.ssh/authorized_keys
4431 chown {user_name}:{user_name} /home/{user_name}/.ssh/authorized_keys
4432 chmod 600 /home/{user_name}/.ssh/authorized_keys
4433 # make centos with selinux happy
4434 which restorecon && restorecon -Rv /home/{user_name}/.ssh
4435 echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
4436 """.format(user_name
=user_name
,user_key
=user_keys
)
4438 bash_script
+= user_keys_data
4440 return bash_script
+"\n\tfi"
4442 def guest_customization(self
, vapp
, customize_script
):
4444 Method to customize guest os
4446 customize_script - Customize script to be run at first boot of VM.
4448 for vm
in vapp
.get_all_vms():
4449 vm_id
= vm
.get('id').split(':')[-1]
4450 vm_name
= vm
.get('name')
4451 vm_name
= vm_name
.replace('_','-')
4453 vm_customization_url
= "{}/api/vApp/vm-{}/guestCustomizationSection/".format(self
.url
, vm_id
)
4454 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4455 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4457 headers
['Content-Type'] = "application/vnd.vmware.vcloud.guestCustomizationSection+xml"
4459 data
= """<GuestCustomizationSection
4460 xmlns="http://www.vmware.com/vcloud/v1.5"
4461 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
4462 ovf:required="false" href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
4463 <ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
4464 <Enabled>true</Enabled>
4465 <ChangeSid>false</ChangeSid>
4466 <VirtualMachineId>{}</VirtualMachineId>
4467 <JoinDomainEnabled>false</JoinDomainEnabled>
4468 <UseOrgSettings>false</UseOrgSettings>
4469 <AdminPasswordEnabled>false</AdminPasswordEnabled>
4470 <AdminPasswordAuto>true</AdminPasswordAuto>
4471 <AdminAutoLogonEnabled>false</AdminAutoLogonEnabled>
4472 <AdminAutoLogonCount>0</AdminAutoLogonCount>
4473 <ResetPasswordRequired>false</ResetPasswordRequired>
4474 <CustomizationScript>{}</CustomizationScript>
4475 <ComputerName>{}</ComputerName>
4476 <Link href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml" rel="edit"/>
4477 </GuestCustomizationSection>
4478 """.format(vm_customization_url
,
4482 vm_customization_url
)
4484 response
= self
.perform_request(req_type
='PUT',
4485 url
=vm_customization_url
,
4488 if response
.status_code
== 202:
4489 guest_task
= self
.get_task_from_response(response
.content
)
4490 self
.client
.get_task_monitor().wait_for_success(task
=guest_task
)
4491 self
.logger
.info("guest_customization : customized guest os task "\
4492 "completed for VM {}".format(vm_name
))
4494 self
.logger
.error("guest_customization : task for customized guest os"\
4495 "failed for VM {}".format(vm_name
))
4496 raise vimconn
.vimconnException("guest_customization : failed to perform"\
4497 "guest os customization on VM {}".format(vm_name
))
4499 def add_new_disk(self
, vapp_uuid
, disk_size
):
4501 Method to create an empty vm disk
4504 vapp_uuid - is vapp identifier.
4505 disk_size - size of disk to be created in GB
4513 #Disk size in GB, convert it into MB
4514 if disk_size
is not None:
4515 disk_size_mb
= int(disk_size
) * 1024
4516 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
4518 if vm_details
and "vm_virtual_hardware" in vm_details
:
4519 self
.logger
.info("Adding disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
4520 disk_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
4521 status
= self
.add_new_disk_rest(disk_href
, disk_size_mb
)
4523 except Exception as exp
:
4524 msg
= "Error occurred while creating new disk {}.".format(exp
)
4525 self
.rollback_newvm(vapp_uuid
, msg
)
4528 self
.logger
.info("Added new disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
4530 #If failed to add disk, delete VM
4531 msg
= "add_new_disk: Failed to add new disk to {}".format(vm_details
["name"])
4532 self
.rollback_newvm(vapp_uuid
, msg
)
4535 def add_new_disk_rest(self
, disk_href
, disk_size_mb
):
4537 Retrives vApp Disks section & add new empty disk
4540 disk_href: Disk section href to addd disk
4541 disk_size_mb: Disk size in MB
4543 Returns: Status of add new disk task
4546 if self
.client
._session
:
4547 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4548 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4549 response
= self
.perform_request(req_type
='GET',
4553 if response
.status_code
== 403:
4554 response
= self
.retry_rest('GET', disk_href
)
4556 if response
.status_code
!= requests
.codes
.ok
:
4557 self
.logger
.error("add_new_disk_rest: GET REST API call {} failed. Return status code {}"
4558 .format(disk_href
, response
.status_code
))
4561 #Find but type & max of instance IDs assigned to disks
4562 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
4563 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
4565 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
4566 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
4568 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
4569 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
4570 inst_id
= int(item
.find("rasd:InstanceID" ,namespaces
).text
)
4571 if inst_id
> instance_id
:
4572 instance_id
= inst_id
4573 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
4574 bus_subtype
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busSubType"]
4575 bus_type
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busType"]
4577 instance_id
= instance_id
+ 1
4578 new_item
= """<Item>
4579 <rasd:Description>Hard disk</rasd:Description>
4580 <rasd:ElementName>New disk</rasd:ElementName>
4582 xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
4583 vcloud:capacity="{}"
4584 vcloud:busSubType="{}"
4585 vcloud:busType="{}"></rasd:HostResource>
4586 <rasd:InstanceID>{}</rasd:InstanceID>
4587 <rasd:ResourceType>17</rasd:ResourceType>
4588 </Item>""".format(disk_size_mb
, bus_subtype
, bus_type
, instance_id
)
4590 new_data
= response
.content
4591 #Add new item at the bottom
4592 new_data
= new_data
.replace('</Item>\n</RasdItemsList>', '</Item>\n{}\n</RasdItemsList>'.format(new_item
))
4594 # Send PUT request to modify virtual hardware section with new disk
4595 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
4597 response
= self
.perform_request(req_type
='PUT',
4602 if response
.status_code
== 403:
4603 add_headers
= {'Content-Type': headers
['Content-Type']}
4604 response
= self
.retry_rest('PUT', disk_href
, add_headers
, new_data
)
4606 if response
.status_code
!= 202:
4607 self
.logger
.error("PUT REST API call {} failed. Return status code {}. Response Content:{}"
4608 .format(disk_href
, response
.status_code
, response
.content
))
4610 add_disk_task
= self
.get_task_from_response(response
.content
)
4611 result
= self
.client
.get_task_monitor().wait_for_success(task
=add_disk_task
)
4612 if result
.get('status') == 'success':
4615 self
.logger
.error("Add new disk REST task failed to add {} MB disk".format(disk_size_mb
))
4617 except Exception as exp
:
4618 self
.logger
.error("Error occurred calling rest api for creating new disk {}".format(exp
))
4623 def add_existing_disk(self
, catalogs
=None, image_id
=None, size
=None, template_name
=None, vapp_uuid
=None):
4625 Method to add existing disk to vm
4627 catalogs - List of VDC catalogs
4628 image_id - Catalog ID
4629 template_name - Name of template in catalog
4630 vapp_uuid - UUID of vApp
4635 vcenter_conect
, content
= self
.get_vcenter_content()
4636 #find moref-id of vm in image
4637 catalog_vm_info
= self
.get_vapp_template_details(catalogs
=catalogs
,
4641 if catalog_vm_info
and "vm_vcenter_info" in catalog_vm_info
:
4642 if "vm_moref_id" in catalog_vm_info
["vm_vcenter_info"]:
4643 catalog_vm_moref_id
= catalog_vm_info
["vm_vcenter_info"].get("vm_moref_id", None)
4644 if catalog_vm_moref_id
:
4645 self
.logger
.info("Moref_id of VM in catalog : {}" .format(catalog_vm_moref_id
))
4646 host
, catalog_vm_obj
= self
.get_vm_obj(content
, catalog_vm_moref_id
)
4649 disk_info
= self
.find_disk(catalog_vm_obj
)
4651 exp_msg
= "No VM with image id {} found".format(image_id
)
4652 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
4654 exp_msg
= "No Image found with image ID {} ".format(image_id
)
4655 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
4658 self
.logger
.info("Existing disk_info : {}".format(disk_info
))
4660 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
4661 host
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4663 status
= self
.add_disk(vcenter_conect
=vcenter_conect
,
4665 disk_info
=disk_info
,
4670 self
.logger
.info("Disk from image id {} added to {}".format(image_id
,
4674 msg
= "No disk found with image id {} to add in VM {}".format(
4677 self
.rollback_newvm(vapp_uuid
, msg
, exp_type
="NotFound")
4680 def find_disk(self
, vm_obj
):
4682 Method to find details of existing disk in VM
4684 vm_obj - vCenter object of VM
4685 image_id - Catalog ID
4687 disk_info : dict of disk details
4692 devices
= vm_obj
.config
.hardware
.device
4693 for device
in devices
:
4694 if type(device
) is vim
.vm
.device
.VirtualDisk
:
4695 if isinstance(device
.backing
,vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo
) and hasattr(device
.backing
, 'fileName'):
4696 disk_info
["full_path"] = device
.backing
.fileName
4697 disk_info
["datastore"] = device
.backing
.datastore
4698 disk_info
["capacityKB"] = device
.capacityInKB
4700 except Exception as exp
:
4701 self
.logger
.error("find_disk() : exception occurred while "\
4702 "getting existing disk details :{}".format(exp
))
4706 def add_disk(self
, vcenter_conect
=None, vm
=None, size
=None, vapp_uuid
=None, disk_info
={}):
4708 Method to add existing disk in VM
4710 vcenter_conect - vCenter content object
4711 vm - vCenter vm object
4712 disk_info : dict of disk details
4714 status : status of add disk task
4716 datastore
= disk_info
["datastore"] if "datastore" in disk_info
else None
4717 fullpath
= disk_info
["full_path"] if "full_path" in disk_info
else None
4718 capacityKB
= disk_info
["capacityKB"] if "capacityKB" in disk_info
else None
4719 if size
is not None:
4720 #Convert size from GB to KB
4721 sizeKB
= int(size
) * 1024 * 1024
4722 #compare size of existing disk and user given size.Assign whicherver is greater
4723 self
.logger
.info("Add Existing disk : sizeKB {} , capacityKB {}".format(
4724 sizeKB
, capacityKB
))
4725 if sizeKB
> capacityKB
:
4728 if datastore
and fullpath
and capacityKB
:
4730 spec
= vim
.vm
.ConfigSpec()
4731 # get all disks on a VM, set unit_number to the next available
4733 for dev
in vm
.config
.hardware
.device
:
4734 if hasattr(dev
.backing
, 'fileName'):
4735 unit_number
= int(dev
.unitNumber
) + 1
4736 # unit_number 7 reserved for scsi controller
4737 if unit_number
== 7:
4739 if isinstance(dev
, vim
.vm
.device
.VirtualDisk
):
4740 #vim.vm.device.VirtualSCSIController
4741 controller_key
= dev
.controllerKey
4743 self
.logger
.info("Add Existing disk : unit number {} , controller key {}".format(
4744 unit_number
, controller_key
))
4747 disk_spec
= vim
.vm
.device
.VirtualDeviceSpec()
4748 disk_spec
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
4749 disk_spec
.device
= vim
.vm
.device
.VirtualDisk()
4750 disk_spec
.device
.backing
= \
4751 vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo()
4752 disk_spec
.device
.backing
.thinProvisioned
= True
4753 disk_spec
.device
.backing
.diskMode
= 'persistent'
4754 disk_spec
.device
.backing
.datastore
= datastore
4755 disk_spec
.device
.backing
.fileName
= fullpath
4757 disk_spec
.device
.unitNumber
= unit_number
4758 disk_spec
.device
.capacityInKB
= capacityKB
4759 disk_spec
.device
.controllerKey
= controller_key
4760 dev_changes
.append(disk_spec
)
4761 spec
.deviceChange
= dev_changes
4762 task
= vm
.ReconfigVM_Task(spec
=spec
)
4763 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4765 except Exception as exp
:
4766 exp_msg
= "add_disk() : exception {} occurred while adding disk "\
4767 "{} to vm {}".format(exp
,
4770 self
.rollback_newvm(vapp_uuid
, exp_msg
)
4772 msg
= "add_disk() : Can not add disk to VM with disk info {} ".format(disk_info
)
4773 self
.rollback_newvm(vapp_uuid
, msg
)
4776 def get_vcenter_content(self
):
4778 Get the vsphere content object
4781 vm_vcenter_info
= self
.get_vm_vcenter_info()
4782 except Exception as exp
:
4783 self
.logger
.error("Error occurred while getting vCenter infromationn"\
4784 " for VM : {}".format(exp
))
4785 raise vimconn
.vimconnException(message
=exp
)
4788 if hasattr(ssl
, '_create_unverified_context'):
4789 context
= ssl
._create
_unverified
_context
()
4791 vcenter_conect
= SmartConnect(
4792 host
=vm_vcenter_info
["vm_vcenter_ip"],
4793 user
=vm_vcenter_info
["vm_vcenter_user"],
4794 pwd
=vm_vcenter_info
["vm_vcenter_password"],
4795 port
=int(vm_vcenter_info
["vm_vcenter_port"]),
4798 atexit
.register(Disconnect
, vcenter_conect
)
4799 content
= vcenter_conect
.RetrieveContent()
4800 return vcenter_conect
, content
4803 def get_vm_moref_id(self
, vapp_uuid
):
4805 Get the moref_id of given VM
4809 vm_details
= self
.get_vapp_details_rest(vapp_uuid
, need_admin_access
=True)
4810 if vm_details
and "vm_vcenter_info" in vm_details
:
4811 vm_moref_id
= vm_details
["vm_vcenter_info"].get("vm_moref_id", None)
4814 except Exception as exp
:
4815 self
.logger
.error("Error occurred while getting VM moref ID "\
4816 " for VM : {}".format(exp
))
4820 def get_vapp_template_details(self
, catalogs
=None, image_id
=None , template_name
=None):
4822 Method to get vApp template details
4824 catalogs - list of VDC catalogs
4825 image_id - Catalog ID to find
4826 template_name : template name in catalog
4828 parsed_respond : dict of vApp tempalte details
4830 parsed_response
= {}
4832 vca
= self
.connect_as_admin()
4834 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
4837 org
, vdc
= self
.get_vdc_details()
4838 catalog
= self
.get_catalog_obj(image_id
, catalogs
)
4840 items
= org
.get_catalog_item(catalog
.get('name'), catalog
.get('name'))
4841 catalog_items
= [items
.attrib
]
4843 if len(catalog_items
) == 1:
4844 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4845 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
4847 response
= self
.perform_request(req_type
='GET',
4848 url
=catalog_items
[0].get('href'),
4850 catalogItem
= XmlElementTree
.fromstring(response
.content
)
4851 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
4852 vapp_tempalte_href
= entity
.get("href")
4853 #get vapp details and parse moref id
4855 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
4856 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
4857 'vmw': 'http://www.vmware.com/schema/ovf',
4858 'vm': 'http://www.vmware.com/vcloud/v1.5',
4859 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
4860 'vmext':"http://www.vmware.com/vcloud/extension/v1.5",
4861 'xmlns':"http://www.vmware.com/vcloud/v1.5"
4865 response
= self
.perform_request(req_type
='GET',
4866 url
=vapp_tempalte_href
,
4869 if response
.status_code
!= requests
.codes
.ok
:
4870 self
.logger
.debug("REST API call {} failed. Return status code {}".format(
4871 vapp_tempalte_href
, response
.status_code
))
4874 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
4875 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
4876 if children_section
is not None:
4877 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
4878 if vCloud_extension_section
is not None:
4879 vm_vcenter_info
= {}
4880 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
4881 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
4882 if vmext
is not None:
4883 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
4884 parsed_response
["vm_vcenter_info"]= vm_vcenter_info
4886 except Exception as exp
:
4887 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
4889 return parsed_response
4892 def rollback_newvm(self
, vapp_uuid
, msg
, exp_type
="Genric"):
4894 Method to delete vApp
4896 vapp_uuid - vApp UUID
4897 msg - Error message to be logged
4898 exp_type : Exception type
4903 status
= self
.delete_vminstance(vapp_uuid
)
4906 self
.logger
.error(msg
)
4907 if exp_type
== "Genric":
4908 raise vimconn
.vimconnException(msg
)
4909 elif exp_type
== "NotFound":
4910 raise vimconn
.vimconnNotFoundException(message
=msg
)
4912 def add_sriov(self
, vapp_uuid
, sriov_nets
, vmname_andid
):
4914 Method to attach SRIOV adapters to VM
4917 vapp_uuid - uuid of vApp/VM
4918 sriov_nets - SRIOV devices infromation as specified in VNFD (flavor)
4919 vmname_andid - vmname
4922 The status of add SRIOV adapter task , vm object and
4923 vcenter_conect object
4926 vcenter_conect
, content
= self
.get_vcenter_content()
4927 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
4931 no_of_sriov_devices
= len(sriov_nets
)
4932 if no_of_sriov_devices
> 0:
4933 #Get VM and its host
4934 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4935 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
4936 if host_obj
and vm_obj
:
4937 #get SRIOV devies from host on which vapp is currently installed
4938 avilable_sriov_devices
= self
.get_sriov_devices(host_obj
,
4939 no_of_sriov_devices
,
4942 if len(avilable_sriov_devices
) == 0:
4943 #find other hosts with active pci devices
4944 new_host_obj
, avilable_sriov_devices
= self
.get_host_and_sriov_devices(
4946 no_of_sriov_devices
,
4949 if new_host_obj
is not None and len(avilable_sriov_devices
)> 0:
4950 #Migrate vm to the host where SRIOV devices are available
4951 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
,
4953 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
4954 if task
is not None:
4955 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4956 self
.logger
.info("Migrate VM status: {}".format(result
))
4957 host_obj
= new_host_obj
4959 self
.logger
.info("Fail to migrate VM : {}".format(result
))
4960 raise vimconn
.vimconnNotFoundException(
4961 "Fail to migrate VM : {} to host {}".format(
4966 if host_obj
is not None and avilable_sriov_devices
is not None and len(avilable_sriov_devices
)> 0:
4967 #Add SRIOV devices one by one
4968 for sriov_net
in sriov_nets
:
4969 network_name
= sriov_net
.get('net_id')
4970 dvs_portgr_name
= self
.create_dvPort_group(network_name
)
4971 if sriov_net
.get('type') == "VF" or sriov_net
.get('type') == "SR-IOV":
4972 #add vlan ID ,Modify portgroup for vlan ID
4973 self
.configure_vlanID(content
, vcenter_conect
, network_name
)
4975 task
= self
.add_sriov_to_vm(content
,
4979 avilable_sriov_devices
[0]
4982 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4984 self
.logger
.info("Added SRIOV {} to VM {}".format(
4985 no_of_sriov_devices
,
4988 self
.logger
.error("Fail to add SRIOV {} to VM {}".format(
4989 no_of_sriov_devices
,
4991 raise vimconn
.vimconnUnexpectedResponse(
4992 "Fail to add SRIOV adapter in VM ".format(str(vm_obj
))
4994 return True, vm_obj
, vcenter_conect
4996 self
.logger
.error("Currently there is no host with"\
4997 " {} number of avaialble SRIOV "\
4998 "VFs required for VM {}".format(
4999 no_of_sriov_devices
,
5002 raise vimconn
.vimconnNotFoundException(
5003 "Currently there is no host with {} "\
5004 "number of avaialble SRIOV devices required for VM {}".format(
5005 no_of_sriov_devices
,
5008 self
.logger
.debug("No infromation about SRIOV devices {} ",sriov_nets
)
5010 except vmodl
.MethodFault
as error
:
5011 self
.logger
.error("Error occurred while adding SRIOV {} ",error
)
5012 return None, vm_obj
, vcenter_conect
5015 def get_sriov_devices(self
,host
, no_of_vfs
):
5017 Method to get the details of SRIOV devices on given host
5019 host - vSphere host object
5020 no_of_vfs - number of VFs needed on host
5023 array of SRIOV devices
5027 for device
in host
.config
.pciPassthruInfo
:
5028 if isinstance(device
,vim
.host
.SriovInfo
) and device
.sriovActive
:
5029 if device
.numVirtualFunction
>= no_of_vfs
:
5030 sriovInfo
.append(device
)
5035 def get_host_and_sriov_devices(self
, content
, no_of_vfs
):
5037 Method to get the details of SRIOV devices infromation on all hosts
5040 content - vSphere host object
5041 no_of_vfs - number of pci VFs needed on host
5044 array of SRIOV devices and host object
5047 sriov_device_objs
= None
5050 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
5051 [vim
.HostSystem
], True)
5052 for host
in container
.view
:
5053 devices
= self
.get_sriov_devices(host
, no_of_vfs
)
5056 sriov_device_objs
= devices
5058 except Exception as exp
:
5059 self
.logger
.error("Error {} occurred while finding SRIOV devices on host: {}".format(exp
, host_obj
))
5061 return host_obj
,sriov_device_objs
5064 def add_sriov_to_vm(self
,content
, vm_obj
, host_obj
, network_name
, sriov_device
):
5066 Method to add SRIOV adapter to vm
5069 host_obj - vSphere host object
5070 vm_obj - vSphere vm object
5071 content - vCenter content object
5072 network_name - name of distributed virtaul portgroup
5073 sriov_device - SRIOV device info
5079 vnic_label
= "sriov nic"
5081 dvs_portgr
= self
.get_dvport_group(network_name
)
5082 network_name
= dvs_portgr
.name
5083 nic
= vim
.vm
.device
.VirtualDeviceSpec()
5085 nic
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
5086 nic
.device
= vim
.vm
.device
.VirtualSriovEthernetCard()
5087 nic
.device
.addressType
= 'assigned'
5088 #nic.device.key = 13016
5089 nic
.device
.deviceInfo
= vim
.Description()
5090 nic
.device
.deviceInfo
.label
= vnic_label
5091 nic
.device
.deviceInfo
.summary
= network_name
5092 nic
.device
.backing
= vim
.vm
.device
.VirtualEthernetCard
.NetworkBackingInfo()
5094 nic
.device
.backing
.network
= self
.get_obj(content
, [vim
.Network
], network_name
)
5095 nic
.device
.backing
.deviceName
= network_name
5096 nic
.device
.backing
.useAutoDetect
= False
5097 nic
.device
.connectable
= vim
.vm
.device
.VirtualDevice
.ConnectInfo()
5098 nic
.device
.connectable
.startConnected
= True
5099 nic
.device
.connectable
.allowGuestControl
= True
5101 nic
.device
.sriovBacking
= vim
.vm
.device
.VirtualSriovEthernetCard
.SriovBackingInfo()
5102 nic
.device
.sriovBacking
.physicalFunctionBacking
= vim
.vm
.device
.VirtualPCIPassthrough
.DeviceBackingInfo()
5103 nic
.device
.sriovBacking
.physicalFunctionBacking
.id = sriov_device
.id
5106 vmconf
= vim
.vm
.ConfigSpec(deviceChange
=devices
)
5107 task
= vm_obj
.ReconfigVM_Task(vmconf
)
5109 except Exception as exp
:
5110 self
.logger
.error("Error {} occurred while adding SRIOV adapter in VM: {}".format(exp
, vm_obj
))
5114 def create_dvPort_group(self
, network_name
):
5116 Method to create disributed virtual portgroup
5119 network_name - name of network/portgroup
5125 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
5126 network_name
=''.join(new_network_name
)
5127 vcenter_conect
, content
= self
.get_vcenter_content()
5129 dv_switch
= self
.get_obj(content
, [vim
.DistributedVirtualSwitch
], self
.dvs_name
)
5131 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
5132 dv_pg_spec
.name
= network_name
5134 dv_pg_spec
.type = vim
.dvs
.DistributedVirtualPortgroup
.PortgroupType
.earlyBinding
5135 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
5136 dv_pg_spec
.defaultPortConfig
.securityPolicy
= vim
.dvs
.VmwareDistributedVirtualSwitch
.SecurityPolicy()
5137 dv_pg_spec
.defaultPortConfig
.securityPolicy
.allowPromiscuous
= vim
.BoolPolicy(value
=False)
5138 dv_pg_spec
.defaultPortConfig
.securityPolicy
.forgedTransmits
= vim
.BoolPolicy(value
=False)
5139 dv_pg_spec
.defaultPortConfig
.securityPolicy
.macChanges
= vim
.BoolPolicy(value
=False)
5141 task
= dv_switch
.AddDVPortgroup_Task([dv_pg_spec
])
5142 self
.wait_for_vcenter_task(task
, vcenter_conect
)
5144 dvPort_group
= self
.get_obj(content
, [vim
.dvs
.DistributedVirtualPortgroup
], network_name
)
5146 self
.logger
.info("Created disributed virtaul port group: {}".format(dvPort_group
))
5147 return dvPort_group
.key
5149 self
.logger
.debug("No disributed virtual switch found with name {}".format(network_name
))
5151 except Exception as exp
:
5152 self
.logger
.error("Error occurred while creating disributed virtaul port group {}"\
5153 " : {}".format(network_name
, exp
))
5156 def reconfig_portgroup(self
, content
, dvPort_group_name
, config_info
={}):
5158 Method to reconfigure disributed virtual portgroup
5161 dvPort_group_name - name of disributed virtual portgroup
5162 content - vCenter content object
5163 config_info - disributed virtual portgroup configuration
5169 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
5171 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
5172 dv_pg_spec
.configVersion
= dvPort_group
.config
.configVersion
5173 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
5174 if "vlanID" in config_info
:
5175 dv_pg_spec
.defaultPortConfig
.vlan
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VlanIdSpec()
5176 dv_pg_spec
.defaultPortConfig
.vlan
.vlanId
= config_info
.get('vlanID')
5178 task
= dvPort_group
.ReconfigureDVPortgroup_Task(spec
=dv_pg_spec
)
5182 except Exception as exp
:
5183 self
.logger
.error("Error occurred while reconfiguraing disributed virtaul port group {}"\
5184 " : {}".format(dvPort_group_name
, exp
))
5188 def destroy_dvport_group(self
, dvPort_group_name
):
5190 Method to destroy disributed virtual portgroup
5193 network_name - name of network/portgroup
5196 True if portgroup successfully got deleted else false
5198 vcenter_conect
, content
= self
.get_vcenter_content()
5201 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
5203 task
= dvPort_group
.Destroy_Task()
5204 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5206 except vmodl
.MethodFault
as exp
:
5207 self
.logger
.error("Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
5208 exp
, dvPort_group_name
))
5212 def get_dvport_group(self
, dvPort_group_name
):
5214 Method to get disributed virtual portgroup
5217 network_name - name of network/portgroup
5222 vcenter_conect
, content
= self
.get_vcenter_content()
5225 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, [vim
.dvs
.DistributedVirtualPortgroup
], True)
5226 for item
in container
.view
:
5227 if item
.key
== dvPort_group_name
:
5231 except vmodl
.MethodFault
as exp
:
5232 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
5233 exp
, dvPort_group_name
))
5236 def get_vlanID_from_dvs_portgr(self
, dvPort_group_name
):
5238 Method to get disributed virtual portgroup vlanID
5241 network_name - name of network/portgroup
5248 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
5250 vlanId
= dvPort_group
.config
.defaultPortConfig
.vlan
.vlanId
5251 except vmodl
.MethodFault
as exp
:
5252 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
5253 exp
, dvPort_group_name
))
5257 def configure_vlanID(self
, content
, vcenter_conect
, dvPort_group_name
):
5259 Method to configure vlanID in disributed virtual portgroup vlanID
5262 network_name - name of network/portgroup
5267 vlanID
= self
.get_vlanID_from_dvs_portgr(dvPort_group_name
)
5270 vlanID
= self
.genrate_vlanID(dvPort_group_name
)
5271 config
= {"vlanID":vlanID
}
5272 task
= self
.reconfig_portgroup(content
, dvPort_group_name
,
5275 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5277 self
.logger
.info("Reconfigured Port group {} for vlan ID {}".format(
5278 dvPort_group_name
,vlanID
))
5280 self
.logger
.error("Fail reconfigure portgroup {} for vlanID{}".format(
5281 dvPort_group_name
, vlanID
))
5284 def genrate_vlanID(self
, network_name
):
5286 Method to get unused vlanID
5288 network_name - name of network/portgroup
5294 if self
.config
.get('vlanID_range') == None:
5295 raise vimconn
.vimconnConflictException("You must provide a 'vlanID_range' "\
5296 "at config value before creating sriov network with vlan tag")
5297 if "used_vlanIDs" not in self
.persistent_info
:
5298 self
.persistent_info
["used_vlanIDs"] = {}
5300 used_ids
= self
.persistent_info
["used_vlanIDs"].values()
5302 #used_ids = list(self.persistent_info["used_vlanIDs"].values())
5304 for vlanID_range
in self
.config
.get('vlanID_range'):
5305 start_vlanid
, end_vlanid
= vlanID_range
.split("-")
5306 if start_vlanid
> end_vlanid
:
5307 raise vimconn
.vimconnConflictException("Invalid vlan ID range {}".format(
5310 for id in xrange(int(start_vlanid
), int(end_vlanid
) + 1):
5312 #for id in range(int(start_vlanid), int(end_vlanid) + 1):
5313 if id not in used_ids
:
5315 self
.persistent_info
["used_vlanIDs"][network_name
] = vlan_id
5318 raise vimconn
.vimconnConflictException("All Vlan IDs are in use")
5321 def get_obj(self
, content
, vimtype
, name
):
5323 Get the vsphere object associated with a given text name
5326 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, vimtype
, True)
5327 for item
in container
.view
:
5328 if item
.name
== name
:
5334 def insert_media_to_vm(self
, vapp
, image_id
):
5336 Method to insert media CD-ROM (ISO image) from catalog to vm.
5337 vapp - vapp object to get vm id
5338 Image_id - image id for cdrom to be inerted to vm
5340 # create connection object
5341 vca
= self
.connect()
5343 # fetching catalog details
5344 rest_url
= "{}/api/catalog/{}".format(self
.url
, image_id
)
5346 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5347 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
5348 response
= self
.perform_request(req_type
='GET',
5352 if response
.status_code
!= 200:
5353 self
.logger
.error("REST call {} failed reason : {}"\
5354 "status code : {}".format(url_rest_call
,
5356 response
.status_code
))
5357 raise vimconn
.vimconnException("insert_media_to_vm(): Failed to get "\
5359 # searching iso name and id
5360 iso_name
,media_id
= self
.get_media_details(vca
, response
.content
)
5362 if iso_name
and media_id
:
5363 data
="""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
5364 <ns6:MediaInsertOrEjectParams
5365 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">
5367 type="application/vnd.vmware.vcloud.media+xml"
5369 id="urn:vcloud:media:{}"
5370 href="https://{}/api/media/{}"/>
5371 </ns6:MediaInsertOrEjectParams>""".format(iso_name
, media_id
,
5374 for vms
in vapp
.get_all_vms():
5375 vm_id
= vms
.get('id').split(':')[-1]
5377 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.mediaInsertOrEjectParams+xml'
5378 rest_url
= "{}/api/vApp/vm-{}/media/action/insertMedia".format(self
.url
,vm_id
)
5380 response
= self
.perform_request(req_type
='POST',
5385 if response
.status_code
!= 202:
5386 self
.logger
.error("Failed to insert CD-ROM to vm")
5387 raise vimconn
.vimconnException("insert_media_to_vm() : Failed to insert"\
5390 task
= self
.get_task_from_response(response
.content
)
5391 result
= self
.client
.get_task_monitor().wait_for_success(task
=task
)
5392 if result
.get('status') == 'success':
5393 self
.logger
.info("insert_media_to_vm(): Sucessfully inserted media ISO"\
5394 " image to vm {}".format(vm_id
))
5396 except Exception as exp
:
5397 self
.logger
.error("insert_media_to_vm() : exception occurred "\
5398 "while inserting media CD-ROM")
5399 raise vimconn
.vimconnException(message
=exp
)
5402 def get_media_details(self
, vca
, content
):
5404 Method to get catalog item details
5405 vca - connection object
5406 content - Catalog details
5407 Return - Media name, media id
5409 cataloghref_list
= []
5412 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
5413 for child
in vm_list_xmlroot
.iter():
5414 if 'CatalogItem' in child
.tag
:
5415 cataloghref_list
.append(child
.attrib
.get('href'))
5416 if cataloghref_list
is not None:
5417 for href
in cataloghref_list
:
5419 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5420 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
5421 response
= self
.perform_request(req_type
='GET',
5424 if response
.status_code
!= 200:
5425 self
.logger
.error("REST call {} failed reason : {}"\
5426 "status code : {}".format(href
,
5428 response
.status_code
))
5429 raise vimconn
.vimconnException("get_media_details : Failed to get "\
5430 "catalogitem details")
5431 list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
5432 for child
in list_xmlroot
.iter():
5433 if 'Entity' in child
.tag
:
5434 if 'media' in child
.attrib
.get('href'):
5435 name
= child
.attrib
.get('name')
5436 media_id
= child
.attrib
.get('href').split('/').pop()
5437 return name
,media_id
5439 self
.logger
.debug("Media name and id not found")
5441 except Exception as exp
:
5442 self
.logger
.error("get_media_details : exception occurred "\
5443 "getting media details")
5444 raise vimconn
.vimconnException(message
=exp
)
5447 def retry_rest(self
, method
, url
, add_headers
=None, data
=None):
5448 """ Method to get Token & retry respective REST request
5450 api - REST API - Can be one of 'GET' or 'PUT' or 'POST'
5451 url - request url to be used
5452 add_headers - Additional headers (optional)
5453 data - Request payload data to be passed in request
5455 response - Response of request
5462 if self
.client
._session
:
5463 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5464 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5467 headers
.update(add_headers
)
5470 response
= self
.perform_request(req_type
='GET',
5473 elif method
== 'PUT':
5474 response
= self
.perform_request(req_type
='PUT',
5478 elif method
== 'POST':
5479 response
= self
.perform_request(req_type
='POST',
5483 elif method
== 'DELETE':
5484 response
= self
.perform_request(req_type
='DELETE',
5490 def get_token(self
):
5491 """ Generate a new token if expired
5494 The return client object that letter can be used to connect to vCloud director as admin for VDC
5497 self
.logger
.debug("Generate token for vca {} as {} to datacenter {}.".format(self
.org_name
,
5501 client
= Client(host
, verify_ssl_certs
=False)
5502 client
.set_credentials(BasicLoginCredentials(self
.user
, self
.org_name
, self
.passwd
))
5504 self
.client
= client
5507 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
5508 "{} as user: {}".format(self
.org_name
, self
.user
))
5511 raise vimconn
.vimconnConnectionException("Failed while reconnecting vCD")
5514 def get_vdc_details(self
):
5515 """ Get VDC details using pyVcloud Lib
5517 Returns org and vdc object
5519 org
= Org(self
.client
, resource
=self
.client
.get_org())
5520 vdc
= org
.get_vdc(self
.tenant_name
)
5522 #Retry once, if failed by refreshing token
5525 vdc
= org
.get_vdc(self
.tenant_name
)
5530 def perform_request(self
, req_type
, url
, headers
=None, data
=None):
5531 """Perform the POST/PUT/GET/DELETE request."""
5533 #Log REST request details
5534 self
.log_request(req_type
, url
=url
, headers
=headers
, data
=data
)
5535 # perform request and return its result
5536 if req_type
== 'GET':
5537 response
= requests
.get(url
=url
,
5540 elif req_type
== 'PUT':
5541 response
= requests
.put(url
=url
,
5545 elif req_type
== 'POST':
5546 response
= requests
.post(url
=url
,
5550 elif req_type
== 'DELETE':
5551 response
= requests
.delete(url
=url
,
5554 #Log the REST response
5555 self
.log_response(response
)
5560 def log_request(self
, req_type
, url
=None, headers
=None, data
=None):
5561 """Logs REST request details"""
5563 if req_type
is not None:
5564 self
.logger
.debug("Request type: {}".format(req_type
))
5567 self
.logger
.debug("Request url: {}".format(url
))
5569 if headers
is not None:
5570 for header
in headers
:
5571 self
.logger
.debug("Request header: {}: {}".format(header
, headers
[header
]))
5573 if data
is not None:
5574 self
.logger
.debug("Request data: {}".format(data
))
5577 def log_response(self
, response
):
5578 """Logs REST response details"""
5580 self
.logger
.debug("Response status code: {} ".format(response
.status_code
))
5583 def get_task_from_response(self
, content
):
5585 content - API response content(response.content)
5588 xmlroot
= XmlElementTree
.fromstring(content
)
5589 if xmlroot
.tag
.split('}')[1] == "Task":
5593 if ele
.tag
.split("}")[1] == "Tasks":
5599 def power_on_vapp(self
,vapp_id
, vapp_name
):
5602 vapp_name - vAapp name
5603 return - Task object
5605 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5606 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5608 poweron_href
= "{}/api/vApp/vapp-{}/power/action/powerOn".format(self
.url
,
5610 response
= self
.perform_request(req_type
='POST',
5614 if response
.status_code
!= 202:
5615 self
.logger
.error("REST call {} failed reason : {}"\
5616 "status code : {} ".format(poweron_href
,
5618 response
.status_code
))
5619 raise vimconn
.vimconnException("power_on_vapp() : Failed to power on "\
5620 "vApp {}".format(vapp_name
))
5622 poweron_task
= self
.get_task_from_response(response
.content
)