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
41 from pyVmomi
import vim
, vmodl
42 from pyVim
.connect
import SmartConnect
, Disconnect
44 from xml
.etree
import ElementTree
as XmlElementTree
45 from lxml
import etree
as lxmlElementTree
48 from pyvcloud
.vcd
.client
import BasicLoginCredentials
,Client
,VcdTaskException
49 from pyvcloud
.vcd
.vdc
import VDC
50 from pyvcloud
.vcd
.org
import Org
52 from pyvcloud
.vcd
.vapp
import VApp
53 from xml
.sax
.saxutils
import escape
67 # global variable for vcd connector type
68 STANDALONE
= 'standalone'
70 # key for flavor dicts
71 FLAVOR_RAM_KEY
= 'ram'
72 FLAVOR_VCPUS_KEY
= 'vcpus'
73 FLAVOR_DISK_KEY
= 'disk'
74 DEFAULT_IP_PROFILE
= {'dhcp_count':50,
78 # global variable for wait time
84 __author__
= "Mustafa Bayramov, Arpita Kate, Sachin Bhangare, Prakash Kasar"
85 __date__
= "$09-Mar-2018 11:09:29$"
88 # -1: "Could not be created",
94 # 5: "Waiting for user input",
96 # 7: "Unrecognized state",
98 # 9: "Inconsistent state",
99 # 10: "Children do not all have the same status",
100 # 11: "Upload initiated, OVF descriptor pending",
101 # 12: "Upload initiated, copying contents",
102 # 13: "Upload initiated , disk contents pending",
103 # 14: "Upload has been quarantined",
104 # 15: "Upload quarantine period has expired"
106 # mapping vCD status to MANO
107 vcdStatusCode2manoFormat
= {4: 'ACTIVE',
116 netStatus2manoFormat
= {'ACTIVE': 'ACTIVE', 'PAUSED': 'PAUSED', 'INACTIVE': 'INACTIVE', 'BUILD': 'BUILD',
117 'ERROR': 'ERROR', 'DELETED': 'DELETED'
120 class vimconnector(vimconn
.vimconnector
):
121 # dict used to store flavor in memory
124 def __init__(self
, uuid
=None, name
=None, tenant_id
=None, tenant_name
=None,
125 url
=None, url_admin
=None, user
=None, passwd
=None, log_level
=None, config
={}, persistent_info
={}):
127 Constructor create vmware connector to vCloud director.
129 By default construct doesn't validate connection state. So client can create object with None arguments.
130 If client specified username , password and host and VDC name. Connector initialize other missing attributes.
132 a) It initialize organization UUID
133 b) Initialize tenant_id/vdc ID. (This information derived from tenant name)
136 uuid - is organization uuid.
137 name - is organization name that must be presented in vCloud director.
138 tenant_id - is VDC uuid it must be presented in vCloud director
139 tenant_name - is VDC name.
140 url - is hostname or ip address of vCloud director
141 url_admin - same as above.
142 user - is user that administrator for organization. Caller must make sure that
143 username has right privileges.
145 password - is password for a user.
147 VMware connector also requires PVDC administrative privileges and separate account.
148 This variables must be passed via config argument dict contains keys
150 dict['admin_username']
151 dict['admin_password']
152 config - Provide NSX and vCenter information
158 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
,
159 url_admin
, user
, passwd
, log_level
, config
)
161 self
.logger
= logging
.getLogger('openmano.vim.vmware')
162 self
.logger
.setLevel(10)
163 self
.persistent_info
= persistent_info
168 self
.url_admin
= url_admin
169 self
.tenant_id
= tenant_id
170 self
.tenant_name
= tenant_name
174 self
.admin_password
= None
175 self
.admin_user
= None
177 self
.nsx_manager
= None
179 self
.nsx_password
= None
180 self
.availability_zone
= None
182 # Disable warnings from self-signed certificates.
183 requests
.packages
.urllib3
.disable_warnings()
185 if tenant_name
is not None:
186 orgnameandtenant
= tenant_name
.split(":")
187 if len(orgnameandtenant
) == 2:
188 self
.tenant_name
= orgnameandtenant
[1]
189 self
.org_name
= orgnameandtenant
[0]
191 self
.tenant_name
= tenant_name
192 if "orgname" in config
:
193 self
.org_name
= config
['orgname']
196 self
.logger
.setLevel(getattr(logging
, log_level
))
199 self
.admin_user
= config
['admin_username']
200 self
.admin_password
= config
['admin_password']
202 raise vimconn
.vimconnException(message
="Error admin username or admin password is empty.")
205 self
.nsx_manager
= config
['nsx_manager']
206 self
.nsx_user
= config
['nsx_user']
207 self
.nsx_password
= config
['nsx_password']
209 raise vimconn
.vimconnException(message
="Error: nsx manager or nsx user or nsx password is empty in Config")
211 self
.vcenter_ip
= config
.get("vcenter_ip", None)
212 self
.vcenter_port
= config
.get("vcenter_port", None)
213 self
.vcenter_user
= config
.get("vcenter_user", None)
214 self
.vcenter_password
= config
.get("vcenter_password", None)
216 #Set availability zone for Affinity rules
217 self
.availability_zone
= self
.set_availability_zones()
219 # ############# Stub code for SRIOV #################
221 # self.dvs_name = config['dv_switch_name']
223 # raise vimconn.vimconnException(message="Error: distributed virtaul switch name is empty in Config")
225 # self.vlanID_range = config.get("vlanID_range", None)
231 raise vimconn
.vimconnException('url param can not be NoneType')
233 if not self
.url_admin
: # try to use normal url
234 self
.url_admin
= self
.url
236 logging
.debug("UUID: {} name: {} tenant_id: {} tenant name {}".format(self
.id, self
.org_name
,
237 self
.tenant_id
, self
.tenant_name
))
238 logging
.debug("vcd url {} vcd username: {} vcd password: {}".format(self
.url
, self
.user
, self
.passwd
))
239 logging
.debug("vcd admin username {} vcd admin passowrd {}".format(self
.admin_user
, self
.admin_password
))
241 # initialize organization
242 if self
.user
is not None and self
.passwd
is not None and self
.url
:
243 self
.init_organization()
245 def __getitem__(self
, index
):
248 if index
== 'tenant_id':
249 return self
.tenant_id
250 if index
== 'tenant_name':
251 return self
.tenant_name
254 elif index
== 'org_name':
256 elif index
== 'org_uuid':
258 elif index
== 'user':
260 elif index
== 'passwd':
264 elif index
== 'url_admin':
265 return self
.url_admin
266 elif index
== "config":
269 raise KeyError("Invalid key '%s'" % str(index
))
271 def __setitem__(self
, index
, value
):
274 if index
== 'tenant_id':
275 self
.tenant_id
= value
276 if index
== 'tenant_name':
277 self
.tenant_name
= value
280 elif index
== 'org_name':
281 self
.org_name
= value
282 elif index
== 'org_uuid':
283 self
.org_uuid
= value
284 elif index
== 'user':
286 elif index
== 'passwd':
290 elif index
== 'url_admin':
291 self
.url_admin
= value
293 raise KeyError("Invalid key '%s'" % str(index
))
295 def connect_as_admin(self
):
296 """ Method connect as pvdc admin user to vCloud director.
297 There are certain action that can be done only by provider vdc admin user.
298 Organization creation / provider network creation etc.
301 The return client object that latter can be used to connect to vcloud director as admin for provider vdc
303 self
.logger
.debug("Logging into vCD {} as admin.".format(self
.org_name
))
308 client_as_admin
= Client(host
, verify_ssl_certs
=False)
309 client_as_admin
.set_highest_supported_version()
310 client_as_admin
.set_credentials(BasicLoginCredentials(self
.admin_user
, org
, self
.admin_password
))
311 except Exception as e
:
312 raise vimconn
.vimconnException(
313 "Can't connect to a vCloud director as: {} with exception {}".format(self
.admin_user
, e
))
315 return client_as_admin
318 """ Method connect as normal user to vCloud director.
321 The return client object that latter can be used to connect to vCloud director as admin for VDC
324 self
.logger
.debug("Logging into vCD {} as {} to datacenter {}.".format(self
.org_name
,
328 client
= Client(host
, verify_ssl_certs
=False)
329 client
.set_highest_supported_version()
330 client
.set_credentials(BasicLoginCredentials(self
.user
, self
.org_name
, self
.passwd
))
332 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
333 "{} as user: {}".format(self
.org_name
, self
.user
))
337 def init_organization(self
):
338 """ Method initialize organization UUID and VDC parameters.
340 At bare minimum client must provide organization name that present in vCloud director and VDC.
342 The VDC - UUID ( tenant_id) will be initialized at the run time if client didn't call constructor.
343 The Org - UUID will be initialized at the run time if data center present in vCloud director.
346 The return vca object that letter can be used to connect to vcloud direct as admin
348 client
= self
.connect()
350 raise vimconn
.vimconnConnectionException("Failed to connect vCD.")
354 if self
.org_uuid
is None:
355 org_list
= client
.get_org_list()
356 for org
in org_list
.Org
:
357 # we set org UUID at the init phase but we can do it only when we have valid credential.
358 if org
.get('name') == self
.org_name
:
359 self
.org_uuid
= org
.get('href').split('/')[-1]
360 self
.logger
.debug("Setting organization UUID {}".format(self
.org_uuid
))
363 raise vimconn
.vimconnException("Vcloud director organization {} not found".format(self
.org_name
))
365 # if well good we require for org details
366 org_details_dict
= self
.get_org(org_uuid
=self
.org_uuid
)
368 # we have two case if we want to initialize VDC ID or VDC name at run time
369 # tenant_name provided but no tenant id
370 if self
.tenant_id
is None and self
.tenant_name
is not None and 'vdcs' in org_details_dict
:
371 vdcs_dict
= org_details_dict
['vdcs']
372 for vdc
in vdcs_dict
:
373 if vdcs_dict
[vdc
] == self
.tenant_name
:
375 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
379 raise vimconn
.vimconnException("Tenant name indicated but not present in vcloud director.")
380 # case two we have tenant_id but we don't have tenant name so we find and set it.
381 if self
.tenant_id
is not None and self
.tenant_name
is None and 'vdcs' in org_details_dict
:
382 vdcs_dict
= org_details_dict
['vdcs']
383 for vdc
in vdcs_dict
:
384 if vdc
== self
.tenant_id
:
385 self
.tenant_name
= vdcs_dict
[vdc
]
386 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
390 raise vimconn
.vimconnException("Tenant id indicated but not present in vcloud director")
391 self
.logger
.debug("Setting organization uuid {}".format(self
.org_uuid
))
393 self
.logger
.debug("Failed initialize organization UUID for org {}".format(self
.org_name
))
394 self
.logger
.debug(traceback
.format_exc())
397 def new_tenant(self
, tenant_name
=None, tenant_description
=None):
398 """ Method adds a new tenant to VIM with this name.
399 This action requires access to create VDC action in vCloud director.
402 tenant_name is tenant_name to be created.
403 tenant_description not used for this call
406 returns the tenant identifier in UUID format.
407 If action is failed method will throw vimconn.vimconnException method
409 vdc_task
= self
.create_vdc(vdc_name
=tenant_name
)
410 if vdc_task
is not None:
411 vdc_uuid
, value
= vdc_task
.popitem()
412 self
.logger
.info("Created new vdc {} and uuid: {}".format(tenant_name
, vdc_uuid
))
415 raise vimconn
.vimconnException("Failed create tenant {}".format(tenant_name
))
417 def delete_tenant(self
, tenant_id
=None):
418 """ Delete a tenant from VIM
420 tenant_id is tenant_id to be deleted.
423 returns the tenant identifier in UUID format.
424 If action is failed method will throw exception
426 vca
= self
.connect_as_admin()
428 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
430 if tenant_id
is not None:
433 url_list
= [self
.url
, '/api/vdc/', tenant_id
]
434 orgvdc_herf
= ''.join(url_list
)
436 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
437 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
438 response
= self
.perform_request(req_type
='GET',
442 if response
.status_code
!= requests
.codes
.ok
:
443 self
.logger
.debug("delete_tenant():GET REST API call {} failed. "\
444 "Return status code {}".format(orgvdc_herf
,
445 response
.status_code
))
446 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
448 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
449 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
451 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
452 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
453 vdc_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
454 vdc_remove_href
= vdc_remove_href
+ '?recursive=true&force=true'
456 response
= self
.perform_request(req_type
='DELETE',
460 if response
.status_code
== 202:
464 self
.logger
.debug("delete_tenant(): DELETE REST API call {} failed. "\
465 "Return status code {}".format(vdc_remove_href
,
466 response
.status_code
))
467 raise vimconn
.vimconnException("Fail to delete tenant with ID {}".format(tenant_id
))
469 self
.logger
.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id
))
470 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
473 def get_tenant_list(self
, filter_dict
={}):
474 """Obtain tenants of VIM
475 filter_dict can contain the following keys:
476 name: filter by tenant name
477 id: filter by tenant uuid/id
479 Returns the tenant list of dictionaries:
480 [{'name':'<name>, 'id':'<id>, ...}, ...]
483 org_dict
= self
.get_org(self
.org_uuid
)
484 vdcs_dict
= org_dict
['vdcs']
489 entry
= {'name': vdcs_dict
[k
], 'id': k
}
490 # if caller didn't specify dictionary we return all tenants.
491 if filter_dict
is not None and filter_dict
:
492 filtered_entry
= entry
.copy()
493 filtered_dict
= set(entry
.keys()) - set(filter_dict
)
494 for unwanted_key
in filtered_dict
: del entry
[unwanted_key
]
495 if filter_dict
== entry
:
496 vdclist
.append(filtered_entry
)
498 vdclist
.append(entry
)
500 self
.logger
.debug("Error in get_tenant_list()")
501 self
.logger
.debug(traceback
.format_exc())
502 raise vimconn
.vimconnException("Incorrect state. {}")
506 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
507 """Adds a tenant network to VIM
509 'net_name': name of the network
511 'bridge': overlay isolated network
512 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
513 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
514 'ip_profile': is a dict containing the IP parameters of the network
515 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
516 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
517 'gateway_address': (Optional) ip_schema, that is X.X.X.X
518 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
519 'dhcp_enabled': True or False
520 'dhcp_start_address': ip_schema, first IP to grant
521 'dhcp_count': number of IPs to grant.
522 'shared': if this network can be seen/use by other tenants/organization
523 'vlan': in case of a data or ptp net_type, the intended vlan tag to be used for the network
524 Returns a tuple with the network identifier and created_items, or raises an exception on error
525 created_items can be None or a dictionary where this method can include key-values that will be passed to
526 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
527 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
531 self
.logger
.debug("new_network tenant {} net_type {} ip_profile {} shared {}"
532 .format(net_name
, net_type
, ip_profile
, shared
))
539 # ############# Stub code for SRIOV #################
540 # if net_type == "data" or net_type == "ptp":
541 # if self.config.get('dv_switch_name') == None:
542 # raise vimconn.vimconnConflictException("You must provide 'dv_switch_name' at config value")
543 # network_uuid = self.create_dvPort_group(net_name)
545 network_uuid
= self
.create_network(network_name
=net_name
, net_type
=net_type
,
546 ip_profile
=ip_profile
, isshared
=isshared
)
547 if network_uuid
is not None:
548 return network_uuid
, created_items
550 raise vimconn
.vimconnUnexpectedResponse("Failed create a new network {}".format(net_name
))
552 def get_vcd_network_list(self
):
553 """ Method available organization for a logged in tenant
556 The return vca object that letter can be used to connect to vcloud direct as admin
559 self
.logger
.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
561 if not self
.tenant_name
:
562 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
564 org
, vdc
= self
.get_vdc_details()
566 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self
.tenant_name
))
568 vdc_uuid
= vdc
.get('id').split(":")[3]
569 if self
.client
._session
:
570 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
571 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
572 response
= self
.perform_request(req_type
='GET',
575 if response
.status_code
!= 200:
576 self
.logger
.error("Failed to get vdc content")
577 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
579 content
= XmlElementTree
.fromstring(response
.content
)
584 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
586 response
= self
.perform_request(req_type
='GET',
590 if response
.status_code
!= 200:
591 self
.logger
.error("Failed to get network content")
592 raise vimconn
.vimconnNotFoundException("Failed to get network content")
594 net_details
= XmlElementTree
.fromstring(response
.content
)
597 net_uuid
= net_details
.get('id').split(":")
598 if len(net_uuid
) != 4:
601 net_uuid
= net_uuid
[3]
603 self
.logger
.debug("get_vcd_network_list(): Adding network {} "
604 "to a list vcd id {} network {}".format(net_uuid
,
606 net_details
.get('name')))
607 filter_dict
["name"] = net_details
.get('name')
608 filter_dict
["id"] = net_uuid
609 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
613 filter_dict
["shared"] = shared
614 filter_dict
["tenant_id"] = vdc_uuid
615 if int(net_details
.get('status')) == 1:
616 filter_dict
["admin_state_up"] = True
618 filter_dict
["admin_state_up"] = False
619 filter_dict
["status"] = "ACTIVE"
620 filter_dict
["type"] = "bridge"
621 network_list
.append(filter_dict
)
622 self
.logger
.debug("get_vcd_network_list adding entry {}".format(filter_dict
))
624 self
.logger
.debug("Error in get_vcd_network_list", exc_info
=True)
627 self
.logger
.debug("get_vcd_network_list returning {}".format(network_list
))
630 def get_network_list(self
, filter_dict
={}):
631 """Obtain tenant networks of VIM
633 name: network name OR/AND
634 id: network uuid OR/AND
635 shared: boolean OR/AND
636 tenant_id: tenant OR/AND
637 admin_state_up: boolean
640 [{key : value , key : value}]
642 Returns the network list of dictionaries:
643 [{<the fields at Filter_dict plus some VIM specific>}, ...]
647 self
.logger
.debug("get_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
649 if not self
.tenant_name
:
650 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
652 org
, vdc
= self
.get_vdc_details()
654 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}.".format(self
.tenant_name
))
657 vdcid
= vdc
.get('id').split(":")[3]
659 if self
.client
._session
:
660 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
661 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
662 response
= self
.perform_request(req_type
='GET',
665 if response
.status_code
!= 200:
666 self
.logger
.error("Failed to get vdc content")
667 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
669 content
= XmlElementTree
.fromstring(response
.content
)
673 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
675 response
= self
.perform_request(req_type
='GET',
679 if response
.status_code
!= 200:
680 self
.logger
.error("Failed to get network content")
681 raise vimconn
.vimconnNotFoundException("Failed to get network content")
683 net_details
= XmlElementTree
.fromstring(response
.content
)
686 net_uuid
= net_details
.get('id').split(":")
687 if len(net_uuid
) != 4:
690 net_uuid
= net_uuid
[3]
692 self
.logger
.debug("get_network_list(): Adding net {}"
693 " to a list vcd id {} network {}".format(net_uuid
,
695 net_details
.get('name')))
696 filter_entry
["name"] = net_details
.get('name')
697 filter_entry
["id"] = net_uuid
698 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
702 filter_entry
["shared"] = shared
703 filter_entry
["tenant_id"] = vdcid
704 if int(net_details
.get('status')) == 1:
705 filter_entry
["admin_state_up"] = True
707 filter_entry
["admin_state_up"] = False
708 filter_entry
["status"] = "ACTIVE"
709 filter_entry
["type"] = "bridge"
710 filtered_entry
= filter_entry
.copy()
712 if filter_dict
is not None and filter_dict
:
713 # we remove all the key : value we don't care and match only
715 filtered_dict
= set(filter_entry
.keys()) - set(filter_dict
)
716 for unwanted_key
in filtered_dict
: del filter_entry
[unwanted_key
]
717 if filter_dict
== filter_entry
:
718 network_list
.append(filtered_entry
)
720 network_list
.append(filtered_entry
)
721 except Exception as e
:
722 self
.logger
.debug("Error in get_network_list",exc_info
=True)
723 if isinstance(e
, vimconn
.vimconnException
):
726 raise vimconn
.vimconnNotFoundException("Failed : Networks list not found {} ".format(e
))
728 self
.logger
.debug("Returning {}".format(network_list
))
731 def get_network(self
, net_id
):
732 """Method obtains network details of net_id VIM network
733 Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
736 org
, vdc
= self
.get_vdc_details()
737 vdc_id
= vdc
.get('id').split(":")[3]
738 if self
.client
._session
:
739 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
740 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
741 response
= self
.perform_request(req_type
='GET',
744 if response
.status_code
!= 200:
745 self
.logger
.error("Failed to get vdc content")
746 raise vimconn
.vimconnNotFoundException("Failed to get vdc content")
748 content
= XmlElementTree
.fromstring(response
.content
)
753 if item
.tag
.split('}')[-1] == 'AvailableNetworks':
755 response
= self
.perform_request(req_type
='GET',
759 if response
.status_code
!= 200:
760 self
.logger
.error("Failed to get network content")
761 raise vimconn
.vimconnNotFoundException("Failed to get network content")
763 net_details
= XmlElementTree
.fromstring(response
.content
)
765 vdc_network_id
= net_details
.get('id').split(":")
766 if len(vdc_network_id
) == 4 and vdc_network_id
[3] == net_id
:
767 filter_dict
["name"] = net_details
.get('name')
768 filter_dict
["id"] = vdc_network_id
[3]
769 if [i
.text
for i
in net_details
if i
.tag
.split('}')[-1] == 'IsShared'][0] == 'true':
773 filter_dict
["shared"] = shared
774 filter_dict
["tenant_id"] = vdc_id
775 if int(net_details
.get('status')) == 1:
776 filter_dict
["admin_state_up"] = True
778 filter_dict
["admin_state_up"] = False
779 filter_dict
["status"] = "ACTIVE"
780 filter_dict
["type"] = "bridge"
781 self
.logger
.debug("Returning {}".format(filter_dict
))
784 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
785 except Exception as e
:
786 self
.logger
.debug("Error in get_network")
787 self
.logger
.debug(traceback
.format_exc())
788 if isinstance(e
, vimconn
.vimconnException
):
791 raise vimconn
.vimconnNotFoundException("Failed : Network not found {} ".format(e
))
795 def delete_network(self
, net_id
, created_items
=None):
797 Removes a tenant network from VIM and its associated elements
798 :param net_id: VIM identifier of the network, provided by method new_network
799 :param created_items: dictionary with extra items to be deleted. provided by method new_network
800 Returns the network identifier or raises an exception upon error or when network is not found
803 # ############# Stub code for SRIOV #################
804 # dvport_group = self.get_dvport_group(net_id)
807 # status = self.destroy_dvport_group(net_id)
809 # # Remove vlanID from persistent info
810 # if net_id in self.persistent_info["used_vlanIDs"]:
811 # del self.persistent_info["used_vlanIDs"][net_id]
815 vcd_network
= self
.get_vcd_network(network_uuid
=net_id
)
816 if vcd_network
is not None and vcd_network
:
817 if self
.delete_network_action(network_uuid
=net_id
):
820 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
822 def refresh_nets_status(self
, net_list
):
823 """Get the status of the networks
824 Params: the list of network identifiers
825 Returns a dictionary with:
826 net_id: #VIM id of this network
827 status: #Mandatory. Text with one of:
828 # DELETED (not found at vim)
829 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
830 # OTHER (Vim reported other status not understood)
831 # ERROR (VIM indicates an ERROR status)
832 # ACTIVE, INACTIVE, DOWN (admin down),
833 # BUILD (on building process)
835 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
836 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
844 vcd_network
= self
.get_vcd_network(network_uuid
=net
)
845 if vcd_network
is not None and vcd_network
:
846 if vcd_network
['status'] == '1':
852 errormsg
= 'Network not found.'
854 dict_entry
[net
] = {'status': status
, 'error_msg': errormsg
,
855 'vim_info': yaml
.safe_dump(vcd_network
)}
857 self
.logger
.debug("Error in refresh_nets_status")
858 self
.logger
.debug(traceback
.format_exc())
862 def get_flavor(self
, flavor_id
):
863 """Obtain flavor details from the VIM
864 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
866 if flavor_id
not in vimconnector
.flavorlist
:
867 raise vimconn
.vimconnNotFoundException("Flavor not found.")
868 return vimconnector
.flavorlist
[flavor_id
]
870 def new_flavor(self
, flavor_data
):
871 """Adds a tenant flavor to VIM
872 flavor_data contains a dictionary with information, keys:
874 ram: memory (cloud type) in MBytes
875 vpcus: cpus (cloud type)
876 extended: EPA parameters
877 - numas: #items requested in same NUMA
878 memory: number of 1G huge pages memory
879 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
880 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
881 - name: interface name
882 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
883 bandwidth: X Gbps; requested guarantee bandwidth
884 vpci: requested virtual PCI address
888 Returns the flavor identifier"""
890 # generate a new uuid put to internal dict and return it.
891 self
.logger
.debug("Creating new flavor - flavor_data: {}".format(flavor_data
))
892 new_flavor
=flavor_data
893 ram
= flavor_data
.get(FLAVOR_RAM_KEY
, 1024)
894 cpu
= flavor_data
.get(FLAVOR_VCPUS_KEY
, 1)
895 disk
= flavor_data
.get(FLAVOR_DISK_KEY
, 0)
897 if not isinstance(ram
, int):
898 raise vimconn
.vimconnException("Non-integer value for ram")
899 elif not isinstance(cpu
, int):
900 raise vimconn
.vimconnException("Non-integer value for cpu")
901 elif not isinstance(disk
, int):
902 raise vimconn
.vimconnException("Non-integer value for disk")
904 extended_flv
= flavor_data
.get("extended")
906 numas
=extended_flv
.get("numas")
909 #overwrite ram and vcpus
911 ram
= numa
['memory']*1024
912 if 'paired-threads' in numa
:
913 cpu
= numa
['paired-threads']*2
914 elif 'cores' in numa
:
916 elif 'threads' in numa
:
917 cpu
= numa
['threads']
919 new_flavor
[FLAVOR_RAM_KEY
] = ram
920 new_flavor
[FLAVOR_VCPUS_KEY
] = cpu
921 new_flavor
[FLAVOR_DISK_KEY
] = disk
922 # generate a new uuid put to internal dict and return it.
923 flavor_id
= uuid
.uuid4()
924 vimconnector
.flavorlist
[str(flavor_id
)] = new_flavor
925 self
.logger
.debug("Created flavor - {} : {}".format(flavor_id
, new_flavor
))
927 return str(flavor_id
)
929 def delete_flavor(self
, flavor_id
):
930 """Deletes a tenant flavor from VIM identify by its id
932 Returns the used id or raise an exception
934 if flavor_id
not in vimconnector
.flavorlist
:
935 raise vimconn
.vimconnNotFoundException("Flavor not found.")
937 vimconnector
.flavorlist
.pop(flavor_id
, None)
940 def new_image(self
, image_dict
):
942 Adds a tenant image to VIM
944 200, image-id if the image is created
945 <0, message if there is an error
948 return self
.get_image_id_from_path(image_dict
['location'])
950 def delete_image(self
, image_id
):
952 Deletes a tenant image from VIM
954 image_id is ID of Image to be deleted
956 returns the image identifier in UUID format or raises an exception on error
958 conn
= self
.connect_as_admin()
960 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
961 # Get Catalog details
962 url_list
= [self
.url
, '/api/catalog/', image_id
]
963 catalog_herf
= ''.join(url_list
)
965 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
966 'x-vcloud-authorization': conn
._session
.headers
['x-vcloud-authorization']}
968 response
= self
.perform_request(req_type
='GET',
972 if response
.status_code
!= requests
.codes
.ok
:
973 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
974 "Return status code {}".format(catalog_herf
,
975 response
.status_code
))
976 raise vimconn
.vimconnNotFoundException("Fail to get image {}".format(image_id
))
978 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
979 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
981 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
982 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
984 catalogItems_section
= lxmlroot_respond
.find("xmlns:CatalogItems",namespaces
)
985 catalogItems
= catalogItems_section
.iterfind("xmlns:CatalogItem",namespaces
)
986 for catalogItem
in catalogItems
:
987 catalogItem_href
= catalogItem
.attrib
['href']
989 response
= self
.perform_request(req_type
='GET',
990 url
=catalogItem_href
,
993 if response
.status_code
!= requests
.codes
.ok
:
994 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
995 "Return status code {}".format(catalog_herf
,
996 response
.status_code
))
997 raise vimconn
.vimconnNotFoundException("Fail to get catalogItem {} for catalog {}".format(
1001 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
1002 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
1004 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
1005 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
1006 catalogitem_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
1009 response
= self
.perform_request(req_type
='DELETE',
1010 url
=catalogitem_remove_href
,
1012 if response
.status_code
== requests
.codes
.no_content
:
1013 self
.logger
.debug("Deleted Catalog item {}".format(catalogItem
))
1015 raise vimconn
.vimconnException("Fail to delete Catalog Item {}".format(catalogItem
))
1018 url_list
= [self
.url
, '/api/admin/catalog/', image_id
]
1019 catalog_remove_herf
= ''.join(url_list
)
1020 response
= self
.perform_request(req_type
='DELETE',
1021 url
=catalog_remove_herf
,
1024 if response
.status_code
== requests
.codes
.no_content
:
1025 self
.logger
.debug("Deleted Catalog {}".format(image_id
))
1028 raise vimconn
.vimconnException("Fail to delete Catalog {}".format(image_id
))
1031 def catalog_exists(self
, catalog_name
, catalogs
):
1034 :param catalog_name:
1038 for catalog
in catalogs
:
1039 if catalog
['name'] == catalog_name
:
1040 return catalog
['id']
1042 def create_vimcatalog(self
, vca
=None, catalog_name
=None):
1043 """ Create new catalog entry in vCloud director.
1046 vca: vCloud director.
1047 catalog_name catalog that client wish to create. Note no validation done for a name.
1048 Client must make sure that provide valid string representation.
1050 Returns catalog id if catalog created else None.
1054 lxml_catalog_element
= vca
.create_catalog(catalog_name
, catalog_name
)
1055 if lxml_catalog_element
:
1056 id_attr_value
= lxml_catalog_element
.get('id') # 'urn:vcloud:catalog:7490d561-d384-4dac-8229-3575fd1fc7b4'
1057 return id_attr_value
.split(':')[-1]
1058 catalogs
= vca
.list_catalogs()
1059 except Exception as ex
:
1061 'create_vimcatalog(): Creation of catalog "{}" failed with error: {}'.format(catalog_name
, ex
))
1063 return self
.catalog_exists(catalog_name
, catalogs
)
1065 # noinspection PyIncorrectDocstring
1066 def upload_ovf(self
, vca
=None, catalog_name
=None, image_name
=None, media_file_name
=None,
1067 description
='', progress
=False, chunk_bytes
=128 * 1024):
1069 Uploads a OVF file to a vCloud catalog
1076 :param catalog_name: (str): The name of the catalog to upload the media.
1077 :param media_file_name: (str): The name of the local media file to upload.
1078 :return: (bool) True if the media file was successfully uploaded, false otherwise.
1080 os
.path
.isfile(media_file_name
)
1081 statinfo
= os
.stat(media_file_name
)
1083 # find a catalog entry where we upload OVF.
1084 # create vApp Template and check the status if vCD able to read OVF it will respond with appropirate
1086 # if VCD can parse OVF we upload VMDK file
1088 for catalog
in vca
.list_catalogs():
1089 if catalog_name
!= catalog
['name']:
1091 catalog_href
= "{}/api/catalog/{}/action/upload".format(self
.url
, catalog
['id'])
1093 <UploadVAppTemplateParams name="{}" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>{} vApp Template</Description></UploadVAppTemplateParams>
1094 """.format(catalog_name
, description
)
1097 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1098 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1099 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
1101 response
= self
.perform_request(req_type
='POST',
1106 if response
.status_code
== requests
.codes
.created
:
1107 catalogItem
= XmlElementTree
.fromstring(response
.content
)
1108 entity
= [child
for child
in catalogItem
if
1109 child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
1110 href
= entity
.get('href')
1113 response
= self
.perform_request(req_type
='GET',
1117 if response
.status_code
== requests
.codes
.ok
:
1118 headers
['Content-Type'] = 'Content-Type text/xml'
1119 result
= re
.search('rel="upload:default"\shref="(.*?\/descriptor.ovf)"',response
.content
)
1121 transfer_href
= result
.group(1)
1123 response
= self
.perform_request(req_type
='PUT',
1126 data
=open(media_file_name
, 'rb'))
1127 if response
.status_code
!= requests
.codes
.ok
:
1129 "Failed create vApp template for catalog name {} and image {}".format(catalog_name
,
1133 # TODO fix this with aync block
1136 self
.logger
.debug("vApp template for catalog name {} and image {}".format(catalog_name
, media_file_name
))
1138 # uploading VMDK file
1139 # check status of OVF upload and upload remaining files.
1140 response
= self
.perform_request(req_type
='GET',
1144 if response
.status_code
== requests
.codes
.ok
:
1145 result
= re
.search('rel="upload:default"\s*href="(.*?vmdk)"',response
.content
)
1147 link_href
= result
.group(1)
1148 # we skip ovf since it already uploaded.
1149 if 'ovf' in link_href
:
1151 # The OVF file and VMDK must be in a same directory
1152 head
, tail
= os
.path
.split(media_file_name
)
1153 file_vmdk
= head
+ '/' + link_href
.split("/")[-1]
1154 if not os
.path
.isfile(file_vmdk
):
1156 statinfo
= os
.stat(file_vmdk
)
1157 if statinfo
.st_size
== 0:
1159 hrefvmdk
= link_href
1162 widgets
= ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
1163 FileTransferSpeed()]
1164 progress_bar
= ProgressBar(widgets
=widgets
, maxval
=statinfo
.st_size
).start()
1166 bytes_transferred
= 0
1167 f
= open(file_vmdk
, 'rb')
1168 while bytes_transferred
< statinfo
.st_size
:
1169 my_bytes
= f
.read(chunk_bytes
)
1170 if len(my_bytes
) <= chunk_bytes
:
1171 headers
['Content-Range'] = 'bytes %s-%s/%s' % (
1172 bytes_transferred
, len(my_bytes
) - 1, statinfo
.st_size
)
1173 headers
['Content-Length'] = str(len(my_bytes
))
1174 response
= requests
.put(url
=hrefvmdk
,
1178 if response
.status_code
== requests
.codes
.ok
:
1179 bytes_transferred
+= len(my_bytes
)
1181 progress_bar
.update(bytes_transferred
)
1184 'file upload failed with error: [%s] %s' % (response
.status_code
,
1191 progress_bar
.finish()
1195 self
.logger
.debug("Failed retrieve vApp template for catalog name {} for OVF {}".
1196 format(catalog_name
, media_file_name
))
1198 except Exception as exp
:
1199 self
.logger
.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1200 .format(catalog_name
,media_file_name
, exp
))
1201 raise vimconn
.vimconnException(
1202 "Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1203 .format(catalog_name
,media_file_name
, exp
))
1205 self
.logger
.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name
, media_file_name
))
1208 def upload_vimimage(self
, vca
=None, catalog_name
=None, media_name
=None, medial_file_name
=None, progress
=False):
1209 """Upload media file"""
1210 # TODO add named parameters for readability
1212 return self
.upload_ovf(vca
=vca
, catalog_name
=catalog_name
, image_name
=media_name
.split(".")[0],
1213 media_file_name
=medial_file_name
, description
='medial_file_name', progress
=progress
)
1215 def validate_uuid4(self
, uuid_string
=None):
1216 """ Method validate correct format of UUID.
1218 Return: true if string represent valid uuid
1221 val
= uuid
.UUID(uuid_string
, version
=4)
1226 def get_catalogid(self
, catalog_name
=None, catalogs
=None):
1227 """ Method check catalog and return catalog ID in UUID format.
1230 catalog_name: catalog name as string
1231 catalogs: list of catalogs.
1233 Return: catalogs uuid
1236 for catalog
in catalogs
:
1237 if catalog
['name'] == catalog_name
:
1238 catalog_id
= catalog
['id']
1242 def get_catalogbyid(self
, catalog_uuid
=None, catalogs
=None):
1243 """ Method check catalog and return catalog name lookup done by catalog UUID.
1246 catalog_name: catalog name as string
1247 catalogs: list of catalogs.
1249 Return: catalogs name or None
1252 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1255 for catalog
in catalogs
:
1256 catalog_id
= catalog
.get('id')
1257 if catalog_id
== catalog_uuid
:
1258 return catalog
.get('name')
1261 def get_catalog_obj(self
, catalog_uuid
=None, catalogs
=None):
1262 """ Method check catalog and return catalog name lookup done by catalog UUID.
1265 catalog_name: catalog name as string
1266 catalogs: list of catalogs.
1268 Return: catalogs name or None
1271 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1274 for catalog
in catalogs
:
1275 catalog_id
= catalog
.get('id')
1276 if catalog_id
== catalog_uuid
:
1280 def get_image_id_from_path(self
, path
=None, progress
=False):
1281 """ Method upload OVF image to vCloud director.
1283 Each OVF image represented as single catalog entry in vcloud director.
1284 The method check for existing catalog entry. The check done by file name without file extension.
1286 if given catalog name already present method will respond with existing catalog uuid otherwise
1287 it will create new catalog entry and upload OVF file to newly created catalog.
1289 If method can't create catalog entry or upload a file it will throw exception.
1291 Method accept boolean flag progress that will output progress bar. It useful method
1292 for standalone upload use case. In case to test large file upload.
1295 path: - valid path to OVF file.
1296 progress - boolean progress bar show progress bar.
1298 Return: if image uploaded correct method will provide image catalog UUID.
1302 raise vimconn
.vimconnException("Image path can't be None.")
1304 if not os
.path
.isfile(path
):
1305 raise vimconn
.vimconnException("Can't read file. File not found.")
1307 if not os
.access(path
, os
.R_OK
):
1308 raise vimconn
.vimconnException("Can't read file. Check file permission to read.")
1310 self
.logger
.debug("get_image_id_from_path() client requesting {} ".format(path
))
1312 dirpath
, filename
= os
.path
.split(path
)
1313 flname
, file_extension
= os
.path
.splitext(path
)
1314 if file_extension
!= '.ovf':
1315 self
.logger
.debug("Wrong file extension {} connector support only OVF container.".format(file_extension
))
1316 raise vimconn
.vimconnException("Wrong container. vCloud director supports only OVF.")
1318 catalog_name
= os
.path
.splitext(filename
)[0]
1319 catalog_md5_name
= hashlib
.md5(path
).hexdigest()
1320 self
.logger
.debug("File name {} Catalog Name {} file path {} "
1321 "vdc catalog name {}".format(filename
, catalog_name
, path
, catalog_md5_name
))
1324 org
,vdc
= self
.get_vdc_details()
1325 catalogs
= org
.list_catalogs()
1326 except Exception as exp
:
1327 self
.logger
.debug("Failed get catalogs() with Exception {} ".format(exp
))
1328 raise vimconn
.vimconnException("Failed get catalogs() with Exception {} ".format(exp
))
1330 if len(catalogs
) == 0:
1331 self
.logger
.info("Creating a new catalog entry {} in vcloud director".format(catalog_name
))
1332 if self
.create_vimcatalog(org
, catalog_md5_name
) is None:
1333 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1335 result
= self
.upload_vimimage(vca
=org
, catalog_name
=catalog_md5_name
,
1336 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1338 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_name
))
1339 return self
.get_catalogid(catalog_name
, catalogs
)
1341 for catalog
in catalogs
:
1342 # search for existing catalog if we find same name we return ID
1343 # TODO optimize this
1344 if catalog
['name'] == catalog_md5_name
:
1345 self
.logger
.debug("Found existing catalog entry for {} "
1346 "catalog id {}".format(catalog_name
,
1347 self
.get_catalogid(catalog_md5_name
, catalogs
)))
1348 return self
.get_catalogid(catalog_md5_name
, catalogs
)
1350 # if we didn't find existing catalog we create a new one and upload image.
1351 self
.logger
.debug("Creating new catalog entry {} - {}".format(catalog_name
, catalog_md5_name
))
1352 if self
.create_vimcatalog(org
, catalog_md5_name
) is None:
1353 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1355 result
= self
.upload_vimimage(vca
=org
, catalog_name
=catalog_md5_name
,
1356 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1358 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_md5_name
))
1360 return self
.get_catalogid(catalog_md5_name
, org
.list_catalogs())
1362 def get_image_list(self
, filter_dict
={}):
1363 '''Obtain tenant images from VIM
1367 checksum: image checksum
1368 location: image path
1369 Returns the image list of dictionaries:
1370 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1375 org
, vdc
= self
.get_vdc_details()
1377 catalogs
= org
.list_catalogs()
1378 if len(catalogs
) == 0:
1381 for catalog
in catalogs
:
1382 catalog_uuid
= catalog
.get('id')
1383 name
= catalog
.get('name')
1385 if filter_dict
.get("name") and filter_dict
["name"] != name
:
1387 if filter_dict
.get("id") and filter_dict
["id"] != catalog_uuid
:
1389 filtered_dict
["name"] = name
1390 filtered_dict
["id"] = catalog_uuid
1391 image_list
.append(filtered_dict
)
1393 self
.logger
.debug("List of already created catalog items: {}".format(image_list
))
1395 except Exception as exp
:
1396 raise vimconn
.vimconnException("Exception occured while retriving catalog items {}".format(exp
))
1398 def get_vappid(self
, vdc
=None, vapp_name
=None):
1399 """ Method takes vdc object and vApp name and returns vapp uuid or None
1402 vdc: The VDC object.
1403 vapp_name: is application vappp name identifier
1406 The return vApp name otherwise None
1408 if vdc
is None or vapp_name
is None:
1410 # UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
1412 refs
= filter(lambda ref
: ref
.name
== vapp_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1413 vdc
.ResourceEntities
.ResourceEntity
)
1415 #refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
1416 # if ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
1418 return refs
[0].href
.split("vapp")[1][1:]
1419 except Exception as e
:
1420 self
.logger
.exception(e
)
1424 def check_vapp(self
, vdc
=None, vapp_uuid
=None):
1425 """ Method Method returns True or False if vapp deployed in vCloud director
1428 vca: Connector to VCA
1429 vdc: The VDC object.
1430 vappid: vappid is application identifier
1433 The return True if vApp deployed
1438 refs
= filter(lambda ref
:
1439 ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1440 vdc
.ResourceEntities
.ResourceEntity
)
1442 #refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
1443 # if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
1445 vappid
= ref
.href
.split("vapp")[1][1:]
1446 # find vapp with respected vapp uuid
1447 if vappid
== vapp_uuid
:
1449 except Exception as e
:
1450 self
.logger
.exception(e
)
1454 def get_namebyvappid(self
, vapp_uuid
=None):
1455 """Method returns vApp name from vCD and lookup done by vapp_id.
1458 vapp_uuid: vappid is application identifier
1461 The return vApp name otherwise None
1464 if self
.client
and vapp_uuid
:
1465 vapp_call
= "{}/api/vApp/vapp-{}".format(self
.url
, vapp_uuid
)
1466 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1467 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1469 response
= self
.perform_request(req_type
='GET',
1472 #Retry login if session expired & retry sending request
1473 if response
.status_code
== 403:
1474 response
= self
.retry_rest('GET', vapp_call
)
1476 tree
= XmlElementTree
.fromstring(response
.content
)
1477 return tree
.attrib
['name']
1478 except Exception as e
:
1479 self
.logger
.exception(e
)
1483 def new_vminstance(self
, name
=None, description
="", start
=False, image_id
=None, flavor_id
=None, net_list
=[],
1484 cloud_config
=None, disk_list
=None, availability_zone_index
=None, availability_zone_list
=None):
1485 """Adds a VM instance to VIM
1487 'start': (boolean) indicates if VM must start or created in pause mode.
1488 'image_id','flavor_id': image and flavor VIM id to use for the VM
1489 'net_list': list of interfaces, each one is a dictionary with:
1490 'name': (optional) name for the interface.
1491 'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
1492 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
1493 'model': (optional and only have sense for type==virtual) interface model: virtio, e1000, ...
1494 'mac_address': (optional) mac address to assign to this interface
1495 #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
1496 the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
1497 'type': (mandatory) can be one of:
1498 'virtual', in this case always connected to a network of type 'net_type=bridge'
1499 'PCI-PASSTHROUGH' or 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
1500 can created unconnected
1501 'SR-IOV' or 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
1502 'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
1503 are allocated on the same physical NIC
1504 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS
1505 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing
1506 or True, it must apply the default VIM behaviour
1507 After execution the method will add the key:
1508 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this
1509 interface. 'net_list' is modified
1510 'cloud_config': (optional) dictionary with:
1511 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1512 'users': (optional) list of users to be inserted, each item is a dict with:
1513 'name': (mandatory) user name,
1514 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1515 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
1516 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
1517 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1518 'dest': (mandatory) string with the destination absolute path
1519 'encoding': (optional, by default text). Can be one of:
1520 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1521 'content' (mandatory): string with the content of the file
1522 'permissions': (optional) string with file permissions, typically octal notation '0644'
1523 'owner': (optional) file owner, string with the format 'owner:group'
1524 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1525 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1526 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1527 'size': (mandatory) string with the size of the disk in GB
1528 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1529 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1530 availability_zone_index is None
1531 Returns a tuple with the instance identifier and created_items or raises an exception on error
1532 created_items can be None or a dictionary where this method can include key-values that will be passed to
1533 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1534 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1537 self
.logger
.info("Creating new instance for entry {}".format(name
))
1538 self
.logger
.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {} disk_list {} "\
1539 "availability_zone_index {} availability_zone_list {}"\
1540 .format(description
, start
, image_id
, flavor_id
, net_list
, cloud_config
, disk_list
,\
1541 availability_zone_index
, availability_zone_list
))
1543 #new vm name = vmname + tenant_id + uuid
1544 new_vm_name
= [name
, '-', str(uuid
.uuid4())]
1545 vmname_andid
= ''.join(new_vm_name
)
1547 for net
in net_list
:
1548 if net
['type'] == "PCI-PASSTHROUGH":
1549 raise vimconn
.vimconnNotSupportedException(
1550 "Current vCD version does not support type : {}".format(net
['type']))
1552 if len(net_list
) > 10:
1553 raise vimconn
.vimconnNotSupportedException(
1554 "The VM hardware versions 7 and above support upto 10 NICs only")
1556 # if vm already deployed we return existing uuid
1557 # we check for presence of VDC, Catalog entry and Flavor.
1558 org
, vdc
= self
.get_vdc_details()
1560 raise vimconn
.vimconnNotFoundException(
1561 "new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name
))
1562 catalogs
= org
.list_catalogs()
1563 if catalogs
is None:
1564 #Retry once, if failed by refreshing token
1566 org
= Org(self
.client
, resource
=self
.client
.get_org())
1567 catalogs
= org
.list_catalogs()
1568 if catalogs
is None:
1569 raise vimconn
.vimconnNotFoundException(
1570 "new_vminstance(): Failed create vApp {}: (Failed retrieve catalogs list)".format(name
))
1572 catalog_hash_name
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1573 if catalog_hash_name
:
1574 self
.logger
.info("Found catalog entry {} for image id {}".format(catalog_hash_name
, image_id
))
1576 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1577 "(Failed retrieve catalog information {})".format(name
, image_id
))
1579 # Set vCPU and Memory based on flavor.
1585 if flavor_id
is not None:
1586 if flavor_id
not in vimconnector
.flavorlist
:
1587 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1588 "Failed retrieve flavor information "
1589 "flavor id {}".format(name
, flavor_id
))
1592 flavor
= vimconnector
.flavorlist
[flavor_id
]
1593 vm_cpus
= flavor
[FLAVOR_VCPUS_KEY
]
1594 vm_memory
= flavor
[FLAVOR_RAM_KEY
]
1595 vm_disk
= flavor
[FLAVOR_DISK_KEY
]
1596 extended
= flavor
.get("extended", None)
1598 numas
=extended
.get("numas", None)
1600 except Exception as exp
:
1601 raise vimconn
.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id
, exp
))
1603 # image upload creates template name as catalog name space Template.
1604 templateName
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1609 # client must provide at least one entry in net_list if not we report error
1610 #If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
1611 #If no mgmt, then the 1st NN in netlist is considered as primary net.
1613 primary_netname
= None
1614 primary_net_href
= None
1615 network_mode
= 'bridged'
1616 if net_list
is not None and len(net_list
) > 0:
1617 for net
in net_list
:
1618 if 'use' in net
and net
['use'] == 'mgmt' and not primary_net
:
1620 if primary_net
is None:
1621 primary_net
= net_list
[0]
1624 primary_net_id
= primary_net
['net_id']
1625 url_list
= [self
.url
, '/api/network/', primary_net_id
]
1626 primary_net_href
= ''.join(url_list
)
1627 network_dict
= self
.get_vcd_network(network_uuid
=primary_net_id
)
1628 if 'name' in network_dict
:
1629 primary_netname
= network_dict
['name']
1632 raise vimconn
.vimconnException("Corrupted flavor. {}".format(primary_net
))
1634 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name
))
1636 # use: 'data', 'bridge', 'mgmt'
1637 # create vApp. Set vcpu and ram based on flavor id.
1639 vdc_obj
= VDC(self
.client
, resource
=org
.get_vdc(self
.tenant_name
))
1641 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed to get VDC object")
1644 items
= org
.get_catalog_item(catalog_hash_name
, catalog_hash_name
)
1645 catalog_items
= [items
.attrib
]
1647 if len(catalog_items
) == 1:
1649 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
1650 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
1652 response
= self
.perform_request(req_type
='GET',
1653 url
=catalog_items
[0].get('href'),
1655 catalogItem
= XmlElementTree
.fromstring(response
.content
)
1656 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
1657 vapp_tempalte_href
= entity
.get("href")
1659 response
= self
.perform_request(req_type
='GET',
1660 url
=vapp_tempalte_href
,
1662 if response
.status_code
!= requests
.codes
.ok
:
1663 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vapp_tempalte_href
,
1664 response
.status_code
))
1666 result
= (response
.content
).replace("\n"," ")
1668 src
= re
.search('<Vm goldMaster="false"\sstatus="\d+"\sname="(.*?)"\s'
1669 'id="(\w+:\w+:vm:.*?)"\shref="(.*?)"\s'
1670 'type="application/vnd\.vmware\.vcloud\.vm\+xml',result
)
1672 vm_name
= src
.group(1)
1673 vm_id
= src
.group(2)
1674 vm_href
= src
.group(3)
1676 cpus
= re
.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
1677 memory_mb
= re
.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
1678 cores
= re
.search('<vmw:CoresPerSocket ovf:required.*?>(\d+)</vmw:CoresPerSocket>',result
).group(1)
1680 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'
1681 vdc_id
= vdc
.get('id').split(':')[-1]
1682 instantiate_vapp_href
= "{}/api/vdc/{}/action/instantiateVAppTemplate".format(self
.url
,
1684 data
= """<?xml version="1.0" encoding="UTF-8"?>
1685 <InstantiateVAppTemplateParams
1686 xmlns="http://www.vmware.com/vcloud/v1.5"
1690 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
1691 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1">
1692 <Description>Vapp instantiation</Description>
1693 <InstantiationParams>
1694 <NetworkConfigSection>
1695 <ovf:Info>Configuration parameters for logical networks</ovf:Info>
1696 <NetworkConfig networkName="{}">
1698 <ParentNetwork href="{}" />
1699 <FenceMode>bridged</FenceMode>
1702 </NetworkConfigSection>
1703 <LeaseSettingsSection
1704 type="application/vnd.vmware.vcloud.leaseSettingsSection+xml">
1705 <ovf:Info>Lease Settings</ovf:Info>
1706 <StorageLeaseInSeconds>172800</StorageLeaseInSeconds>
1707 <StorageLeaseExpiration>2014-04-25T08:08:16.438-07:00</StorageLeaseExpiration>
1708 </LeaseSettingsSection>
1709 </InstantiationParams>
1712 <Source href="{}" id="{}" name="{}"
1713 type="application/vnd.vmware.vcloud.vm+xml"/>
1715 <NeedsCustomization>false</NeedsCustomization>
1717 <InstantiationParams>
1718 <NetworkConnectionSection>
1719 <ovf:Info>Specifies the available VM network connections</ovf:Info>
1720 <NetworkConnection network="{}">
1721 <NetworkConnectionIndex>0</NetworkConnectionIndex>
1722 <IsConnected>true</IsConnected>
1723 <IpAddressAllocationMode>DHCP</IpAddressAllocationMode>
1724 </NetworkConnection>
1725 </NetworkConnectionSection><ovf:VirtualHardwareSection>
1726 <ovf:Info>Virtual hardware requirements</ovf:Info>
1727 <ovf:Item xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
1728 xmlns:vmw="http://www.vmware.com/schema/ovf">
1729 <rasd:AllocationUnits>hertz * 10^6</rasd:AllocationUnits>
1730 <rasd:Description>Number of Virtual CPUs</rasd:Description>
1731 <rasd:ElementName xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="str">{cpu} virtual CPU(s)</rasd:ElementName>
1732 <rasd:InstanceID>4</rasd:InstanceID>
1733 <rasd:Reservation>0</rasd:Reservation>
1734 <rasd:ResourceType>3</rasd:ResourceType>
1735 <rasd:VirtualQuantity xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="int">{cpu}</rasd:VirtualQuantity>
1736 <rasd:Weight>0</rasd:Weight>
1737 <vmw:CoresPerSocket ovf:required="false">{core}</vmw:CoresPerSocket>
1738 </ovf:Item><ovf:Item xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData">
1739 <rasd:AllocationUnits>byte * 2^20</rasd:AllocationUnits>
1740 <rasd:Description>Memory Size</rasd:Description>
1741 <rasd:ElementName xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="str">{memory} MB of memory</rasd:ElementName>
1742 <rasd:InstanceID>5</rasd:InstanceID>
1743 <rasd:Reservation>0</rasd:Reservation>
1744 <rasd:ResourceType>4</rasd:ResourceType>
1745 <rasd:VirtualQuantity xmlns:py="http://codespeak.net/lxml/objectify/pytype" py:pytype="int">{memory}</rasd:VirtualQuantity>
1746 <rasd:Weight>0</rasd:Weight>
1748 </ovf:VirtualHardwareSection>
1749 </InstantiationParams>
1751 <AllEULAsAccepted>false</AllEULAsAccepted>
1752 </InstantiateVAppTemplateParams>""".format(vmname_andid
,
1764 response
= self
.perform_request(req_type
='POST',
1765 url
=instantiate_vapp_href
,
1769 if response
.status_code
!= 201:
1770 self
.logger
.error("REST call {} failed reason : {}"\
1771 "status code : {}".format(instantiate_vapp_href
,
1773 response
.status_code
))
1774 raise vimconn
.vimconnException("new_vminstance(): Failed to create"\
1775 "vAapp {}".format(vmname_andid
))
1777 vapptask
= self
.get_task_from_response(response
.content
)
1779 if vapptask
is None and retry
==1:
1780 self
.get_token() # Retry getting token
1785 if vapptask
is None or vapptask
is False:
1786 raise vimconn
.vimconnUnexpectedResponse(
1787 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1789 # wait for task to complete
1790 result
= self
.client
.get_task_monitor().wait_for_success(task
=vapptask
)
1792 if result
.get('status') == 'success':
1793 self
.logger
.debug("new_vminstance(): Sucessfully created Vapp {}".format(vmname_andid
))
1795 raise vimconn
.vimconnUnexpectedResponse(
1796 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1798 except Exception as exp
:
1799 raise vimconn
.vimconnUnexpectedResponse(
1800 "new_vminstance(): failed to create vApp {} with Exception:{}".format(vmname_andid
, exp
))
1802 # we should have now vapp in undeployed state.
1804 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
1805 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1806 vapp_uuid
= vapp_resource
.get('id').split(':')[-1]
1807 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1809 except Exception as exp
:
1810 raise vimconn
.vimconnUnexpectedResponse(
1811 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
1812 .format(vmname_andid
, exp
))
1814 if vapp_uuid
is None:
1815 raise vimconn
.vimconnUnexpectedResponse(
1816 "new_vminstance(): Failed to retrieve vApp {} after creation".format(
1819 #Add PCI passthrough/SRIOV configrations
1821 pci_devices_info
= []
1822 reserve_memory
= False
1824 for net
in net_list
:
1825 if net
["type"] == "PF" or net
["type"] == "PCI-PASSTHROUGH":
1826 pci_devices_info
.append(net
)
1827 elif (net
["type"] == "VF" or net
["type"] == "SR-IOV" or net
["type"] == "VFnotShared") and 'net_id'in net
:
1828 reserve_memory
= True
1831 if len(pci_devices_info
) > 0:
1832 self
.logger
.info("Need to add PCI devices {} into VM {}".format(pci_devices_info
,
1834 PCI_devices_status
, vm_obj
, vcenter_conect
= self
.add_pci_devices(vapp_uuid
,
1837 if PCI_devices_status
:
1838 self
.logger
.info("Added PCI devives {} to VM {}".format(
1842 reserve_memory
= True
1844 self
.logger
.info("Fail to add PCI devives {} to VM {}".format(
1851 #Assuming there is only one disk in ovf and fast provisioning in organization vDC is disabled
1852 result
= self
.modify_vm_disk(vapp_uuid
, vm_disk
)
1854 self
.logger
.debug("Modified Disk size of VM {} ".format(vmname_andid
))
1856 #Add new or existing disks to vApp
1858 added_existing_disk
= False
1859 for disk
in disk_list
:
1860 if 'device_type' in disk
and disk
['device_type'] == 'cdrom':
1861 image_id
= disk
['image_id']
1862 # Adding CD-ROM to VM
1863 # will revisit code once specification ready to support this feature
1864 self
.insert_media_to_vm(vapp
, image_id
)
1865 elif "image_id" in disk
and disk
["image_id"] is not None:
1866 self
.logger
.debug("Adding existing disk from image {} to vm {} ".format(
1867 disk
["image_id"] , vapp_uuid
))
1868 self
.add_existing_disk(catalogs
=catalogs
,
1869 image_id
=disk
["image_id"],
1870 size
= disk
["size"],
1871 template_name
=templateName
,
1874 added_existing_disk
= True
1876 #Wait till added existing disk gets reflected into vCD database/API
1877 if added_existing_disk
:
1879 added_existing_disk
= False
1880 self
.add_new_disk(vapp_uuid
, disk
['size'])
1883 # Assigning numa affinity setting
1885 if 'paired-threads-id' in numa
:
1886 paired_threads_id
= numa
['paired-threads-id']
1887 self
.set_numa_affinity(vapp_uuid
, paired_threads_id
)
1889 # add NICs & connect to networks in netlist
1891 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
1892 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
1893 vapp
= VApp(self
.client
, resource
=vapp_resource
)
1894 vapp_id
= vapp_resource
.get('id').split(':')[-1]
1896 self
.logger
.info("Removing primary NIC: ")
1897 # First remove all NICs so that NIC properties can be adjusted as needed
1898 self
.remove_primary_network_adapter_from_all_vms(vapp
)
1900 self
.logger
.info("Request to connect VM to a network: {}".format(net_list
))
1901 primary_nic_index
= 0
1903 for net
in net_list
:
1904 # openmano uses network id in UUID format.
1905 # vCloud Director need a name so we do reverse operation from provided UUID we lookup a name
1906 # [{'use': 'bridge', 'net_id': '527d4bf7-566a-41e7-a9e7-ca3cdd9cef4f', 'type': 'virtual',
1907 # 'vpci': '0000:00:11.0', 'name': 'eth0'}]
1909 if 'net_id' not in net
:
1912 #Using net_id as a vim_id i.e. vim interface id, as do not have saperate vim interface id
1913 #Same will be returned in refresh_vms_status() as vim_interface_id
1914 net
['vim_id'] = net
['net_id'] # Provide the same VIM identifier as the VIM network
1916 interface_net_id
= net
['net_id']
1917 interface_net_name
= self
.get_network_name_by_id(network_uuid
=interface_net_id
)
1918 interface_network_mode
= net
['use']
1920 if interface_network_mode
== 'mgmt':
1921 primary_nic_index
= nicIndex
1923 """- POOL (A static IP address is allocated automatically from a pool of addresses.)
1924 - DHCP (The IP address is obtained from a DHCP service.)
1925 - MANUAL (The IP address is assigned manually in the IpAddress element.)
1926 - NONE (No IP addressing mode specified.)"""
1928 if primary_netname
is not None:
1929 self
.logger
.debug("new_vminstance(): Filtering by net name {}".format(interface_net_name
))
1930 nets
= filter(lambda n
: n
.get('name') == interface_net_name
, self
.get_network_list())
1932 #nets = [n for n in self.get_network_list() if n.get('name') == interface_net_name]
1934 self
.logger
.info("new_vminstance(): Found requested network: {}".format(nets
[0].get('name')))
1936 if interface_net_name
!= primary_netname
:
1937 # connect network to VM - with all DHCP by default
1938 self
.logger
.info("new_vminstance(): Attaching net {} to vapp".format(interface_net_name
))
1939 self
.connect_vapp_to_org_vdc_network(vapp_id
, nets
[0].get('name'))
1941 type_list
= ('PF', 'PCI-PASSTHROUGH', 'VFnotShared')
1942 nic_type
= 'VMXNET3'
1943 if 'type' in net
and net
['type'] not in type_list
:
1944 # fetching nic type from vnf
1946 if net
['model'] is not None:
1947 if net
['model'].lower() == 'paravirt' or net
['model'].lower() == 'virtio':
1948 nic_type
= 'VMXNET3'
1950 nic_type
= net
['model']
1952 self
.logger
.info("new_vminstance(): adding network adapter "\
1953 "to a network {}".format(nets
[0].get('name')))
1954 self
.add_network_adapter_to_vms(vapp
, nets
[0].get('name'),
1960 self
.logger
.info("new_vminstance(): adding network adapter "\
1961 "to a network {}".format(nets
[0].get('name')))
1962 if net
['type'] in ['SR-IOV', 'VF']:
1963 nic_type
= net
['type']
1964 self
.add_network_adapter_to_vms(vapp
, nets
[0].get('name'),
1971 # cloud-init for ssh-key injection
1973 # Create a catalog which will be carrying the config drive ISO
1974 # This catalog is deleted during vApp deletion. The catalog name carries
1975 # vApp UUID and thats how it gets identified during its deletion.
1976 config_drive_catalog_name
= 'cfg_drv-' + vapp_uuid
1977 self
.logger
.info('new_vminstance(): Creating catalog "{}" to carry config drive ISO'.format(
1978 config_drive_catalog_name
))
1979 config_drive_catalog_id
= self
.create_vimcatalog(org
, config_drive_catalog_name
)
1980 if config_drive_catalog_id
is None:
1981 error_msg
= "new_vminstance(): Failed to create new catalog '{}' to carry the config drive " \
1982 "ISO".format(config_drive_catalog_name
)
1983 raise Exception(error_msg
)
1985 # Create config-drive ISO
1986 _
, userdata
= self
._create
_user
_data
(cloud_config
)
1987 # self.logger.debug('new_vminstance(): The userdata for cloud-init: {}'.format(userdata))
1988 iso_path
= self
.create_config_drive_iso(userdata
)
1989 self
.logger
.debug('new_vminstance(): The ISO is successfully created. Path: {}'.format(iso_path
))
1991 self
.logger
.info('new_vminstance(): uploading iso to catalog {}'.format(config_drive_catalog_name
))
1992 self
.upload_iso_to_catalog(config_drive_catalog_id
, iso_path
)
1993 # Attach the config-drive ISO to the VM
1994 self
.logger
.info('new_vminstance(): Attaching the config-drive ISO to the VM')
1995 # The ISO remains in INVALID_STATE right after the PUT request (its a blocking call though)
1997 self
.insert_media_to_vm(vapp
, config_drive_catalog_id
)
1998 shutil
.rmtree(os
.path
.dirname(iso_path
), ignore_errors
=True)
2000 # If VM has PCI devices or SRIOV reserve memory for VM
2002 self
.reserve_memory_for_all_vms(vapp
, memory_mb
)
2004 self
.logger
.debug("new_vminstance(): starting power on vApp {} ".format(vmname_andid
))
2006 poweron_task
= self
.power_on_vapp(vapp_id
, vmname_andid
)
2007 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
2008 if result
.get('status') == 'success':
2009 self
.logger
.info("new_vminstance(): Successfully power on "\
2010 "vApp {}".format(vmname_andid
))
2012 self
.logger
.error("new_vminstance(): failed to power on vApp "\
2013 "{}".format(vmname_andid
))
2015 except Exception as exp
:
2017 self
.delete_vminstance(vapp_uuid
)
2018 except Exception as exp2
:
2019 self
.logger
.error("new_vminstance rollback fail {}".format(exp2
))
2020 # it might be a case if specific mandatory entry in dict is empty or some other pyVcloud exception
2021 self
.logger
.error("new_vminstance(): Failed create new vm instance {} with exception {}"
2023 raise vimconn
.vimconnException("new_vminstance(): Failed create new vm instance {} with exception {}"
2026 # check if vApp deployed and if that the case return vApp UUID otherwise -1
2029 while wait_time
<= MAX_WAIT_TIME
:
2031 vapp_resource
= vdc_obj
.get_vapp(vmname_andid
)
2032 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2033 except Exception as exp
:
2034 raise vimconn
.vimconnUnexpectedResponse(
2035 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
2036 .format(vmname_andid
, exp
))
2038 #if vapp and vapp.me.deployed:
2039 if vapp
and vapp_resource
.get('deployed') == 'true':
2040 vapp_uuid
= vapp_resource
.get('id').split(':')[-1]
2043 self
.logger
.debug("new_vminstance(): Wait for vApp {} to deploy".format(name
))
2044 time
.sleep(INTERVAL_TIME
)
2046 wait_time
+=INTERVAL_TIME
2048 #SET Affinity Rule for VM
2049 #Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used
2050 #While creating VIM account user has to pass the Host Group names in availability_zone list
2051 #"availability_zone" is a part of VIM "config" parameters
2052 #For example, in VIM config: "availability_zone":["HG_170","HG_174","HG_175"]
2053 #Host groups are referred as availability zones
2054 #With following procedure, deployed VM will be added into a VM group.
2055 #Then A VM to Host Affinity rule will be created using the VM group & Host group.
2056 if(availability_zone_list
):
2057 self
.logger
.debug("Existing Host Groups in VIM {}".format(self
.config
.get('availability_zone')))
2058 #Admin access required for creating Affinity rules
2059 client
= self
.connect_as_admin()
2061 raise vimconn
.vimconnConnectionException("Failed to connect vCD as admin")
2063 self
.client
= client
2065 headers
= {'Accept':'application/*+xml;version=27.0',
2066 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2067 #Step1: Get provider vdc details from organization
2068 pvdc_href
= self
.get_pvdc_for_org(self
.tenant_name
, headers
)
2069 if pvdc_href
is not None:
2070 #Step2: Found required pvdc, now get resource pool information
2071 respool_href
= self
.get_resource_pool_details(pvdc_href
, headers
)
2072 if respool_href
is None:
2073 #Raise error if respool_href not found
2074 msg
= "new_vminstance():Error in finding resource pool details in pvdc {}"\
2076 self
.log_message(msg
)
2078 #Step3: Verify requested availability zone(hostGroup) is present in vCD
2079 # get availability Zone
2080 vm_az
= self
.get_vm_availability_zone(availability_zone_index
, availability_zone_list
)
2081 # check if provided av zone(hostGroup) is present in vCD VIM
2082 status
= self
.check_availibility_zone(vm_az
, respool_href
, headers
)
2084 msg
= "new_vminstance(): Error in finding availability zone(Host Group): {} in "\
2085 "resource pool {} status: {}".format(vm_az
,respool_href
,status
)
2086 self
.log_message(msg
)
2088 self
.logger
.debug ("new_vminstance(): Availability zone {} found in VIM".format(vm_az
))
2090 #Step4: Find VM group references to create vm group
2091 vmgrp_href
= self
.find_vmgroup_reference(respool_href
, headers
)
2092 if vmgrp_href
== None:
2093 msg
= "new_vminstance(): No reference to VmGroup found in resource pool"
2094 self
.log_message(msg
)
2096 #Step5: Create a VmGroup with name az_VmGroup
2097 vmgrp_name
= vm_az
+ "_" + name
#Formed VM Group name = Host Group name + VM name
2098 status
= self
.create_vmgroup(vmgrp_name
, vmgrp_href
, headers
)
2099 if status
is not True:
2100 msg
= "new_vminstance(): Error in creating VM group {}".format(vmgrp_name
)
2101 self
.log_message(msg
)
2103 #VM Group url to add vms to vm group
2104 vmgrpname_url
= self
.url
+ "/api/admin/extension/vmGroup/name/"+ vmgrp_name
2106 #Step6: Add VM to VM Group
2107 #Find VM uuid from vapp_uuid
2108 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
2109 vm_uuid
= vm_details
['vmuuid']
2111 status
= self
.add_vm_to_vmgroup(vm_uuid
, vmgrpname_url
, vmgrp_name
, headers
)
2112 if status
is not True:
2113 msg
= "new_vminstance(): Error in adding VM to VM group {}".format(vmgrp_name
)
2114 self
.log_message(msg
)
2116 #Step7: Create VM to Host affinity rule
2117 addrule_href
= self
.get_add_rule_reference (respool_href
, headers
)
2118 if addrule_href
is None:
2119 msg
= "new_vminstance(): Error in finding href to add rule in resource pool: {}"\
2120 .format(respool_href
)
2121 self
.log_message(msg
)
2123 status
= self
.create_vm_to_host_affinity_rule(addrule_href
, vmgrp_name
, vm_az
, "Affinity", headers
)
2125 msg
= "new_vminstance(): Error in creating affinity rule for VM {} in Host group {}"\
2126 .format(name
, vm_az
)
2127 self
.log_message(msg
)
2129 self
.logger
.debug("new_vminstance(): Affinity rule created successfully. Added {} in Host group {}"\
2130 .format(name
, vm_az
))
2131 #Reset token to a normal user to perform other operations
2134 if vapp_uuid
is not None:
2135 return vapp_uuid
, None
2137 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name
))
2139 def create_config_drive_iso(self
, user_data
):
2140 tmpdir
= tempfile
.mkdtemp()
2141 iso_path
= os
.path
.join(tmpdir
, 'ConfigDrive.iso')
2142 latest_dir
= os
.path
.join(tmpdir
, 'openstack', 'latest')
2143 os
.makedirs(latest_dir
)
2144 with
open(os
.path
.join(latest_dir
, 'meta_data.json'), 'w') as meta_file_obj
, \
2145 open(os
.path
.join(latest_dir
, 'user_data'), 'w') as userdata_file_obj
:
2146 userdata_file_obj
.write(user_data
)
2147 meta_file_obj
.write(json
.dumps({"availability_zone": "nova",
2149 "name": "ConfigDrive",
2150 "uuid": str(uuid
.uuid4())}
2153 genisoimage_cmd
= 'genisoimage -J -r -V config-2 -o {iso_path} {source_dir_path}'.format(
2154 iso_path
=iso_path
, source_dir_path
=tmpdir
)
2155 self
.logger
.info('create_config_drive_iso(): Creating ISO by running command "{}"'.format(genisoimage_cmd
))
2157 FNULL
= open(os
.devnull
, 'w')
2158 subprocess
.check_call(genisoimage_cmd
, shell
=True, stdout
=FNULL
)
2159 except subprocess
.CalledProcessError
as e
:
2160 shutil
.rmtree(tmpdir
, ignore_errors
=True)
2161 error_msg
= 'create_config_drive_iso(): Exception while running genisoimage command: {}'.format(e
)
2162 self
.logger
.error(error_msg
)
2163 raise Exception(error_msg
)
2166 def upload_iso_to_catalog(self
, catalog_id
, iso_file_path
):
2167 if not os
.path
.isfile(iso_file_path
):
2168 error_msg
= "upload_iso_to_catalog(): Given iso file is not present. Given path: {}".format(iso_file_path
)
2169 self
.logger
.error(error_msg
)
2170 raise Exception(error_msg
)
2171 iso_file_stat
= os
.stat(iso_file_path
)
2172 xml_media_elem
= '''<?xml version="1.0" encoding="UTF-8"?>
2174 xmlns="http://www.vmware.com/vcloud/v1.5"
2178 <Description>ISO image for config-drive</Description>
2179 </Media>'''.format(iso_name
=os
.path
.basename(iso_file_path
), iso_size
=iso_file_stat
.st_size
)
2180 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2181 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2182 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.media+xml'
2183 catalog_href
= self
.url
+ '/api/catalog/' + catalog_id
+ '/action/upload'
2184 response
= self
.perform_request(req_type
='POST', url
=catalog_href
, headers
=headers
, data
=xml_media_elem
)
2186 if response
.status_code
!= 201:
2187 error_msg
= "upload_iso_to_catalog(): Failed to POST an action/upload request to {}".format(catalog_href
)
2188 self
.logger
.error(error_msg
)
2189 raise Exception(error_msg
)
2191 catalogItem
= XmlElementTree
.fromstring(response
.content
)
2192 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.media+xml"][0]
2193 entity_href
= entity
.get('href')
2195 response
= self
.perform_request(req_type
='GET', url
=entity_href
, headers
=headers
)
2196 if response
.status_code
!= 200:
2197 raise Exception("upload_iso_to_catalog(): Failed to GET entity href {}".format(entity_href
))
2199 match
= re
.search(r
'<Files>\s+?<File.+?href="(.+?)"/>\s+?</File>\s+?</Files>', response
.text
, re
.DOTALL
)
2201 media_upload_href
= match
.group(1)
2203 raise Exception('Could not parse the upload URL for the media file from the last response')
2205 headers
['Content-Type'] = 'application/octet-stream'
2206 response
= self
.perform_request(req_type
='PUT',
2207 url
=media_upload_href
,
2209 data
=open(iso_file_path
, 'rb'))
2211 if response
.status_code
!= 200:
2212 raise Exception('PUT request to "{}" failed'.format(media_upload_href
))
2214 def get_vcd_availibility_zones(self
,respool_href
, headers
):
2215 """ Method to find presence of av zone is VIM resource pool
2218 respool_href - resource pool href
2219 headers - header information
2222 vcd_az - list of azone present in vCD
2226 resp
= self
.perform_request(req_type
='GET',url
=respool_href
, headers
=headers
)
2228 if resp
.status_code
!= requests
.codes
.ok
:
2229 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(url
, resp
.status_code
))
2231 #Get the href to hostGroups and find provided hostGroup is present in it
2232 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2233 for child
in resp_xml
:
2234 if 'VMWProviderVdcResourcePool' in child
.tag
:
2235 for schild
in child
:
2236 if 'Link' in schild
.tag
:
2237 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
2238 hostGroup
= schild
.attrib
.get('href')
2239 hg_resp
= self
.perform_request(req_type
='GET',url
=hostGroup
, headers
=headers
)
2240 if hg_resp
.status_code
!= requests
.codes
.ok
:
2241 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(hostGroup
, hg_resp
.status_code
))
2243 hg_resp_xml
= XmlElementTree
.fromstring(hg_resp
.content
)
2244 for hostGroup
in hg_resp_xml
:
2245 if 'HostGroup' in hostGroup
.tag
:
2246 #append host group name to the list
2247 vcd_az
.append(hostGroup
.attrib
.get("name"))
2251 def set_availability_zones(self
):
2253 Set vim availability zone
2256 vim_availability_zones
= None
2257 availability_zone
= None
2258 if 'availability_zone' in self
.config
:
2259 vim_availability_zones
= self
.config
.get('availability_zone')
2260 if isinstance(vim_availability_zones
, str):
2261 availability_zone
= [vim_availability_zones
]
2262 elif isinstance(vim_availability_zones
, list):
2263 availability_zone
= vim_availability_zones
2265 return availability_zone
2267 return availability_zone
2270 def get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
2272 Return the availability zone to be used by the created VM.
2273 returns: The VIM availability zone to be used or None
2275 if availability_zone_index
is None:
2276 if not self
.config
.get('availability_zone'):
2278 elif isinstance(self
.config
.get('availability_zone'), str):
2279 return self
.config
['availability_zone']
2281 return self
.config
['availability_zone'][0]
2283 vim_availability_zones
= self
.availability_zone
2285 # check if VIM offer enough availability zones describe in the VNFD
2286 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
2287 # check if all the names of NFV AV match VIM AV names
2288 match_by_index
= False
2289 for av
in availability_zone_list
:
2290 if av
not in vim_availability_zones
:
2291 match_by_index
= True
2294 self
.logger
.debug("Required Availability zone or Host Group not found in VIM config")
2295 self
.logger
.debug("Input Availability zone list: {}".format(availability_zone_list
))
2296 self
.logger
.debug("VIM configured Availability zones: {}".format(vim_availability_zones
))
2297 self
.logger
.debug("VIM Availability zones will be used by index")
2298 return vim_availability_zones
[availability_zone_index
]
2300 return availability_zone_list
[availability_zone_index
]
2302 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
2305 def create_vm_to_host_affinity_rule(self
, addrule_href
, vmgrpname
, hostgrpname
, polarity
, headers
):
2306 """ Method to create VM to Host Affinity rule in vCD
2309 addrule_href - href to make a POST request
2310 vmgrpname - name of the VM group created
2311 hostgrpnmae - name of the host group created earlier
2312 polarity - Affinity or Anti-affinity (default: Affinity)
2313 headers - headers to make REST call
2316 True- if rule is created
2317 False- Failed to create rule due to some error
2321 rule_name
= polarity
+ "_" + vmgrpname
2322 payload
= """<?xml version="1.0" encoding="UTF-8"?>
2323 <vmext:VMWVmHostAffinityRule
2324 xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5"
2325 xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
2326 type="application/vnd.vmware.admin.vmwVmHostAffinityRule+xml">
2327 <vcloud:Name>{}</vcloud:Name>
2328 <vcloud:IsEnabled>true</vcloud:IsEnabled>
2329 <vcloud:IsMandatory>true</vcloud:IsMandatory>
2330 <vcloud:Polarity>{}</vcloud:Polarity>
2331 <vmext:HostGroupName>{}</vmext:HostGroupName>
2332 <vmext:VmGroupName>{}</vmext:VmGroupName>
2333 </vmext:VMWVmHostAffinityRule>""".format(rule_name
, polarity
, hostgrpname
, vmgrpname
)
2335 resp
= self
.perform_request(req_type
='POST',url
=addrule_href
, headers
=headers
, data
=payload
)
2337 if resp
.status_code
!= requests
.codes
.accepted
:
2338 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(addrule_href
, resp
.status_code
))
2342 affinity_task
= self
.get_task_from_response(resp
.content
)
2343 self
.logger
.debug ("affinity_task: {}".format(affinity_task
))
2344 if affinity_task
is None or affinity_task
is False:
2345 raise vimconn
.vimconnUnexpectedResponse("failed to find affinity task")
2346 # wait for task to complete
2347 result
= self
.client
.get_task_monitor().wait_for_success(task
=affinity_task
)
2348 if result
.get('status') == 'success':
2349 self
.logger
.debug("Successfully created affinity rule {}".format(rule_name
))
2352 raise vimconn
.vimconnUnexpectedResponse(
2353 "failed to create affinity rule {}".format(rule_name
))
2356 def get_add_rule_reference (self
, respool_href
, headers
):
2357 """ This method finds href to add vm to host affinity rule to vCD
2360 respool_href- href to resource pool
2361 headers- header information to make REST call
2364 None - if no valid href to add rule found or
2365 addrule_href - href to add vm to host affinity rule of resource pool
2368 resp
= self
.perform_request(req_type
='GET',url
=respool_href
, headers
=headers
)
2370 if resp
.status_code
!= requests
.codes
.ok
:
2371 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(respool_href
, resp
.status_code
))
2374 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2375 for child
in resp_xml
:
2376 if 'VMWProviderVdcResourcePool' in child
.tag
:
2377 for schild
in child
:
2378 if 'Link' in schild
.tag
:
2379 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwVmHostAffinityRule+xml" and \
2380 schild
.attrib
.get('rel') == "add":
2381 addrule_href
= schild
.attrib
.get('href')
2387 def add_vm_to_vmgroup(self
, vm_uuid
, vmGroupNameURL
, vmGroup_name
, headers
):
2388 """ Method to add deployed VM to newly created VM Group.
2389 This is required to create VM to Host affinity in vCD
2392 vm_uuid- newly created vm uuid
2393 vmGroupNameURL- URL to VM Group name
2394 vmGroup_name- Name of VM group created
2395 headers- Headers for REST request
2398 True- if VM added to VM group successfully
2399 False- if any error encounter
2402 addvm_resp
= self
.perform_request(req_type
='GET',url
=vmGroupNameURL
, headers
=headers
)#, data=payload)
2404 if addvm_resp
.status_code
!= requests
.codes
.ok
:
2405 self
.logger
.debug ("REST API call to get VM Group Name url {} failed. Return status code {}"\
2406 .format(vmGroupNameURL
, addvm_resp
.status_code
))
2409 resp_xml
= XmlElementTree
.fromstring(addvm_resp
.content
)
2410 for child
in resp_xml
:
2411 if child
.tag
.split('}')[1] == 'Link':
2412 if child
.attrib
.get("rel") == "addVms":
2413 addvmtogrpURL
= child
.attrib
.get("href")
2416 url_list
= [self
.url
, '/api/vApp/vm-',vm_uuid
]
2417 vmdetailsURL
= ''.join(url_list
)
2419 resp
= self
.perform_request(req_type
='GET',url
=vmdetailsURL
, headers
=headers
)
2421 if resp
.status_code
!= requests
.codes
.ok
:
2422 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(vmdetailsURL
, resp
.status_code
))
2426 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2427 if resp_xml
.tag
.split('}')[1] == "Vm":
2428 vm_id
= resp_xml
.attrib
.get("id")
2429 vm_name
= resp_xml
.attrib
.get("name")
2430 vm_href
= resp_xml
.attrib
.get("href")
2431 #print vm_id, vm_name, vm_href
2432 #Add VM into VMgroup
2433 payload
= """<?xml version="1.0" encoding="UTF-8"?>\
2434 <ns2:Vms xmlns:ns2="http://www.vmware.com/vcloud/v1.5" \
2435 xmlns="http://www.vmware.com/vcloud/versions" \
2436 xmlns:ns3="http://schemas.dmtf.org/ovf/envelope/1" \
2437 xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" \
2438 xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/common" \
2439 xmlns:ns6="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" \
2440 xmlns:ns7="http://www.vmware.com/schema/ovf" \
2441 xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1" \
2442 xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">\
2443 <ns2:VmReference href="{}" id="{}" name="{}" \
2444 type="application/vnd.vmware.vcloud.vm+xml" />\
2445 </ns2:Vms>""".format(vm_href
, vm_id
, vm_name
)
2447 addvmtogrp_resp
= self
.perform_request(req_type
='POST',url
=addvmtogrpURL
, headers
=headers
, data
=payload
)
2449 if addvmtogrp_resp
.status_code
!= requests
.codes
.accepted
:
2450 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(addvmtogrpURL
, addvmtogrp_resp
.status_code
))
2453 self
.logger
.debug ("Done adding VM {} to VMgroup {}".format(vm_name
, vmGroup_name
))
2457 def create_vmgroup(self
, vmgroup_name
, vmgroup_href
, headers
):
2458 """Method to create a VM group in vCD
2461 vmgroup_name : Name of VM group to be created
2462 vmgroup_href : href for vmgroup
2463 headers- Headers for REST request
2465 #POST to add URL with required data
2466 vmgroup_status
= False
2467 payload
= """<VMWVmGroup xmlns="http://www.vmware.com/vcloud/extension/v1.5" \
2468 xmlns:vcloud_v1.5="http://www.vmware.com/vcloud/v1.5" name="{}">\
2469 <vmCount>1</vmCount>\
2470 </VMWVmGroup>""".format(vmgroup_name
)
2471 resp
= self
.perform_request(req_type
='POST',url
=vmgroup_href
, headers
=headers
, data
=payload
)
2473 if resp
.status_code
!= requests
.codes
.accepted
:
2474 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(vmgroup_href
, resp
.status_code
))
2475 return vmgroup_status
2477 vmgroup_task
= self
.get_task_from_response(resp
.content
)
2478 if vmgroup_task
is None or vmgroup_task
is False:
2479 raise vimconn
.vimconnUnexpectedResponse(
2480 "create_vmgroup(): failed to create VM group {}".format(vmgroup_name
))
2482 # wait for task to complete
2483 result
= self
.client
.get_task_monitor().wait_for_success(task
=vmgroup_task
)
2485 if result
.get('status') == 'success':
2486 self
.logger
.debug("create_vmgroup(): Successfully created VM group {}".format(vmgroup_name
))
2488 vmgroup_status
= True
2489 return vmgroup_status
2491 raise vimconn
.vimconnUnexpectedResponse(\
2492 "create_vmgroup(): failed to create VM group {}".format(vmgroup_name
))
2495 def find_vmgroup_reference(self
, url
, headers
):
2496 """ Method to create a new VMGroup which is required to add created VM
2498 url- resource pool href
2499 headers- header information
2502 returns href to VM group to create VM group
2504 #Perform GET on resource pool to find 'add' link to create VMGroup
2505 #https://vcd-ip/api/admin/extension/providervdc/<providervdc id>/resourcePools
2507 resp
= self
.perform_request(req_type
='GET',url
=url
, headers
=headers
)
2509 if resp
.status_code
!= requests
.codes
.ok
:
2510 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(url
, resp
.status_code
))
2512 #Get the href to add vmGroup to vCD
2513 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2514 for child
in resp_xml
:
2515 if 'VMWProviderVdcResourcePool' in child
.tag
:
2516 for schild
in child
:
2517 if 'Link' in schild
.tag
:
2518 #Find href with type VMGroup and rel with add
2519 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwVmGroupType+xml"\
2520 and schild
.attrib
.get('rel') == "add":
2521 vmgrp_href
= schild
.attrib
.get('href')
2525 def check_availibility_zone(self
, az
, respool_href
, headers
):
2526 """ Method to verify requested av zone is present or not in provided
2530 az - name of hostgroup (availibility_zone)
2531 respool_href - Resource Pool href
2532 headers - Headers to make REST call
2534 az_found - True if availibility_zone is found else False
2537 headers
['Accept']='application/*+xml;version=27.0'
2538 resp
= self
.perform_request(req_type
='GET',url
=respool_href
, headers
=headers
)
2540 if resp
.status_code
!= requests
.codes
.ok
:
2541 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(respool_href
, resp
.status_code
))
2543 #Get the href to hostGroups and find provided hostGroup is present in it
2544 resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2546 for child
in resp_xml
:
2547 if 'VMWProviderVdcResourcePool' in child
.tag
:
2548 for schild
in child
:
2549 if 'Link' in schild
.tag
:
2550 if schild
.attrib
.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
2551 hostGroup_href
= schild
.attrib
.get('href')
2552 hg_resp
= self
.perform_request(req_type
='GET',url
=hostGroup_href
, headers
=headers
)
2553 if hg_resp
.status_code
!= requests
.codes
.ok
:
2554 self
.logger
.debug ("REST API call {} failed. Return status code {}".format(hostGroup_href
, hg_resp
.status_code
))
2556 hg_resp_xml
= XmlElementTree
.fromstring(hg_resp
.content
)
2557 for hostGroup
in hg_resp_xml
:
2558 if 'HostGroup' in hostGroup
.tag
:
2559 if hostGroup
.attrib
.get("name") == az
:
2565 def get_pvdc_for_org(self
, org_vdc
, headers
):
2566 """ This method gets provider vdc references from organisation
2569 org_vdc - name of the organisation VDC to find pvdc
2570 headers - headers to make REST call
2573 None - if no pvdc href found else
2574 pvdc_href - href to pvdc
2577 #Get provider VDC references from vCD
2579 #url = '<vcd url>/api/admin/extension/providerVdcReferences'
2580 url_list
= [self
.url
, '/api/admin/extension/providerVdcReferences']
2581 url
= ''.join(url_list
)
2583 response
= self
.perform_request(req_type
='GET',url
=url
, headers
=headers
)
2584 if response
.status_code
!= requests
.codes
.ok
:
2585 self
.logger
.debug ("REST API call {} failed. Return status code {}"\
2586 .format(url
, response
.status_code
))
2588 xmlroot_response
= XmlElementTree
.fromstring(response
.content
)
2589 for child
in xmlroot_response
:
2590 if 'ProviderVdcReference' in child
.tag
:
2591 pvdc_href
= child
.attrib
.get('href')
2592 #Get vdcReferences to find org
2593 pvdc_resp
= self
.perform_request(req_type
='GET',url
=pvdc_href
, headers
=headers
)
2594 if pvdc_resp
.status_code
!= requests
.codes
.ok
:
2595 raise vimconn
.vimconnException("REST API call {} failed. "\
2596 "Return status code {}"\
2597 .format(url
, pvdc_resp
.status_code
))
2599 pvdc_resp_xml
= XmlElementTree
.fromstring(pvdc_resp
.content
)
2600 for child
in pvdc_resp_xml
:
2601 if 'Link' in child
.tag
:
2602 if child
.attrib
.get('type') == "application/vnd.vmware.admin.vdcReferences+xml":
2603 vdc_href
= child
.attrib
.get('href')
2605 #Check if provided org is present in vdc
2606 vdc_resp
= self
.perform_request(req_type
='GET',
2609 if vdc_resp
.status_code
!= requests
.codes
.ok
:
2610 raise vimconn
.vimconnException("REST API call {} failed. "\
2611 "Return status code {}"\
2612 .format(url
, vdc_resp
.status_code
))
2613 vdc_resp_xml
= XmlElementTree
.fromstring(vdc_resp
.content
)
2614 for child
in vdc_resp_xml
:
2615 if 'VdcReference' in child
.tag
:
2616 if child
.attrib
.get('name') == org_vdc
:
2620 def get_resource_pool_details(self
, pvdc_href
, headers
):
2621 """ Method to get resource pool information.
2622 Host groups are property of resource group.
2623 To get host groups, we need to GET details of resource pool.
2626 pvdc_href: href to pvdc details
2630 respool_href - Returns href link reference to resource pool
2633 resp
= self
.perform_request(req_type
='GET',url
=pvdc_href
, headers
=headers
)
2635 if resp
.status_code
!= requests
.codes
.ok
:
2636 self
.logger
.debug ("REST API call {} failed. Return status code {}"\
2637 .format(pvdc_href
, resp
.status_code
))
2639 respool_resp_xml
= XmlElementTree
.fromstring(resp
.content
)
2640 for child
in respool_resp_xml
:
2641 if 'Link' in child
.tag
:
2642 if child
.attrib
.get('type') == "application/vnd.vmware.admin.vmwProviderVdcResourcePoolSet+xml":
2643 respool_href
= child
.attrib
.get("href")
2648 def log_message(self
, msg
):
2650 Method to log error messages related to Affinity rule creation
2651 in new_vminstance & raise Exception
2653 msg - Error message to be logged
2656 #get token to connect vCD as a normal user
2658 self
.logger
.debug(msg
)
2659 raise vimconn
.vimconnException(msg
)
2664 ## based on current discussion
2668 # created: '2016-09-08T11:51:58'
2669 # description: simple-instance.linux1.1
2670 # flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
2671 # hostId: e836c036-74e7-11e6-b249-0800273e724c
2672 # image: dde30fe6-75a9-11e6-ad5f-0800273e724c
2677 def get_vminstance(self
, vim_vm_uuid
=None):
2678 """Returns the VM instance information from VIM"""
2680 self
.logger
.debug("Client requesting vm instance {} ".format(vim_vm_uuid
))
2682 org
, vdc
= self
.get_vdc_details()
2684 raise vimconn
.vimconnConnectionException(
2685 "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2687 vm_info_dict
= self
.get_vapp_details_rest(vapp_uuid
=vim_vm_uuid
)
2688 if not vm_info_dict
:
2689 self
.logger
.debug("get_vminstance(): Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
2690 raise vimconn
.vimconnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
2692 status_key
= vm_info_dict
['status']
2695 vm_dict
= {'created': vm_info_dict
['created'],
2696 'description': vm_info_dict
['name'],
2697 'status': vcdStatusCode2manoFormat
[int(status_key
)],
2698 'hostId': vm_info_dict
['vmuuid'],
2700 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
2702 if 'interfaces' in vm_info_dict
:
2703 vm_dict
['interfaces'] = vm_info_dict
['interfaces']
2705 vm_dict
['interfaces'] = []
2707 vm_dict
= {'created': '',
2709 'status': vcdStatusCode2manoFormat
[int(-1)],
2710 'hostId': vm_info_dict
['vmuuid'],
2711 'error_msg': "Inconsistency state",
2712 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
2716 def delete_vminstance(self
, vm__vim_uuid
, created_items
=None):
2717 """Method poweroff and remove VM instance from vcloud director network.
2720 vm__vim_uuid: VM UUID
2723 Returns the instance identifier
2726 self
.logger
.debug("Client requesting delete vm instance {} ".format(vm__vim_uuid
))
2728 org
, vdc
= self
.get_vdc_details()
2729 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2731 self
.logger
.debug("delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(
2733 raise vimconn
.vimconnException(
2734 "delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2737 vapp_name
= self
.get_namebyvappid(vm__vim_uuid
)
2738 if vapp_name
is None:
2739 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2740 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2741 self
.logger
.info("Deleting vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
2742 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2743 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2745 # Delete vApp and wait for status change if task executed and vApp is None.
2748 if vapp_resource
.get('deployed') == 'true':
2749 self
.logger
.info("Powering off vApp {}".format(vapp_name
))
2753 while wait_time
<= MAX_WAIT_TIME
:
2754 power_off_task
= vapp
.power_off()
2755 result
= self
.client
.get_task_monitor().wait_for_success(task
=power_off_task
)
2757 if result
.get('status') == 'success':
2761 self
.logger
.info("Wait for vApp {} to power off".format(vapp_name
))
2762 time
.sleep(INTERVAL_TIME
)
2764 wait_time
+=INTERVAL_TIME
2766 self
.logger
.debug("delete_vminstance(): Failed to power off VM instance {} ".format(vm__vim_uuid
))
2768 self
.logger
.info("delete_vminstance(): Powered off VM instance {} ".format(vm__vim_uuid
))
2771 self
.logger
.info("Undeploy vApp {}".format(vapp_name
))
2774 while wait_time
<= MAX_WAIT_TIME
:
2775 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2777 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2778 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2779 undeploy_task
= vapp
.undeploy()
2781 result
= self
.client
.get_task_monitor().wait_for_success(task
=undeploy_task
)
2782 if result
.get('status') == 'success':
2786 self
.logger
.debug("Wait for vApp {} to undeploy".format(vapp_name
))
2787 time
.sleep(INTERVAL_TIME
)
2789 wait_time
+=INTERVAL_TIME
2792 self
.logger
.debug("delete_vminstance(): Failed to undeploy vApp {} ".format(vm__vim_uuid
))
2795 self
.logger
.info("Start deletion of vApp {} ".format(vapp_name
))
2797 if vapp
is not None:
2801 while wait_time
<= MAX_WAIT_TIME
:
2802 vapp
= VApp(self
.client
, resource
=vapp_resource
)
2804 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2805 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
2807 delete_task
= vdc_obj
.delete_vapp(vapp
.name
, force
=True)
2809 result
= self
.client
.get_task_monitor().wait_for_success(task
=delete_task
)
2810 if result
.get('status') == 'success':
2813 self
.logger
.debug("Wait for vApp {} to delete".format(vapp_name
))
2814 time
.sleep(INTERVAL_TIME
)
2816 wait_time
+=INTERVAL_TIME
2819 self
.logger
.debug("delete_vminstance(): Failed delete uuid {} ".format(vm__vim_uuid
))
2821 self
.logger
.info("Deleted vm instance {} sccessfully".format(vm__vim_uuid
))
2822 config_drive_catalog_name
, config_drive_catalog_id
= 'cfg_drv-' + vm__vim_uuid
, None
2823 catalog_list
= self
.get_image_list()
2825 config_drive_catalog_id
= [catalog_
['id'] for catalog_
in catalog_list
2826 if catalog_
['name'] == config_drive_catalog_name
][0]
2829 if config_drive_catalog_id
:
2830 self
.logger
.debug('delete_vminstance(): Found a config drive catalog {} matching '
2831 'vapp_name"{}". Deleting it.'.format(config_drive_catalog_id
, vapp_name
))
2832 self
.delete_image(config_drive_catalog_id
)
2835 self
.logger
.debug(traceback
.format_exc())
2836 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
2839 def refresh_vms_status(self
, vm_list
):
2840 """Get the status of the virtual machines and their interfaces/ports
2841 Params: the list of VM identifiers
2842 Returns a dictionary with:
2843 vm_id: #VIM id of this Virtual Machine
2844 status: #Mandatory. Text with one of:
2845 # DELETED (not found at vim)
2846 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2847 # OTHER (Vim reported other status not understood)
2848 # ERROR (VIM indicates an ERROR status)
2849 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
2850 # CREATING (on building process), ERROR
2851 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
2853 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2854 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2856 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2857 mac_address: #Text format XX:XX:XX:XX:XX:XX
2858 vim_net_id: #network id where this interface is connected
2859 vim_interface_id: #interface/port VIM id
2860 ip_address: #null, or text with IPv4, IPv6 address
2863 self
.logger
.debug("Client requesting refresh vm status for {} ".format(vm_list
))
2865 org
,vdc
= self
.get_vdc_details()
2867 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
2871 for vmuuid
in vm_list
:
2872 vapp_name
= self
.get_namebyvappid(vmuuid
)
2873 if vapp_name
is not None:
2876 vm_pci_details
= self
.get_vm_pci_details(vmuuid
)
2877 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
2878 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
2879 the_vapp
= VApp(self
.client
, resource
=vapp_resource
)
2882 for vm
in the_vapp
.get_all_vms():
2883 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
2884 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
2885 response
= self
.perform_request(req_type
='GET',
2889 if response
.status_code
!= 200:
2890 self
.logger
.error("refresh_vms_status : REST call {} failed reason : {}"\
2891 "status code : {}".format(vm
.get('href'),
2893 response
.status_code
))
2894 raise vimconn
.vimconnException("refresh_vms_status : Failed to get "\
2896 xmlroot
= XmlElementTree
.fromstring(response
.content
)
2899 result
= response
.content
.replace("\n"," ")
2900 hdd_match
= re
.search('vcloud:capacity="(\d+)"\svcloud:storageProfileOverrideVmDefault=',result
)
2902 hdd_mb
= hdd_match
.group(1)
2903 vm_details
['hdd_mb'] = int(hdd_mb
) if hdd_mb
else None
2904 cpus_match
= re
.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result
)
2906 cpus
= cpus_match
.group(1)
2907 vm_details
['cpus'] = int(cpus
) if cpus
else None
2908 memory_mb
= re
.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result
).group(1)
2909 vm_details
['memory_mb'] = int(memory_mb
) if memory_mb
else None
2910 vm_details
['status'] = vcdStatusCode2manoFormat
[int(xmlroot
.get('status'))]
2911 vm_details
['id'] = xmlroot
.get('id')
2912 vm_details
['name'] = xmlroot
.get('name')
2913 vm_info
= [vm_details
]
2915 vm_info
[0].update(vm_pci_details
)
2917 vm_dict
= {'status': vcdStatusCode2manoFormat
[int(vapp_resource
.get('status'))],
2918 'error_msg': vcdStatusCode2manoFormat
[int(vapp_resource
.get('status'))],
2919 'vim_info': yaml
.safe_dump(vm_info
), 'interfaces': []}
2924 networks
= re
.findall('<NetworkConnection needsCustomization=.*?</NetworkConnection>',result
)
2925 for network
in networks
:
2926 mac_s
= re
.search('<MACAddress>(.*?)</MACAddress>',network
)
2927 vm_mac
= mac_s
.group(1) if mac_s
else None
2928 ip_s
= re
.search('<IpAddress>(.*?)</IpAddress>',network
)
2929 vm_ip
= ip_s
.group(1) if ip_s
else None
2932 if not nsx_edge_list
:
2933 nsx_edge_list
= self
.get_edge_details()
2934 if nsx_edge_list
is None:
2935 raise vimconn
.vimconnException("refresh_vms_status:"\
2936 "Failed to get edge details from NSX Manager")
2937 if vm_mac
is not None:
2938 vm_ip
= self
.get_ipaddr_from_NSXedge(nsx_edge_list
, vm_mac
)
2940 net_s
= re
.search('network="(.*?)"',network
)
2941 network_name
= net_s
.group(1) if net_s
else None
2943 vm_net_id
= self
.get_network_id_by_name(network_name
)
2944 interface
= {"mac_address": vm_mac
,
2945 "vim_net_id": vm_net_id
,
2946 "vim_interface_id": vm_net_id
,
2947 "ip_address": vm_ip
}
2949 vm_dict
["interfaces"].append(interface
)
2951 # add a vm to vm dict
2952 vms_dict
.setdefault(vmuuid
, vm_dict
)
2953 self
.logger
.debug("refresh_vms_status : vm info {}".format(vm_dict
))
2954 except Exception as exp
:
2955 self
.logger
.debug("Error in response {}".format(exp
))
2956 self
.logger
.debug(traceback
.format_exc())
2961 def get_edge_details(self
):
2962 """Get the NSX edge list from NSX Manager
2963 Returns list of NSX edges
2966 rheaders
= {'Content-Type': 'application/xml'}
2967 nsx_api_url
= '/api/4.0/edges'
2969 self
.logger
.debug("Get edge details from NSX Manager {} {}".format(self
.nsx_manager
, nsx_api_url
))
2972 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2973 auth
= (self
.nsx_user
, self
.nsx_password
),
2974 verify
= False, headers
= rheaders
)
2975 if resp
.status_code
== requests
.codes
.ok
:
2976 paged_Edge_List
= XmlElementTree
.fromstring(resp
.text
)
2977 for edge_pages
in paged_Edge_List
:
2978 if edge_pages
.tag
== 'edgePage':
2979 for edge_summary
in edge_pages
:
2980 if edge_summary
.tag
== 'pagingInfo':
2981 for element
in edge_summary
:
2982 if element
.tag
== 'totalCount' and element
.text
== '0':
2983 raise vimconn
.vimconnException("get_edge_details: No NSX edges details found: {}"
2984 .format(self
.nsx_manager
))
2986 if edge_summary
.tag
== 'edgeSummary':
2987 for element
in edge_summary
:
2988 if element
.tag
== 'id':
2989 edge_list
.append(element
.text
)
2991 raise vimconn
.vimconnException("get_edge_details: No NSX edge details found: {}"
2992 .format(self
.nsx_manager
))
2995 raise vimconn
.vimconnException("get_edge_details: "\
2996 "No NSX edge details found: {}"
2997 .format(self
.nsx_manager
))
2999 self
.logger
.debug("get_edge_details: Found NSX edges {}".format(edge_list
))
3002 self
.logger
.debug("get_edge_details: "
3003 "Failed to get NSX edge details from NSX Manager: {}"
3004 .format(resp
.content
))
3007 except Exception as exp
:
3008 self
.logger
.debug("get_edge_details: "\
3009 "Failed to get NSX edge details from NSX Manager: {}"
3011 raise vimconn
.vimconnException("get_edge_details: "\
3012 "Failed to get NSX edge details from NSX Manager: {}"
3016 def get_ipaddr_from_NSXedge(self
, nsx_edges
, mac_address
):
3017 """Get IP address details from NSX edges, using the MAC address
3018 PARAMS: nsx_edges : List of NSX edges
3019 mac_address : Find IP address corresponding to this MAC address
3020 Returns: IP address corrresponding to the provided MAC address
3024 rheaders
= {'Content-Type': 'application/xml'}
3026 self
.logger
.debug("get_ipaddr_from_NSXedge: Finding IP addr from NSX edge")
3029 for edge
in nsx_edges
:
3030 nsx_api_url
= '/api/4.0/edges/'+ edge
+'/dhcp/leaseInfo'
3032 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
3033 auth
= (self
.nsx_user
, self
.nsx_password
),
3034 verify
= False, headers
= rheaders
)
3036 if resp
.status_code
== requests
.codes
.ok
:
3037 dhcp_leases
= XmlElementTree
.fromstring(resp
.text
)
3038 for child
in dhcp_leases
:
3039 if child
.tag
== 'dhcpLeaseInfo':
3040 dhcpLeaseInfo
= child
3041 for leaseInfo
in dhcpLeaseInfo
:
3042 for elem
in leaseInfo
:
3043 if (elem
.tag
)=='macAddress':
3044 edge_mac_addr
= elem
.text
3045 if (elem
.tag
)=='ipAddress':
3047 if edge_mac_addr
is not None:
3048 if edge_mac_addr
== mac_address
:
3049 self
.logger
.debug("Found ip addr {} for mac {} at NSX edge {}"
3050 .format(ip_addr
, mac_address
,edge
))
3053 self
.logger
.debug("get_ipaddr_from_NSXedge: "\
3054 "Error occurred while getting DHCP lease info from NSX Manager: {}"
3055 .format(resp
.content
))
3057 self
.logger
.debug("get_ipaddr_from_NSXedge: No IP addr found in any NSX edge")
3060 except XmlElementTree
.ParseError
as Err
:
3061 self
.logger
.debug("ParseError in response from NSX Manager {}".format(Err
.message
), exc_info
=True)
3064 def action_vminstance(self
, vm__vim_uuid
=None, action_dict
=None, created_items
={}):
3065 """Send and action over a VM instance from VIM
3066 Returns the vm_id if the action was successfully sent to the VIM"""
3068 self
.logger
.debug("Received action for vm {} and action dict {}".format(vm__vim_uuid
, action_dict
))
3069 if vm__vim_uuid
is None or action_dict
is None:
3070 raise vimconn
.vimconnException("Invalid request. VM id or action is None.")
3072 org
, vdc
= self
.get_vdc_details()
3074 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
3076 vapp_name
= self
.get_namebyvappid(vm__vim_uuid
)
3077 if vapp_name
is None:
3078 self
.logger
.debug("action_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
3079 raise vimconn
.vimconnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
3081 self
.logger
.info("Action_vminstance vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
3084 vdc_obj
= VDC(self
.client
, href
=vdc
.get('href'))
3085 vapp_resource
= vdc_obj
.get_vapp(vapp_name
)
3086 vapp
= VApp(self
.client
, resource
=vapp_resource
)
3087 if "start" in action_dict
:
3088 self
.logger
.info("action_vminstance: Power on vApp: {}".format(vapp_name
))
3089 poweron_task
= self
.power_on_vapp(vm__vim_uuid
, vapp_name
)
3090 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
3091 self
.instance_actions_result("start", result
, vapp_name
)
3092 elif "rebuild" in action_dict
:
3093 self
.logger
.info("action_vminstance: Rebuild vApp: {}".format(vapp_name
))
3094 rebuild_task
= vapp
.deploy(power_on
=True)
3095 result
= self
.client
.get_task_monitor().wait_for_success(task
=rebuild_task
)
3096 self
.instance_actions_result("rebuild", result
, vapp_name
)
3097 elif "pause" in action_dict
:
3098 self
.logger
.info("action_vminstance: pause vApp: {}".format(vapp_name
))
3099 pause_task
= vapp
.undeploy(action
='suspend')
3100 result
= self
.client
.get_task_monitor().wait_for_success(task
=pause_task
)
3101 self
.instance_actions_result("pause", result
, vapp_name
)
3102 elif "resume" in action_dict
:
3103 self
.logger
.info("action_vminstance: resume vApp: {}".format(vapp_name
))
3104 poweron_task
= self
.power_on_vapp(vm__vim_uuid
, vapp_name
)
3105 result
= self
.client
.get_task_monitor().wait_for_success(task
=poweron_task
)
3106 self
.instance_actions_result("resume", result
, vapp_name
)
3107 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
3108 action_name
, value
= action_dict
.items()[0]
3110 #action_name , value = list(action_dict.items())[0]
3111 self
.logger
.info("action_vminstance: {} vApp: {}".format(action_name
, vapp_name
))
3112 shutdown_task
= vapp
.shutdown()
3113 result
= self
.client
.get_task_monitor().wait_for_success(task
=shutdown_task
)
3114 if action_name
== "shutdown":
3115 self
.instance_actions_result("shutdown", result
, vapp_name
)
3117 self
.instance_actions_result("shutoff", result
, vapp_name
)
3118 elif "forceOff" in action_dict
:
3119 result
= vapp
.undeploy(action
='powerOff')
3120 self
.instance_actions_result("forceOff", result
, vapp_name
)
3121 elif "reboot" in action_dict
:
3122 self
.logger
.info("action_vminstance: reboot vApp: {}".format(vapp_name
))
3123 reboot_task
= vapp
.reboot()
3124 self
.client
.get_task_monitor().wait_for_success(task
=reboot_task
)
3126 raise vimconn
.vimconnException("action_vminstance: Invalid action {} or action is None.".format(action_dict
))
3128 except Exception as exp
:
3129 self
.logger
.debug("action_vminstance: Failed with Exception {}".format(exp
))
3130 raise vimconn
.vimconnException("action_vminstance: Failed with Exception {}".format(exp
))
3132 def instance_actions_result(self
, action
, result
, vapp_name
):
3133 if result
.get('status') == 'success':
3134 self
.logger
.info("action_vminstance: Sucessfully {} the vApp: {}".format(action
, vapp_name
))
3136 self
.logger
.error("action_vminstance: Failed to {} vApp: {}".format(action
, vapp_name
))
3138 def get_vminstance_console(self
, vm_id
, console_type
="novnc"):
3140 Get a console for the virtual machine
3142 vm_id: uuid of the VM
3143 console_type, can be:
3144 "novnc" (by default), "xvpvnc" for VNC types,
3145 "rdp-html5" for RDP types, "spice-html5" for SPICE types
3146 Returns dict with the console parameters:
3147 protocol: ssh, ftp, http, https, ...
3148 server: usually ip address
3149 port: the http, ssh, ... port
3150 suffix: extra text, e.g. the http path and query string
3154 if console_type
==None or console_type
=='novnc':
3156 url_rest_call
= "{}/api/vApp/vm-{}/screen/action/acquireMksTicket".format(self
.url
, vm_id
)
3158 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3159 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3160 response
= self
.perform_request(req_type
='POST',
3164 if response
.status_code
== 403:
3165 response
= self
.retry_rest('GET', url_rest_call
)
3167 if response
.status_code
!= 200:
3168 self
.logger
.error("REST call {} failed reason : {}"\
3169 "status code : {}".format(url_rest_call
,
3171 response
.status_code
))
3172 raise vimconn
.vimconnException("get_vminstance_console : Failed to get "\
3173 "VM Mks ticket details")
3174 s
= re
.search("<Host>(.*?)</Host>",response
.content
)
3175 console_dict
['server'] = s
.group(1) if s
else None
3176 s1
= re
.search("<Port>(\d+)</Port>",response
.content
)
3177 console_dict
['port'] = s1
.group(1) if s1
else None
3180 url_rest_call
= "{}/api/vApp/vm-{}/screen/action/acquireTicket".format(self
.url
, vm_id
)
3182 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3183 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3184 response
= self
.perform_request(req_type
='POST',
3188 if response
.status_code
== 403:
3189 response
= self
.retry_rest('GET', url_rest_call
)
3191 if response
.status_code
!= 200:
3192 self
.logger
.error("REST call {} failed reason : {}"\
3193 "status code : {}".format(url_rest_call
,
3195 response
.status_code
))
3196 raise vimconn
.vimconnException("get_vminstance_console : Failed to get "\
3197 "VM console details")
3198 s
= re
.search(">.*?/(vm-\d+.*)</",response
.content
)
3199 console_dict
['suffix'] = s
.group(1) if s
else None
3200 console_dict
['protocol'] = "https"
3204 # NOT USED METHODS in current version
3206 def host_vim2gui(self
, host
, server_dict
):
3207 """Transform host dictionary from VIM format to GUI format,
3208 and append to the server_dict
3210 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3212 def get_hosts_info(self
):
3213 """Get the information of deployed hosts
3214 Returns the hosts content"""
3215 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3217 def get_hosts(self
, vim_tenant
):
3218 """Get the hosts and deployed instances
3219 Returns the hosts content"""
3220 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3222 def get_processor_rankings(self
):
3223 """Get the processor rankings in the VIM database"""
3224 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3226 def new_host(self
, host_data
):
3227 """Adds a new host to VIM"""
3228 '''Returns status code of the VIM response'''
3229 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3231 def new_external_port(self
, port_data
):
3232 """Adds a external port to VIM"""
3233 '''Returns the port identifier'''
3234 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3236 def new_external_network(self
, net_name
, net_type
):
3237 """Adds a external network to VIM (shared)"""
3238 '''Returns the network identifier'''
3239 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3241 def connect_port_network(self
, port_id
, network_id
, admin
=False):
3242 """Connects a external port to a network"""
3243 '''Returns status code of the VIM response'''
3244 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3246 def new_vminstancefromJSON(self
, vm_data
):
3247 """Adds a VM instance to VIM"""
3248 '''Returns the instance identifier'''
3249 raise vimconn
.vimconnNotImplemented("Should have implemented this")
3251 def get_network_name_by_id(self
, network_uuid
=None):
3252 """Method gets vcloud director network named based on supplied uuid.
3255 network_uuid: network_id
3258 The return network name.
3261 if not network_uuid
:
3265 org_dict
= self
.get_org(self
.org_uuid
)
3266 if 'networks' in org_dict
:
3267 org_network_dict
= org_dict
['networks']
3268 for net_uuid
in org_network_dict
:
3269 if net_uuid
== network_uuid
:
3270 return org_network_dict
[net_uuid
]
3272 self
.logger
.debug("Exception in get_network_name_by_id")
3273 self
.logger
.debug(traceback
.format_exc())
3277 def get_network_id_by_name(self
, network_name
=None):
3278 """Method gets vcloud director network uuid based on supplied name.
3281 network_name: network_name
3283 The return network uuid.
3284 network_uuid: network_id
3287 if not network_name
:
3288 self
.logger
.debug("get_network_id_by_name() : Network name is empty")
3292 org_dict
= self
.get_org(self
.org_uuid
)
3293 if org_dict
and 'networks' in org_dict
:
3294 org_network_dict
= org_dict
['networks']
3295 for net_uuid
,net_name
in org_network_dict
.iteritems():
3297 #for net_uuid,net_name in org_network_dict.items():
3298 if net_name
== network_name
:
3301 except KeyError as exp
:
3302 self
.logger
.debug("get_network_id_by_name() : KeyError- {} ".format(exp
))
3306 def list_org_action(self
):
3308 Method leverages vCloud director and query for available organization for particular user
3311 vca - is active VCA connection.
3312 vdc_name - is a vdc name that will be used to query vms action
3315 The return XML respond
3317 url_list
= [self
.url
, '/api/org']
3318 vm_list_rest_call
= ''.join(url_list
)
3320 if self
.client
._session
:
3321 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3322 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3324 response
= self
.perform_request(req_type
='GET',
3325 url
=vm_list_rest_call
,
3328 if response
.status_code
== 403:
3329 response
= self
.retry_rest('GET', vm_list_rest_call
)
3331 if response
.status_code
== requests
.codes
.ok
:
3332 return response
.content
3336 def get_org_action(self
, org_uuid
=None):
3338 Method leverages vCloud director and retrieve available object for organization.
3341 org_uuid - vCD organization uuid
3342 self.client - is active connection.
3345 The return XML respond
3348 if org_uuid
is None:
3351 url_list
= [self
.url
, '/api/org/', org_uuid
]
3352 vm_list_rest_call
= ''.join(url_list
)
3354 if self
.client
._session
:
3355 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3356 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3358 #response = requests.get(vm_list_rest_call, headers=headers, verify=False)
3359 response
= self
.perform_request(req_type
='GET',
3360 url
=vm_list_rest_call
,
3362 if response
.status_code
== 403:
3363 response
= self
.retry_rest('GET', vm_list_rest_call
)
3365 if response
.status_code
== requests
.codes
.ok
:
3366 return response
.content
3369 def get_org(self
, org_uuid
=None):
3371 Method retrieves available organization in vCloud Director
3374 org_uuid - is a organization uuid.
3377 The return dictionary with following key
3378 "network" - for network list under the org
3379 "catalogs" - for network list under the org
3380 "vdcs" - for vdc list under org
3385 if org_uuid
is None:
3388 content
= self
.get_org_action(org_uuid
=org_uuid
)
3393 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3394 for child
in vm_list_xmlroot
:
3395 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.vdc+xml':
3396 vdc_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
3397 org_dict
['vdcs'] = vdc_list
3398 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.orgNetwork+xml':
3399 network_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
3400 org_dict
['networks'] = network_list
3401 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
3402 catalog_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
3403 org_dict
['catalogs'] = catalog_list
3409 def get_org_list(self
):
3411 Method retrieves available organization in vCloud Director
3414 vca - is active VCA connection.
3417 The return dictionary and key for each entry VDC UUID
3422 content
= self
.list_org_action()
3424 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3425 for vm_xml
in vm_list_xmlroot
:
3426 if vm_xml
.tag
.split("}")[1] == 'Org':
3427 org_uuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3428 org_dict
[org_uuid
[0]] = vm_xml
.attrib
['name']
3434 def vms_view_action(self
, vdc_name
=None):
3435 """ Method leverages vCloud director vms query call
3438 vca - is active VCA connection.
3439 vdc_name - is a vdc name that will be used to query vms action
3442 The return XML respond
3444 vca
= self
.connect()
3445 if vdc_name
is None:
3448 url_list
= [vca
.host
, '/api/vms/query']
3449 vm_list_rest_call
= ''.join(url_list
)
3451 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
3452 refs
= filter(lambda ref
: ref
.name
== vdc_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vdc+xml',
3453 vca
.vcloud_session
.organization
.Link
)
3455 #refs = [ref for ref in vca.vcloud_session.organization.Link if ref.name == vdc_name and\
3456 # ref.type_ == 'application/vnd.vmware.vcloud.vdc+xml']
3458 response
= Http
.get(url
=vm_list_rest_call
,
3459 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3462 if response
.status_code
== requests
.codes
.ok
:
3463 return response
.content
3467 def get_vapp_list(self
, vdc_name
=None):
3469 Method retrieves vApp list deployed vCloud director and returns a dictionary
3470 contains a list of all vapp deployed for queried VDC.
3471 The key for a dictionary is vApp UUID
3475 vca - is active VCA connection.
3476 vdc_name - is a vdc name that will be used to query vms action
3479 The return dictionary and key for each entry vapp UUID
3483 if vdc_name
is None:
3486 content
= self
.vms_view_action(vdc_name
=vdc_name
)
3488 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3489 for vm_xml
in vm_list_xmlroot
:
3490 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
3491 if vm_xml
.attrib
['isVAppTemplate'] == 'true':
3492 rawuuid
= vm_xml
.attrib
['container'].split('/')[-1:]
3493 if 'vappTemplate-' in rawuuid
[0]:
3494 # vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
3495 # vm and use raw UUID as key
3496 vapp_dict
[rawuuid
[0][13:]] = vm_xml
.attrib
3502 def get_vm_list(self
, vdc_name
=None):
3504 Method retrieves VM's list deployed vCloud director. It returns a dictionary
3505 contains a list of all VM's deployed for queried VDC.
3506 The key for a dictionary is VM UUID
3510 vca - is active VCA connection.
3511 vdc_name - is a vdc name that will be used to query vms action
3514 The return dictionary and key for each entry vapp UUID
3518 if vdc_name
is None:
3521 content
= self
.vms_view_action(vdc_name
=vdc_name
)
3523 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3524 for vm_xml
in vm_list_xmlroot
:
3525 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
3526 if vm_xml
.attrib
['isVAppTemplate'] == 'false':
3527 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3528 if 'vm-' in rawuuid
[0]:
3529 # vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
3530 # vm and use raw UUID as key
3531 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
3537 def get_vapp(self
, vdc_name
=None, vapp_name
=None, isuuid
=False):
3539 Method retrieves VM deployed vCloud director. It returns VM attribute as dictionary
3540 contains a list of all VM's deployed for queried VDC.
3541 The key for a dictionary is VM UUID
3545 vca - is active VCA connection.
3546 vdc_name - is a vdc name that will be used to query vms action
3549 The return dictionary and key for each entry vapp UUID
3552 vca
= self
.connect()
3554 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3556 if vdc_name
is None:
3559 content
= self
.vms_view_action(vdc_name
=vdc_name
)
3561 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3562 for vm_xml
in vm_list_xmlroot
:
3563 if vm_xml
.tag
.split("}")[1] == 'VMRecord' and vm_xml
.attrib
['isVAppTemplate'] == 'false':
3564 # lookup done by UUID
3566 if vapp_name
in vm_xml
.attrib
['container']:
3567 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3568 if 'vm-' in rawuuid
[0]:
3569 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
3571 # lookup done by Name
3573 if vapp_name
in vm_xml
.attrib
['name']:
3574 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
3575 if 'vm-' in rawuuid
[0]:
3576 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
3583 def get_network_action(self
, network_uuid
=None):
3585 Method leverages vCloud director and query network based on network uuid
3588 vca - is active VCA connection.
3589 network_uuid - is a network uuid
3592 The return XML respond
3595 if network_uuid
is None:
3598 url_list
= [self
.url
, '/api/network/', network_uuid
]
3599 vm_list_rest_call
= ''.join(url_list
)
3601 if self
.client
._session
:
3602 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3603 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3605 response
= self
.perform_request(req_type
='GET',
3606 url
=vm_list_rest_call
,
3608 #Retry login if session expired & retry sending request
3609 if response
.status_code
== 403:
3610 response
= self
.retry_rest('GET', vm_list_rest_call
)
3612 if response
.status_code
== requests
.codes
.ok
:
3613 return response
.content
3617 def get_vcd_network(self
, network_uuid
=None):
3619 Method retrieves available network from vCloud Director
3622 network_uuid - is VCD network UUID
3624 Each element serialized as key : value pair
3626 Following keys available for access. network_configuration['Gateway'}
3630 <IsInherited>true</IsInherited>
3631 <Gateway>172.16.252.100</Gateway>
3632 <Netmask>255.255.255.0</Netmask>
3633 <Dns1>172.16.254.201</Dns1>
3634 <Dns2>172.16.254.202</Dns2>
3635 <DnsSuffix>vmwarelab.edu</DnsSuffix>
3636 <IsEnabled>true</IsEnabled>
3639 <StartAddress>172.16.252.1</StartAddress>
3640 <EndAddress>172.16.252.99</EndAddress>
3645 <FenceMode>bridged</FenceMode>
3648 The return dictionary and key for each entry vapp UUID
3651 network_configuration
= {}
3652 if network_uuid
is None:
3656 content
= self
.get_network_action(network_uuid
=network_uuid
)
3657 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3659 network_configuration
['status'] = vm_list_xmlroot
.get("status")
3660 network_configuration
['name'] = vm_list_xmlroot
.get("name")
3661 network_configuration
['uuid'] = vm_list_xmlroot
.get("id").split(":")[3]
3663 for child
in vm_list_xmlroot
:
3664 if child
.tag
.split("}")[1] == 'IsShared':
3665 network_configuration
['isShared'] = child
.text
.strip()
3666 if child
.tag
.split("}")[1] == 'Configuration':
3667 for configuration
in child
.iter():
3668 tagKey
= configuration
.tag
.split("}")[1].strip()
3670 network_configuration
[tagKey
] = configuration
.text
.strip()
3671 return network_configuration
3672 except Exception as exp
:
3673 self
.logger
.debug("get_vcd_network: Failed with Exception {}".format(exp
))
3674 raise vimconn
.vimconnException("get_vcd_network: Failed with Exception {}".format(exp
))
3676 return network_configuration
3678 def delete_network_action(self
, network_uuid
=None):
3680 Method delete given network from vCloud director
3683 network_uuid - is a network uuid that client wish to delete
3686 The return None or XML respond or false
3688 client
= self
.connect_as_admin()
3690 raise vimconn
.vimconnConnectionException("Failed to connect vCD as admin")
3691 if network_uuid
is None:
3694 url_list
= [self
.url
, '/api/admin/network/', network_uuid
]
3695 vm_list_rest_call
= ''.join(url_list
)
3698 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3699 'x-vcloud-authorization': client
._session
.headers
['x-vcloud-authorization']}
3700 response
= self
.perform_request(req_type
='DELETE',
3701 url
=vm_list_rest_call
,
3703 if response
.status_code
== 202:
3708 def create_network(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
3709 ip_profile
=None, isshared
='true'):
3711 Method create network in vCloud director
3714 network_name - is network name to be created.
3715 net_type - can be 'bridge','data','ptp','mgmt'.
3716 ip_profile is a dict containing the IP parameters of the network
3717 isshared - is a boolean
3718 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3719 It optional attribute. by default if no parent network indicate the first available will be used.
3722 The return network uuid or return None
3725 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
3726 content
= self
.create_network_rest(network_name
=''.join(new_network_name
),
3727 ip_profile
=ip_profile
,
3729 parent_network_uuid
=parent_network_uuid
,
3732 self
.logger
.debug("Failed create network {}.".format(network_name
))
3736 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
3737 vcd_uuid
= vm_list_xmlroot
.get('id').split(":")
3738 if len(vcd_uuid
) == 4:
3739 self
.logger
.info("Created new network name: {} uuid: {}".format(network_name
, vcd_uuid
[3]))
3742 self
.logger
.debug("Failed create network {}".format(network_name
))
3745 def create_network_rest(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
3746 ip_profile
=None, isshared
='true'):
3748 Method create network in vCloud director
3751 network_name - is network name to be created.
3752 net_type - can be 'bridge','data','ptp','mgmt'.
3753 ip_profile is a dict containing the IP parameters of the network
3754 isshared - is a boolean
3755 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3756 It optional attribute. by default if no parent network indicate the first available will be used.
3759 The return network uuid or return None
3761 client_as_admin
= self
.connect_as_admin()
3762 if not client_as_admin
:
3763 raise vimconn
.vimconnConnectionException("Failed to connect vCD.")
3764 if network_name
is None:
3767 url_list
= [self
.url
, '/api/admin/vdc/', self
.tenant_id
]
3768 vm_list_rest_call
= ''.join(url_list
)
3770 if client_as_admin
._session
:
3771 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3772 'x-vcloud-authorization': client_as_admin
._session
.headers
['x-vcloud-authorization']}
3774 response
= self
.perform_request(req_type
='GET',
3775 url
=vm_list_rest_call
,
3778 provider_network
= None
3779 available_networks
= None
3780 add_vdc_rest_url
= None
3782 if response
.status_code
!= requests
.codes
.ok
:
3783 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3784 response
.status_code
))
3788 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3789 for child
in vm_list_xmlroot
:
3790 if child
.tag
.split("}")[1] == 'ProviderVdcReference':
3791 provider_network
= child
.attrib
.get('href')
3792 # application/vnd.vmware.admin.providervdc+xml
3793 if child
.tag
.split("}")[1] == 'Link':
3794 if child
.attrib
.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
3795 and child
.attrib
.get('rel') == 'add':
3796 add_vdc_rest_url
= child
.attrib
.get('href')
3798 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3799 self
.logger
.debug("Respond body {}".format(response
.content
))
3802 # find pvdc provided available network
3803 response
= self
.perform_request(req_type
='GET',
3804 url
=provider_network
,
3806 if response
.status_code
!= requests
.codes
.ok
:
3807 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3808 response
.status_code
))
3811 if parent_network_uuid
is None:
3813 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3814 for child
in vm_list_xmlroot
.iter():
3815 if child
.tag
.split("}")[1] == 'AvailableNetworks':
3816 for networks
in child
.iter():
3817 # application/vnd.vmware.admin.network+xml
3818 if networks
.attrib
.get('href') is not None:
3819 available_networks
= networks
.attrib
.get('href')
3825 #Configure IP profile of the network
3826 ip_profile
= ip_profile
if ip_profile
is not None else DEFAULT_IP_PROFILE
3828 if 'subnet_address' not in ip_profile
or ip_profile
['subnet_address'] is None:
3829 subnet_rand
= random
.randint(0, 255)
3830 ip_base
= "192.168.{}.".format(subnet_rand
)
3831 ip_profile
['subnet_address'] = ip_base
+ "0/24"
3833 ip_base
= ip_profile
['subnet_address'].rsplit('.',1)[0] + '.'
3835 if 'gateway_address' not in ip_profile
or ip_profile
['gateway_address'] is None:
3836 ip_profile
['gateway_address']=ip_base
+ "1"
3837 if 'dhcp_count' not in ip_profile
or ip_profile
['dhcp_count'] is None:
3838 ip_profile
['dhcp_count']=DEFAULT_IP_PROFILE
['dhcp_count']
3839 if 'dhcp_enabled' not in ip_profile
or ip_profile
['dhcp_enabled'] is None:
3840 ip_profile
['dhcp_enabled']=DEFAULT_IP_PROFILE
['dhcp_enabled']
3841 if 'dhcp_start_address' not in ip_profile
or ip_profile
['dhcp_start_address'] is None:
3842 ip_profile
['dhcp_start_address']=ip_base
+ "3"
3843 if 'ip_version' not in ip_profile
or ip_profile
['ip_version'] is None:
3844 ip_profile
['ip_version']=DEFAULT_IP_PROFILE
['ip_version']
3845 if 'dns_address' not in ip_profile
or ip_profile
['dns_address'] is None:
3846 ip_profile
['dns_address']=ip_base
+ "2"
3848 gateway_address
=ip_profile
['gateway_address']
3849 dhcp_count
=int(ip_profile
['dhcp_count'])
3850 subnet_address
=self
.convert_cidr_to_netmask(ip_profile
['subnet_address'])
3852 if ip_profile
['dhcp_enabled']==True:
3855 dhcp_enabled
='false'
3856 dhcp_start_address
=ip_profile
['dhcp_start_address']
3858 #derive dhcp_end_address from dhcp_start_address & dhcp_count
3859 end_ip_int
= int(netaddr
.IPAddress(dhcp_start_address
))
3860 end_ip_int
+= dhcp_count
- 1
3861 dhcp_end_address
= str(netaddr
.IPAddress(end_ip_int
))
3863 ip_version
=ip_profile
['ip_version']
3864 dns_address
=ip_profile
['dns_address']
3865 except KeyError as exp
:
3866 self
.logger
.debug("Create Network REST: Key error {}".format(exp
))
3867 raise vimconn
.vimconnException("Create Network REST: Key error{}".format(exp
))
3869 # either use client provided UUID or search for a first available
3870 # if both are not defined we return none
3871 if parent_network_uuid
is not None:
3872 provider_network
= None
3873 available_networks
= None
3874 add_vdc_rest_url
= None
3876 url_list
= [self
.url
, '/api/admin/vdc/', self
.tenant_id
, '/networks']
3877 add_vdc_rest_url
= ''.join(url_list
)
3879 url_list
= [self
.url
, '/api/admin/network/', parent_network_uuid
]
3880 available_networks
= ''.join(url_list
)
3882 #Creating all networks as Direct Org VDC type networks.
3883 #Unused in case of Underlay (data/ptp) network interface.
3884 fence_mode
="isolated"
3885 is_inherited
='false'
3886 dns_list
= dns_address
.split(";")
3889 if len(dns_list
) >= 2:
3890 dns2_text
= "\n <Dns2>{}</Dns2>\n".format(dns_list
[1])
3891 data
= """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
3892 <Description>Openmano created</Description>
3896 <IsInherited>{1:s}</IsInherited>
3897 <Gateway>{2:s}</Gateway>
3898 <Netmask>{3:s}</Netmask>
3899 <Dns1>{4:s}</Dns1>{5:s}
3900 <IsEnabled>{6:s}</IsEnabled>
3903 <StartAddress>{7:s}</StartAddress>
3904 <EndAddress>{8:s}</EndAddress>
3909 <FenceMode>{9:s}</FenceMode>
3911 <IsShared>{10:s}</IsShared>
3912 </OrgVdcNetwork> """.format(escape(network_name
), is_inherited
, gateway_address
,
3913 subnet_address
, dns1
, dns2_text
, dhcp_enabled
,
3914 dhcp_start_address
, dhcp_end_address
,
3915 fence_mode
, isshared
)
3917 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
3919 response
= self
.perform_request(req_type
='POST',
3920 url
=add_vdc_rest_url
,
3924 if response
.status_code
!= 201:
3925 self
.logger
.debug("Create Network POST REST API call failed. Return status code {}, Response content: {}"
3926 .format(response
.status_code
,response
.content
))
3928 network_task
= self
.get_task_from_response(response
.content
)
3929 self
.logger
.debug("Create Network REST : Waiting for Network creation complete")
3931 result
= self
.client
.get_task_monitor().wait_for_success(task
=network_task
)
3932 if result
.get('status') == 'success':
3933 return response
.content
3935 self
.logger
.debug("create_network_rest task failed. Network Create response : {}"
3936 .format(response
.content
))
3937 except Exception as exp
:
3938 self
.logger
.debug("create_network_rest : Exception : {} ".format(exp
))
3942 def convert_cidr_to_netmask(self
, cidr_ip
=None):
3944 Method sets convert CIDR netmask address to normal IP format
3946 cidr_ip : CIDR IP address
3948 netmask : Converted netmask
3950 if cidr_ip
is not None:
3952 network
, net_bits
= cidr_ip
.split('/')
3953 netmask
= socket
.inet_ntoa(struct
.pack(">I", (0xffffffff << (32 - int(net_bits
))) & 0xffffffff))
3959 def get_provider_rest(self
, vca
=None):
3961 Method gets provider vdc view from vcloud director
3964 network_name - is network name to be created.
3965 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3966 It optional attribute. by default if no parent network indicate the first available will be used.
3969 The return xml content of respond or None
3972 url_list
= [self
.url
, '/api/admin']
3974 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
3975 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
3976 response
= self
.perform_request(req_type
='GET',
3977 url
=''.join(url_list
),
3980 if response
.status_code
== requests
.codes
.ok
:
3981 return response
.content
3984 def create_vdc(self
, vdc_name
=None):
3988 xml_content
= self
.create_vdc_from_tmpl_rest(vdc_name
=vdc_name
)
3989 if xml_content
is not None:
3991 task_resp_xmlroot
= XmlElementTree
.fromstring(xml_content
)
3992 for child
in task_resp_xmlroot
:
3993 if child
.tag
.split("}")[1] == 'Owner':
3994 vdc_id
= child
.attrib
.get('href').split("/")[-1]
3995 vdc_dict
[vdc_id
] = task_resp_xmlroot
.get('href')
3998 self
.logger
.debug("Respond body {}".format(xml_content
))
4002 def create_vdc_from_tmpl_rest(self
, vdc_name
=None):
4004 Method create vdc in vCloud director based on VDC template.
4005 it uses pre-defined template.
4008 vdc_name - name of a new vdc.
4011 The return xml content of respond or None
4013 # pre-requesite atleast one vdc template should be available in vCD
4014 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
4015 vca
= self
.connect_as_admin()
4017 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
4018 if vdc_name
is None:
4021 url_list
= [self
.url
, '/api/vdcTemplates']
4022 vm_list_rest_call
= ''.join(url_list
)
4024 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4025 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
4026 response
= self
.perform_request(req_type
='GET',
4027 url
=vm_list_rest_call
,
4030 # container url to a template
4031 vdc_template_ref
= None
4033 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
4034 for child
in vm_list_xmlroot
:
4035 # application/vnd.vmware.admin.providervdc+xml
4036 # we need find a template from witch we instantiate VDC
4037 if child
.tag
.split("}")[1] == 'VdcTemplate':
4038 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml':
4039 vdc_template_ref
= child
.attrib
.get('href')
4041 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
4042 self
.logger
.debug("Respond body {}".format(response
.content
))
4045 # if we didn't found required pre defined template we return None
4046 if vdc_template_ref
is None:
4051 url_list
= [self
.url
, '/api/org/', self
.org_uuid
, '/action/instantiate']
4052 vm_list_rest_call
= ''.join(url_list
)
4053 data
= """<InstantiateVdcTemplateParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
4054 <Source href="{1:s}"></Source>
4055 <Description>opnemano</Description>
4056 </InstantiateVdcTemplateParams>""".format(vdc_name
, vdc_template_ref
)
4058 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVdcTemplateParams+xml'
4060 response
= self
.perform_request(req_type
='POST',
4061 url
=vm_list_rest_call
,
4065 vdc_task
= self
.get_task_from_response(response
.content
)
4066 self
.client
.get_task_monitor().wait_for_success(task
=vdc_task
)
4068 # if we all ok we respond with content otherwise by default None
4069 if response
.status_code
>= 200 and response
.status_code
< 300:
4070 return response
.content
4073 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
4074 self
.logger
.debug("Respond body {}".format(response
.content
))
4078 def create_vdc_rest(self
, vdc_name
=None):
4080 Method create network in vCloud director
4083 vdc_name - vdc name to be created
4088 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
4090 vca
= self
.connect_as_admin()
4092 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
4093 if vdc_name
is None:
4096 url_list
= [self
.url
, '/api/admin/org/', self
.org_uuid
]
4097 vm_list_rest_call
= ''.join(url_list
)
4100 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4101 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4102 response
= self
.perform_request(req_type
='GET',
4103 url
=vm_list_rest_call
,
4106 provider_vdc_ref
= None
4107 add_vdc_rest_url
= None
4108 available_networks
= None
4110 if response
.status_code
!= requests
.codes
.ok
:
4111 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
4112 response
.status_code
))
4116 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
4117 for child
in vm_list_xmlroot
:
4118 # application/vnd.vmware.admin.providervdc+xml
4119 if child
.tag
.split("}")[1] == 'Link':
4120 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
4121 and child
.attrib
.get('rel') == 'add':
4122 add_vdc_rest_url
= child
.attrib
.get('href')
4124 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
4125 self
.logger
.debug("Respond body {}".format(response
.content
))
4128 response
= self
.get_provider_rest(vca
=vca
)
4130 vm_list_xmlroot
= XmlElementTree
.fromstring(response
)
4131 for child
in vm_list_xmlroot
:
4132 if child
.tag
.split("}")[1] == 'ProviderVdcReferences':
4133 for sub_child
in child
:
4134 provider_vdc_ref
= sub_child
.attrib
.get('href')
4136 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
4137 self
.logger
.debug("Respond body {}".format(response
))
4140 if add_vdc_rest_url
is not None and provider_vdc_ref
is not None:
4141 data
= """ <CreateVdcParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5"><Description>{1:s}</Description>
4142 <AllocationModel>ReservationPool</AllocationModel>
4143 <ComputeCapacity><Cpu><Units>MHz</Units><Allocated>2048</Allocated><Limit>2048</Limit></Cpu>
4144 <Memory><Units>MB</Units><Allocated>2048</Allocated><Limit>2048</Limit></Memory>
4145 </ComputeCapacity><NicQuota>0</NicQuota><NetworkQuota>100</NetworkQuota>
4146 <VdcStorageProfile><Enabled>true</Enabled><Units>MB</Units><Limit>20480</Limit><Default>true</Default></VdcStorageProfile>
4147 <ProviderVdcReference
4148 name="Main Provider"
4150 <UsesFastProvisioning>true</UsesFastProvisioning></CreateVdcParams>""".format(escape(vdc_name
),
4154 headers
['Content-Type'] = 'application/vnd.vmware.admin.createVdcParams+xml'
4156 response
= self
.perform_request(req_type
='POST',
4157 url
=add_vdc_rest_url
,
4161 # if we all ok we respond with content otherwise by default None
4162 if response
.status_code
== 201:
4163 return response
.content
4166 def get_vapp_details_rest(self
, vapp_uuid
=None, need_admin_access
=False):
4168 Method retrieve vapp detail from vCloud director
4171 vapp_uuid - is vapp identifier.
4174 The return network uuid or return None
4180 if need_admin_access
:
4181 vca
= self
.connect_as_admin()
4186 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
4187 if vapp_uuid
is None:
4190 url_list
= [self
.url
, '/api/vApp/vapp-', vapp_uuid
]
4191 get_vapp_restcall
= ''.join(url_list
)
4194 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4195 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
4196 response
= self
.perform_request(req_type
='GET',
4197 url
=get_vapp_restcall
,
4200 if response
.status_code
== 403:
4201 if need_admin_access
== False:
4202 response
= self
.retry_rest('GET', get_vapp_restcall
)
4204 if response
.status_code
!= requests
.codes
.ok
:
4205 self
.logger
.debug("REST API call {} failed. Return status code {}".format(get_vapp_restcall
,
4206 response
.status_code
))
4207 return parsed_respond
4210 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
4211 parsed_respond
['ovfDescriptorUploaded'] = xmlroot_respond
.attrib
['ovfDescriptorUploaded']
4213 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
4214 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
4215 'vmw': 'http://www.vmware.com/schema/ovf',
4216 'vm': 'http://www.vmware.com/vcloud/v1.5',
4217 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
4218 "vmext":"http://www.vmware.com/vcloud/extension/v1.5",
4219 "xmlns":"http://www.vmware.com/vcloud/v1.5"
4222 created_section
= xmlroot_respond
.find('vm:DateCreated', namespaces
)
4223 if created_section
is not None:
4224 parsed_respond
['created'] = created_section
.text
4226 network_section
= xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig', namespaces
)
4227 if network_section
is not None and 'networkName' in network_section
.attrib
:
4228 parsed_respond
['networkname'] = network_section
.attrib
['networkName']
4230 ipscopes_section
= \
4231 xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig/vm:Configuration/vm:IpScopes',
4233 if ipscopes_section
is not None:
4234 for ipscope
in ipscopes_section
:
4235 for scope
in ipscope
:
4236 tag_key
= scope
.tag
.split("}")[1]
4237 if tag_key
== 'IpRanges':
4238 ip_ranges
= scope
.getchildren()
4239 for ipblock
in ip_ranges
:
4240 for block
in ipblock
:
4241 parsed_respond
[block
.tag
.split("}")[1]] = block
.text
4243 parsed_respond
[tag_key
] = scope
.text
4245 # parse children section for other attrib
4246 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
4247 if children_section
is not None:
4248 parsed_respond
['name'] = children_section
.attrib
['name']
4249 parsed_respond
['nestedHypervisorEnabled'] = children_section
.attrib
['nestedHypervisorEnabled'] \
4250 if "nestedHypervisorEnabled" in children_section
.attrib
else None
4251 parsed_respond
['deployed'] = children_section
.attrib
['deployed']
4252 parsed_respond
['status'] = children_section
.attrib
['status']
4253 parsed_respond
['vmuuid'] = children_section
.attrib
['id'].split(":")[-1]
4254 network_adapter
= children_section
.find('vm:NetworkConnectionSection', namespaces
)
4256 for adapters
in network_adapter
:
4257 adapter_key
= adapters
.tag
.split("}")[1]
4258 if adapter_key
== 'PrimaryNetworkConnectionIndex':
4259 parsed_respond
['primarynetwork'] = adapters
.text
4260 if adapter_key
== 'NetworkConnection':
4262 if 'network' in adapters
.attrib
:
4263 vnic
['network'] = adapters
.attrib
['network']
4264 for adapter
in adapters
:
4265 setting_key
= adapter
.tag
.split("}")[1]
4266 vnic
[setting_key
] = adapter
.text
4267 nic_list
.append(vnic
)
4269 for link
in children_section
:
4270 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
4271 if link
.attrib
['rel'] == 'screen:acquireTicket':
4272 parsed_respond
['acquireTicket'] = link
.attrib
4273 if link
.attrib
['rel'] == 'screen:acquireMksTicket':
4274 parsed_respond
['acquireMksTicket'] = link
.attrib
4276 parsed_respond
['interfaces'] = nic_list
4277 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
4278 if vCloud_extension_section
is not None:
4279 vm_vcenter_info
= {}
4280 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
4281 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
4282 if vmext
is not None:
4283 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
4284 parsed_respond
["vm_vcenter_info"]= vm_vcenter_info
4286 virtual_hardware_section
= children_section
.find('ovf:VirtualHardwareSection', namespaces
)
4287 vm_virtual_hardware_info
= {}
4288 if virtual_hardware_section
is not None:
4289 for item
in virtual_hardware_section
.iterfind('ovf:Item',namespaces
):
4290 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
4291 disk_size
= item
.find("rasd:HostResource" ,namespaces
4292 ).attrib
["{"+namespaces
['vm']+"}capacity"]
4294 vm_virtual_hardware_info
["disk_size"]= disk_size
4297 for link
in virtual_hardware_section
:
4298 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
4299 if link
.attrib
['rel'] == 'edit' and link
.attrib
['href'].endswith("/disks"):
4300 vm_virtual_hardware_info
["disk_edit_href"] = link
.attrib
['href']
4303 parsed_respond
["vm_virtual_hardware"]= vm_virtual_hardware_info
4304 except Exception as exp
:
4305 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
4306 return parsed_respond
4308 def acquire_console(self
, vm_uuid
=None):
4312 if self
.client
._session
:
4313 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4314 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4315 vm_dict
= self
.get_vapp_details_rest(vapp_uuid
=vm_uuid
)
4316 console_dict
= vm_dict
['acquireTicket']
4317 console_rest_call
= console_dict
['href']
4319 response
= self
.perform_request(req_type
='POST',
4320 url
=console_rest_call
,
4323 if response
.status_code
== 403:
4324 response
= self
.retry_rest('POST', console_rest_call
)
4326 if response
.status_code
== requests
.codes
.ok
:
4327 return response
.content
4331 def modify_vm_disk(self
, vapp_uuid
, flavor_disk
):
4333 Method retrieve vm disk details
4336 vapp_uuid - is vapp identifier.
4337 flavor_disk - disk size as specified in VNFD (flavor)
4340 The return network uuid or return None
4344 #Flavor disk is in GB convert it into MB
4345 flavor_disk
= int(flavor_disk
) * 1024
4346 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
4348 vm_name
= vm_details
["name"]
4349 self
.logger
.info("VM: {} flavor_disk :{}".format(vm_name
, flavor_disk
))
4351 if vm_details
and "vm_virtual_hardware" in vm_details
:
4352 vm_disk
= int(vm_details
["vm_virtual_hardware"]["disk_size"])
4353 disk_edit_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
4355 self
.logger
.info("VM: {} VM_disk :{}".format(vm_name
, vm_disk
))
4357 if flavor_disk
> vm_disk
:
4358 status
= self
.modify_vm_disk_rest(disk_edit_href
,flavor_disk
)
4359 self
.logger
.info("Modify disk of VM {} from {} to {} MB".format(vm_name
,
4360 vm_disk
, flavor_disk
))
4363 self
.logger
.info("No need to modify disk of VM {}".format(vm_name
))
4366 except Exception as exp
:
4367 self
.logger
.info("Error occurred while modifing disk size {}".format(exp
))
4370 def modify_vm_disk_rest(self
, disk_href
, disk_size
):
4372 Method retrieve modify vm disk size
4375 disk_href - vCD API URL to GET and PUT disk data
4376 disk_size - disk size as specified in VNFD (flavor)
4379 The return network uuid or return None
4381 if disk_href
is None or disk_size
is None:
4384 if self
.client
._session
:
4385 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4386 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4387 response
= self
.perform_request(req_type
='GET',
4391 if response
.status_code
== 403:
4392 response
= self
.retry_rest('GET', disk_href
)
4394 if response
.status_code
!= requests
.codes
.ok
:
4395 self
.logger
.debug("GET REST API call {} failed. Return status code {}".format(disk_href
,
4396 response
.status_code
))
4399 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
4400 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
4402 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
4403 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
4405 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
4406 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
4407 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
4408 if disk_item
is not None:
4409 disk_item
.attrib
["{"+namespaces
['xmlns']+"}capacity"] = str(disk_size
)
4412 data
= lxmlElementTree
.tostring(lxmlroot_respond
, encoding
='utf8', method
='xml',
4413 xml_declaration
=True)
4415 #Send PUT request to modify disk size
4416 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
4418 response
= self
.perform_request(req_type
='PUT',
4422 if response
.status_code
== 403:
4423 add_headers
= {'Content-Type': headers
['Content-Type']}
4424 response
= self
.retry_rest('PUT', disk_href
, add_headers
, data
)
4426 if response
.status_code
!= 202:
4427 self
.logger
.debug("PUT REST API call {} failed. Return status code {}".format(disk_href
,
4428 response
.status_code
))
4430 modify_disk_task
= self
.get_task_from_response(response
.content
)
4431 result
= self
.client
.get_task_monitor().wait_for_success(task
=modify_disk_task
)
4432 if result
.get('status') == 'success':
4438 except Exception as exp
:
4439 self
.logger
.info("Error occurred calling rest api for modifing disk size {}".format(exp
))
4442 def add_pci_devices(self
, vapp_uuid
, pci_devices
, vmname_andid
):
4444 Method to attach pci devices to VM
4447 vapp_uuid - uuid of vApp/VM
4448 pci_devices - pci devices infromation as specified in VNFD (flavor)
4451 The status of add pci device task , vm object and
4452 vcenter_conect object
4455 self
.logger
.info("Add pci devices {} into vApp {}".format(pci_devices
, vapp_uuid
))
4456 vcenter_conect
, content
= self
.get_vcenter_content()
4457 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
4461 no_of_pci_devices
= len(pci_devices
)
4462 if no_of_pci_devices
> 0:
4463 #Get VM and its host
4464 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4465 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
4466 if host_obj
and vm_obj
:
4467 #get PCI devies from host on which vapp is currently installed
4468 avilable_pci_devices
= self
.get_pci_devices(host_obj
, no_of_pci_devices
)
4470 if avilable_pci_devices
is None:
4471 #find other hosts with active pci devices
4472 new_host_obj
, avilable_pci_devices
= self
.get_host_and_PCIdevices(
4477 if new_host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
4478 #Migrate vm to the host where PCI devices are availble
4479 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
, new_host_obj
))
4480 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
4481 if task
is not None:
4482 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4483 self
.logger
.info("Migrate VM status: {}".format(result
))
4484 host_obj
= new_host_obj
4486 self
.logger
.info("Fail to migrate VM : {}".format(result
))
4487 raise vimconn
.vimconnNotFoundException(
4488 "Fail to migrate VM : {} to host {}".format(
4493 if host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
4494 #Add PCI devices one by one
4495 for pci_device
in avilable_pci_devices
:
4496 task
= self
.add_pci_to_vm(host_obj
, vm_obj
, pci_device
)
4498 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4500 self
.logger
.info("Added PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
4502 self
.logger
.error("Fail to add PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
4503 return True, vm_obj
, vcenter_conect
4505 self
.logger
.error("Currently there is no host with"\
4506 " {} number of avaialble PCI devices required for VM {}".format(
4510 raise vimconn
.vimconnNotFoundException(
4511 "Currently there is no host with {} "\
4512 "number of avaialble PCI devices required for VM {}".format(
4516 self
.logger
.debug("No infromation about PCI devices {} ",pci_devices
)
4518 except vmodl
.MethodFault
as error
:
4519 self
.logger
.error("Error occurred while adding PCI devices {} ",error
)
4520 return None, vm_obj
, vcenter_conect
4522 def get_vm_obj(self
, content
, mob_id
):
4524 Method to get the vsphere VM object associated with a given morf ID
4526 vapp_uuid - uuid of vApp/VM
4527 content - vCenter content object
4528 mob_id - mob_id of VM
4536 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
4537 [vim
.VirtualMachine
], True
4539 for vm
in container
.view
:
4540 mobID
= vm
._GetMoId
()
4543 host_obj
= vm_obj
.runtime
.host
4545 except Exception as exp
:
4546 self
.logger
.error("Error occurred while finding VM object : {}".format(exp
))
4547 return host_obj
, vm_obj
4549 def get_pci_devices(self
, host
, need_devices
):
4551 Method to get the details of pci devices on given host
4553 host - vSphere host object
4554 need_devices - number of pci devices needed on host
4557 array of pci devices
4561 used_devices_ids
= []
4565 pciPassthruInfo
= host
.config
.pciPassthruInfo
4566 pciDevies
= host
.hardware
.pciDevice
4568 for pci_status
in pciPassthruInfo
:
4569 if pci_status
.passthruActive
:
4570 for device
in pciDevies
:
4571 if device
.id == pci_status
.id:
4572 all_device_ids
.append(device
.id)
4573 all_devices
.append(device
)
4575 #check if devices are in use
4576 avalible_devices
= all_devices
4578 if vm
.runtime
.powerState
== vim
.VirtualMachinePowerState
.poweredOn
:
4579 vm_devices
= vm
.config
.hardware
.device
4580 for device
in vm_devices
:
4581 if type(device
) is vim
.vm
.device
.VirtualPCIPassthrough
:
4582 if device
.backing
.id in all_device_ids
:
4583 for use_device
in avalible_devices
:
4584 if use_device
.id == device
.backing
.id:
4585 avalible_devices
.remove(use_device
)
4586 used_devices_ids
.append(device
.backing
.id)
4587 self
.logger
.debug("Device {} from devices {}"\
4588 "is in use".format(device
.backing
.id,
4591 if len(avalible_devices
) < need_devices
:
4592 self
.logger
.debug("Host {} don't have {} number of active devices".format(host
,
4594 self
.logger
.debug("found only {} devives {}".format(len(avalible_devices
),
4598 required_devices
= avalible_devices
[:need_devices
]
4599 self
.logger
.info("Found {} PCI devivces on host {} but required only {}".format(
4600 len(avalible_devices
),
4603 self
.logger
.info("Retruning {} devices as {}".format(need_devices
,
4605 return required_devices
4607 except Exception as exp
:
4608 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host
))
4612 def get_host_and_PCIdevices(self
, content
, need_devices
):
4614 Method to get the details of pci devices infromation on all hosts
4617 content - vSphere host object
4618 need_devices - number of pci devices needed on host
4621 array of pci devices and host object
4624 pci_device_objs
= None
4627 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
4628 [vim
.HostSystem
], True)
4629 for host
in container
.view
:
4630 devices
= self
.get_pci_devices(host
, need_devices
)
4633 pci_device_objs
= devices
4635 except Exception as exp
:
4636 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host_obj
))
4638 return host_obj
,pci_device_objs
4640 def relocate_vm(self
, dest_host
, vm
) :
4642 Method to get the relocate VM to new host
4645 dest_host - vSphere host object
4646 vm - vSphere VM object
4653 relocate_spec
= vim
.vm
.RelocateSpec(host
=dest_host
)
4654 task
= vm
.Relocate(relocate_spec
)
4655 self
.logger
.info("Migrating {} to destination host {}".format(vm
, dest_host
))
4656 except Exception as exp
:
4657 self
.logger
.error("Error occurred while relocate VM {} to new host {}: {}".format(
4658 dest_host
, vm
, exp
))
4661 def wait_for_vcenter_task(self
, task
, actionName
='job', hideResult
=False):
4663 Waits and provides updates on a vSphere task
4665 while task
.info
.state
== vim
.TaskInfo
.State
.running
:
4668 if task
.info
.state
== vim
.TaskInfo
.State
.success
:
4669 if task
.info
.result
is not None and not hideResult
:
4670 self
.logger
.info('{} completed successfully, result: {}'.format(
4674 self
.logger
.info('Task {} completed successfully.'.format(actionName
))
4676 self
.logger
.error('{} did not complete successfully: {} '.format(
4681 return task
.info
.result
4683 def add_pci_to_vm(self
,host_object
, vm_object
, host_pci_dev
):
4685 Method to add pci device in given VM
4688 host_object - vSphere host object
4689 vm_object - vSphere VM object
4690 host_pci_dev - host_pci_dev must be one of the devices from the
4691 host_object.hardware.pciDevice list
4692 which is configured as a PCI passthrough device
4698 if vm_object
and host_object
and host_pci_dev
:
4700 #Add PCI device to VM
4701 pci_passthroughs
= vm_object
.environmentBrowser
.QueryConfigTarget(host
=None).pciPassthrough
4702 systemid_by_pciid
= {item
.pciDevice
.id: item
.systemId
for item
in pci_passthroughs
}
4704 if host_pci_dev
.id not in systemid_by_pciid
:
4705 self
.logger
.error("Device {} is not a passthrough device ".format(host_pci_dev
))
4708 deviceId
= hex(host_pci_dev
.deviceId
% 2**16).lstrip('0x')
4709 backing
= vim
.VirtualPCIPassthroughDeviceBackingInfo(deviceId
=deviceId
,
4711 systemId
=systemid_by_pciid
[host_pci_dev
.id],
4712 vendorId
=host_pci_dev
.vendorId
,
4713 deviceName
=host_pci_dev
.deviceName
)
4715 hba_object
= vim
.VirtualPCIPassthrough(key
=-100, backing
=backing
)
4717 new_device_config
= vim
.VirtualDeviceConfigSpec(device
=hba_object
)
4718 new_device_config
.operation
= "add"
4719 vmConfigSpec
= vim
.vm
.ConfigSpec()
4720 vmConfigSpec
.deviceChange
= [new_device_config
]
4722 task
= vm_object
.ReconfigVM_Task(spec
=vmConfigSpec
)
4723 self
.logger
.info("Adding PCI device {} into VM {} from host {} ".format(
4724 host_pci_dev
, vm_object
, host_object
)
4726 except Exception as exp
:
4727 self
.logger
.error("Error occurred while adding pci devive {} to VM {}: {}".format(
4733 def get_vm_vcenter_info(self
):
4735 Method to get details of vCenter and vm
4738 vapp_uuid - uuid of vApp or VM
4741 Moref Id of VM and deails of vCenter
4743 vm_vcenter_info
= {}
4745 if self
.vcenter_ip
is not None:
4746 vm_vcenter_info
["vm_vcenter_ip"] = self
.vcenter_ip
4748 raise vimconn
.vimconnException(message
="vCenter IP is not provided."\
4749 " Please provide vCenter IP while attaching datacenter to tenant in --config")
4750 if self
.vcenter_port
is not None:
4751 vm_vcenter_info
["vm_vcenter_port"] = self
.vcenter_port
4753 raise vimconn
.vimconnException(message
="vCenter port is not provided."\
4754 " Please provide vCenter port while attaching datacenter to tenant in --config")
4755 if self
.vcenter_user
is not None:
4756 vm_vcenter_info
["vm_vcenter_user"] = self
.vcenter_user
4758 raise vimconn
.vimconnException(message
="vCenter user is not provided."\
4759 " Please provide vCenter user while attaching datacenter to tenant in --config")
4761 if self
.vcenter_password
is not None:
4762 vm_vcenter_info
["vm_vcenter_password"] = self
.vcenter_password
4764 raise vimconn
.vimconnException(message
="vCenter user password is not provided."\
4765 " Please provide vCenter user password while attaching datacenter to tenant in --config")
4767 return vm_vcenter_info
4770 def get_vm_pci_details(self
, vmuuid
):
4772 Method to get VM PCI device details from vCenter
4775 vm_obj - vSphere VM object
4778 dict of PCI devives attached to VM
4781 vm_pci_devices_info
= {}
4783 vcenter_conect
, content
= self
.get_vcenter_content()
4784 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
4786 #Get VM and its host
4788 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4789 if host_obj
and vm_obj
:
4790 vm_pci_devices_info
["host_name"]= host_obj
.name
4791 vm_pci_devices_info
["host_ip"]= host_obj
.config
.network
.vnic
[0].spec
.ip
.ipAddress
4792 for device
in vm_obj
.config
.hardware
.device
:
4793 if type(device
) == vim
.vm
.device
.VirtualPCIPassthrough
:
4794 device_details
={'devide_id':device
.backing
.id,
4795 'pciSlotNumber':device
.slotInfo
.pciSlotNumber
,
4797 vm_pci_devices_info
[device
.deviceInfo
.label
] = device_details
4799 self
.logger
.error("Can not connect to vCenter while getting "\
4800 "PCI devices infromationn")
4801 return vm_pci_devices_info
4802 except Exception as exp
:
4803 self
.logger
.error("Error occurred while getting VM infromationn"\
4804 " for VM : {}".format(exp
))
4805 raise vimconn
.vimconnException(message
=exp
)
4808 def reserve_memory_for_all_vms(self
, vapp
, memory_mb
):
4810 Method to reserve memory for all VMs
4813 memory_mb - Memory in MB
4818 self
.logger
.info("Reserve memory for all VMs")
4819 for vms
in vapp
.get_all_vms():
4820 vm_id
= vms
.get('id').split(':')[-1]
4822 url_rest_call
= "{}/api/vApp/vm-{}/virtualHardwareSection/memory".format(self
.url
, vm_id
)
4824 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4825 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4826 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItem+xml'
4827 response
= self
.perform_request(req_type
='GET',
4831 if response
.status_code
== 403:
4832 response
= self
.retry_rest('GET', url_rest_call
)
4834 if response
.status_code
!= 200:
4835 self
.logger
.error("REST call {} failed reason : {}"\
4836 "status code : {}".format(url_rest_call
,
4838 response
.status_code
))
4839 raise vimconn
.vimconnException("reserve_memory_for_all_vms : Failed to get "\
4842 bytexml
= bytes(bytearray(response
.content
, encoding
='utf-8'))
4843 contentelem
= lxmlElementTree
.XML(bytexml
)
4844 namespaces
= {prefix
:uri
for prefix
,uri
in contentelem
.nsmap
.iteritems() if prefix
}
4845 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
4847 # Find the reservation element in the response
4848 memelem_list
= contentelem
.findall(".//rasd:Reservation", namespaces
)
4849 for memelem
in memelem_list
:
4850 memelem
.text
= str(memory_mb
)
4852 newdata
= lxmlElementTree
.tostring(contentelem
, pretty_print
=True)
4854 response
= self
.perform_request(req_type
='PUT',
4859 if response
.status_code
== 403:
4860 add_headers
= {'Content-Type': headers
['Content-Type']}
4861 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, newdata
)
4863 if response
.status_code
!= 202:
4864 self
.logger
.error("REST call {} failed reason : {}"\
4865 "status code : {} ".format(url_rest_call
,
4867 response
.status_code
))
4868 raise vimconn
.vimconnException("reserve_memory_for_all_vms : Failed to update "\
4869 "virtual hardware memory section")
4871 mem_task
= self
.get_task_from_response(response
.content
)
4872 result
= self
.client
.get_task_monitor().wait_for_success(task
=mem_task
)
4873 if result
.get('status') == 'success':
4874 self
.logger
.info("reserve_memory_for_all_vms(): VM {} succeeded "\
4877 self
.logger
.error("reserve_memory_for_all_vms(): VM {} failed "\
4880 def connect_vapp_to_org_vdc_network(self
, vapp_id
, net_name
):
4882 Configure VApp network config with org vdc network
4889 self
.logger
.info("Connecting vapp {} to org vdc network {}".
4890 format(vapp_id
, net_name
))
4892 url_rest_call
= "{}/api/vApp/vapp-{}/networkConfigSection/".format(self
.url
, vapp_id
)
4894 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4895 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4896 response
= self
.perform_request(req_type
='GET',
4900 if response
.status_code
== 403:
4901 response
= self
.retry_rest('GET', url_rest_call
)
4903 if response
.status_code
!= 200:
4904 self
.logger
.error("REST call {} failed reason : {}"\
4905 "status code : {}".format(url_rest_call
,
4907 response
.status_code
))
4908 raise vimconn
.vimconnException("connect_vapp_to_org_vdc_network : Failed to get "\
4909 "network config section")
4911 data
= response
.content
4912 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConfigSection+xml'
4913 net_id
= self
.get_network_id_by_name(net_name
)
4915 raise vimconn
.vimconnException("connect_vapp_to_org_vdc_network : Failed to find "\
4918 bytexml
= bytes(bytearray(data
, encoding
='utf-8'))
4919 newelem
= lxmlElementTree
.XML(bytexml
)
4920 namespaces
= {prefix
: uri
for prefix
, uri
in newelem
.nsmap
.iteritems() if prefix
}
4921 namespaces
["xmlns"] = "http://www.vmware.com/vcloud/v1.5"
4922 nwcfglist
= newelem
.findall(".//xmlns:NetworkConfig", namespaces
)
4924 newstr
= """<NetworkConfig networkName="{}">
4926 <ParentNetwork href="{}/api/network/{}"/>
4927 <FenceMode>bridged</FenceMode>
4930 """.format(net_name
, self
.url
, net_id
)
4931 newcfgelem
= lxmlElementTree
.fromstring(newstr
)
4933 nwcfglist
[0].addnext(newcfgelem
)
4935 newdata
= lxmlElementTree
.tostring(newelem
, pretty_print
=True)
4937 response
= self
.perform_request(req_type
='PUT',
4942 if response
.status_code
== 403:
4943 add_headers
= {'Content-Type': headers
['Content-Type']}
4944 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, newdata
)
4946 if response
.status_code
!= 202:
4947 self
.logger
.error("REST call {} failed reason : {}"\
4948 "status code : {} ".format(url_rest_call
,
4950 response
.status_code
))
4951 raise vimconn
.vimconnException("connect_vapp_to_org_vdc_network : Failed to update "\
4952 "network config section")
4954 vapp_task
= self
.get_task_from_response(response
.content
)
4955 result
= self
.client
.get_task_monitor().wait_for_success(task
=vapp_task
)
4956 if result
.get('status') == 'success':
4957 self
.logger
.info("connect_vapp_to_org_vdc_network(): Vapp {} connected to "\
4958 "network {}".format(vapp_id
, net_name
))
4960 self
.logger
.error("connect_vapp_to_org_vdc_network(): Vapp {} failed to "\
4961 "connect to network {}".format(vapp_id
, net_name
))
4963 def remove_primary_network_adapter_from_all_vms(self
, vapp
):
4965 Method to remove network adapter type to vm
4972 self
.logger
.info("Removing network adapter from all VMs")
4973 for vms
in vapp
.get_all_vms():
4974 vm_id
= vms
.get('id').split(':')[-1]
4976 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
4978 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
4979 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
4980 response
= self
.perform_request(req_type
='GET',
4984 if response
.status_code
== 403:
4985 response
= self
.retry_rest('GET', url_rest_call
)
4987 if response
.status_code
!= 200:
4988 self
.logger
.error("REST call {} failed reason : {}"\
4989 "status code : {}".format(url_rest_call
,
4991 response
.status_code
))
4992 raise vimconn
.vimconnException("remove_primary_network_adapter : Failed to get "\
4993 "network connection section")
4995 data
= response
.content
4996 data
= data
.split('<Link rel="edit"')[0]
4998 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
5000 newdata
= """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
5001 <NetworkConnectionSection xmlns="http://www.vmware.com/vcloud/v1.5"
5002 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
5003 xmlns:vssd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
5004 xmlns:common="http://schemas.dmtf.org/wbem/wscim/1/common"
5005 xmlns:rasd="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
5006 xmlns:vmw="http://www.vmware.com/schema/ovf"
5007 xmlns:ovfenv="http://schemas.dmtf.org/ovf/environment/1"
5008 xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5"
5009 xmlns:ns9="http://www.vmware.com/vcloud/versions"
5010 href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml" ovf:required="false">
5011 <ovf:Info>Specifies the available VM network connections</ovf:Info>
5012 <PrimaryNetworkConnectionIndex>0</PrimaryNetworkConnectionIndex>
5013 <Link rel="edit" href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml"/>
5014 </NetworkConnectionSection>""".format(url
=url_rest_call
)
5015 response
= self
.perform_request(req_type
='PUT',
5020 if response
.status_code
== 403:
5021 add_headers
= {'Content-Type': headers
['Content-Type']}
5022 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, newdata
)
5024 if response
.status_code
!= 202:
5025 self
.logger
.error("REST call {} failed reason : {}"\
5026 "status code : {} ".format(url_rest_call
,
5028 response
.status_code
))
5029 raise vimconn
.vimconnException("remove_primary_network_adapter : Failed to update "\
5030 "network connection section")
5032 nic_task
= self
.get_task_from_response(response
.content
)
5033 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
5034 if result
.get('status') == 'success':
5035 self
.logger
.info("remove_primary_network_adapter(): VM {} conneced to "\
5036 "default NIC type".format(vm_id
))
5038 self
.logger
.error("remove_primary_network_adapter(): VM {} failed to "\
5039 "connect NIC type".format(vm_id
))
5041 def add_network_adapter_to_vms(self
, vapp
, network_name
, primary_nic_index
, nicIndex
, net
, nic_type
=None):
5043 Method to add network adapter type to vm
5045 network_name - name of network
5046 primary_nic_index - int value for primary nic index
5047 nicIndex - int value for nic index
5048 nic_type - specify model name to which add to vm
5053 self
.logger
.info("Add network adapter to VM: network_name {} nicIndex {} nic_type {}".\
5054 format(network_name
, nicIndex
, nic_type
))
5059 if 'floating_ip' in net
: floating_ip
= net
['floating_ip']
5061 # Stub for ip_address feature
5062 if 'ip_address' in net
: ip_address
= net
['ip_address']
5064 if 'mac_address' in net
: mac_address
= net
['mac_address']
5067 allocation_mode
= "POOL"
5069 allocation_mode
= "MANUAL"
5071 allocation_mode
= "DHCP"
5074 for vms
in vapp
.get_all_vms():
5075 vm_id
= vms
.get('id').split(':')[-1]
5077 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
5079 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5080 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5081 response
= self
.perform_request(req_type
='GET',
5085 if response
.status_code
== 403:
5086 response
= self
.retry_rest('GET', url_rest_call
)
5088 if response
.status_code
!= 200:
5089 self
.logger
.error("REST call {} failed reason : {}"\
5090 "status code : {}".format(url_rest_call
,
5092 response
.status_code
))
5093 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
5094 "network connection section")
5096 data
= response
.content
5097 data
= data
.split('<Link rel="edit"')[0]
5098 if '<PrimaryNetworkConnectionIndex>' not in data
:
5099 self
.logger
.debug("add_network_adapter PrimaryNIC not in data")
5100 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
5101 <NetworkConnection network="{}">
5102 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
5103 <IsConnected>true</IsConnected>
5104 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
5105 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
5107 # Stub for ip_address feature
5109 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
5110 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
5113 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
5114 item
= item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
5116 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item
))
5118 self
.logger
.debug("add_network_adapter PrimaryNIC in data")
5119 new_item
= """<NetworkConnection network="{}">
5120 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
5121 <IsConnected>true</IsConnected>
5122 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
5123 </NetworkConnection>""".format(network_name
, nicIndex
,
5125 # Stub for ip_address feature
5127 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
5128 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
5131 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
5132 new_item
= new_item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
5134 data
= data
+ new_item
+ '</NetworkConnectionSection>'
5136 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
5138 response
= self
.perform_request(req_type
='PUT',
5143 if response
.status_code
== 403:
5144 add_headers
= {'Content-Type': headers
['Content-Type']}
5145 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
5147 if response
.status_code
!= 202:
5148 self
.logger
.error("REST call {} failed reason : {}"\
5149 "status code : {} ".format(url_rest_call
,
5151 response
.status_code
))
5152 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
5153 "network connection section")
5155 nic_task
= self
.get_task_from_response(response
.content
)
5156 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
5157 if result
.get('status') == 'success':
5158 self
.logger
.info("add_network_adapter_to_vms(): VM {} conneced to "\
5159 "default NIC type".format(vm_id
))
5161 self
.logger
.error("add_network_adapter_to_vms(): VM {} failed to "\
5162 "connect NIC type".format(vm_id
))
5164 for vms
in vapp
.get_all_vms():
5165 vm_id
= vms
.get('id').split(':')[-1]
5167 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.url
, vm_id
)
5169 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5170 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5171 response
= self
.perform_request(req_type
='GET',
5175 if response
.status_code
== 403:
5176 response
= self
.retry_rest('GET', url_rest_call
)
5178 if response
.status_code
!= 200:
5179 self
.logger
.error("REST call {} failed reason : {}"\
5180 "status code : {}".format(url_rest_call
,
5182 response
.status_code
))
5183 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
5184 "network connection section")
5185 data
= response
.content
5186 data
= data
.split('<Link rel="edit"')[0]
5187 vcd_netadapter_type
= nic_type
5188 if nic_type
in ['SR-IOV', 'VF']:
5189 vcd_netadapter_type
= "SRIOVETHERNETCARD"
5191 if '<PrimaryNetworkConnectionIndex>' not in data
:
5192 self
.logger
.debug("add_network_adapter PrimaryNIC not in data nic_type {}".format(nic_type
))
5193 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
5194 <NetworkConnection network="{}">
5195 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
5196 <IsConnected>true</IsConnected>
5197 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
5198 <NetworkAdapterType>{}</NetworkAdapterType>
5199 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
5200 allocation_mode
, vcd_netadapter_type
)
5201 # Stub for ip_address feature
5203 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
5204 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
5207 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
5208 item
= item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
5210 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item
))
5212 self
.logger
.debug("add_network_adapter PrimaryNIC in data nic_type {}".format(nic_type
))
5213 new_item
= """<NetworkConnection network="{}">
5214 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
5215 <IsConnected>true</IsConnected>
5216 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
5217 <NetworkAdapterType>{}</NetworkAdapterType>
5218 </NetworkConnection>""".format(network_name
, nicIndex
,
5219 allocation_mode
, vcd_netadapter_type
)
5220 # Stub for ip_address feature
5222 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
5223 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
5226 mac_tag
= '<MACAddress>{}</MACAddress>'.format(mac_address
)
5227 new_item
= new_item
.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag
))
5229 data
= data
+ new_item
+ '</NetworkConnectionSection>'
5231 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
5233 response
= self
.perform_request(req_type
='PUT',
5238 if response
.status_code
== 403:
5239 add_headers
= {'Content-Type': headers
['Content-Type']}
5240 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
5242 if response
.status_code
!= 202:
5243 self
.logger
.error("REST call {} failed reason : {}"\
5244 "status code : {}".format(url_rest_call
,
5246 response
.status_code
))
5247 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
5248 "network connection section")
5250 nic_task
= self
.get_task_from_response(response
.content
)
5251 result
= self
.client
.get_task_monitor().wait_for_success(task
=nic_task
)
5252 if result
.get('status') == 'success':
5253 self
.logger
.info("add_network_adapter_to_vms(): VM {} "\
5254 "conneced to NIC type {}".format(vm_id
, nic_type
))
5256 self
.logger
.error("add_network_adapter_to_vms(): VM {} "\
5257 "failed to connect NIC type {}".format(vm_id
, nic_type
))
5258 except Exception as exp
:
5259 self
.logger
.error("add_network_adapter_to_vms() : exception occurred "\
5260 "while adding Network adapter")
5261 raise vimconn
.vimconnException(message
=exp
)
5264 def set_numa_affinity(self
, vmuuid
, paired_threads_id
):
5266 Method to assign numa affinity in vm configuration parammeters
5269 paired_threads_id - one or more virtual processor
5275 vcenter_conect
, content
= self
.get_vcenter_content()
5276 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
5278 host_obj
, vm_obj
= self
.get_vm_obj(content
,vm_moref_id
)
5280 config_spec
= vim
.vm
.ConfigSpec()
5281 config_spec
.extraConfig
= []
5282 opt
= vim
.option
.OptionValue()
5283 opt
.key
= 'numa.nodeAffinity'
5284 opt
.value
= str(paired_threads_id
)
5285 config_spec
.extraConfig
.append(opt
)
5286 task
= vm_obj
.ReconfigVM_Task(config_spec
)
5288 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5289 extra_config
= vm_obj
.config
.extraConfig
5291 for opts
in extra_config
:
5292 if 'numa.nodeAffinity' in opts
.key
:
5294 self
.logger
.info("set_numa_affinity: Sucessfully assign numa affinity "\
5295 "value {} for vm {}".format(opt
.value
, vm_obj
))
5299 self
.logger
.error("set_numa_affinity: Failed to assign numa affinity")
5300 except Exception as exp
:
5301 self
.logger
.error("set_numa_affinity : exception occurred while setting numa affinity "\
5302 "for VM {} : {}".format(vm_obj
, vm_moref_id
))
5303 raise vimconn
.vimconnException("set_numa_affinity : Error {} failed to assign numa "\
5304 "affinity".format(exp
))
5307 def cloud_init(self
, vapp
, cloud_config
):
5309 Method to inject ssh-key
5311 cloud_config a dictionary with:
5312 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
5313 'users': (optional) list of users to be inserted, each item is a dict with:
5314 'name': (mandatory) user name,
5315 'key-pairs': (optional) list of strings with the public key to be inserted to the user
5316 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
5317 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
5318 'config-files': (optional). List of files to be transferred. Each item is a dict with:
5319 'dest': (mandatory) string with the destination absolute path
5320 'encoding': (optional, by default text). Can be one of:
5321 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
5322 'content' (mandatory): string with the content of the file
5323 'permissions': (optional) string with file permissions, typically octal notation '0644'
5324 'owner': (optional) file owner, string with the format 'owner:group'
5325 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk
5328 if not isinstance(cloud_config
, dict):
5329 raise Exception("cloud_init : parameter cloud_config is not a dictionary")
5333 if "key-pairs" in cloud_config
:
5334 key_pairs
= cloud_config
["key-pairs"]
5336 if "users" in cloud_config
:
5337 userdata
= cloud_config
["users"]
5339 self
.logger
.debug("cloud_init : Guest os customization started..")
5340 customize_script
= self
.format_script(key_pairs
=key_pairs
, users_list
=userdata
)
5341 customize_script
= customize_script
.replace("&","&")
5342 self
.guest_customization(vapp
, customize_script
)
5344 except Exception as exp
:
5345 self
.logger
.error("cloud_init : exception occurred while injecting "\
5347 raise vimconn
.vimconnException("cloud_init : Error {} failed to inject "\
5348 "ssh-key".format(exp
))
5350 def format_script(self
, key_pairs
=[], users_list
=[]):
5351 bash_script
= """#!/bin/sh
5352 echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
5353 if [ "$1" = "precustomization" ];then
5354 echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
5357 keys
= "\n".join(key_pairs
)
5360 if [ ! -d /root/.ssh ];then
5362 chown root:root /root/.ssh
5363 chmod 700 /root/.ssh
5364 touch /root/.ssh/authorized_keys
5365 chown root:root /root/.ssh/authorized_keys
5366 chmod 600 /root/.ssh/authorized_keys
5367 # make centos with selinux happy
5368 which restorecon && restorecon -Rv /root/.ssh
5370 touch /root/.ssh/authorized_keys
5371 chown root:root /root/.ssh/authorized_keys
5372 chmod 600 /root/.ssh/authorized_keys
5374 echo '{key}' >> /root/.ssh/authorized_keys
5375 """.format(key
=keys
)
5377 bash_script
+= keys_data
5379 for user
in users_list
:
5380 if 'name' in user
: user_name
= user
['name']
5381 if 'key-pairs' in user
:
5382 user_keys
= "\n".join(user
['key-pairs'])
5387 useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
5388 """.format(user_name
=user_name
)
5390 bash_script
+= add_user_name
5393 user_keys_data
= """
5394 mkdir /home/{user_name}/.ssh
5395 chown {user_name}:{user_name} /home/{user_name}/.ssh
5396 chmod 700 /home/{user_name}/.ssh
5397 touch /home/{user_name}/.ssh/authorized_keys
5398 chown {user_name}:{user_name} /home/{user_name}/.ssh/authorized_keys
5399 chmod 600 /home/{user_name}/.ssh/authorized_keys
5400 # make centos with selinux happy
5401 which restorecon && restorecon -Rv /home/{user_name}/.ssh
5402 echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
5403 """.format(user_name
=user_name
,user_key
=user_keys
)
5405 bash_script
+= user_keys_data
5407 return bash_script
+"\n\tfi"
5409 def guest_customization(self
, vapp
, customize_script
):
5411 Method to customize guest os
5413 customize_script - Customize script to be run at first boot of VM.
5415 for vm
in vapp
.get_all_vms():
5416 vm_id
= vm
.get('id').split(':')[-1]
5417 vm_name
= vm
.get('name')
5418 vm_name
= vm_name
.replace('_','-')
5420 vm_customization_url
= "{}/api/vApp/vm-{}/guestCustomizationSection/".format(self
.url
, vm_id
)
5421 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5422 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5424 headers
['Content-Type'] = "application/vnd.vmware.vcloud.guestCustomizationSection+xml"
5426 data
= """<GuestCustomizationSection
5427 xmlns="http://www.vmware.com/vcloud/v1.5"
5428 xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
5429 ovf:required="false" href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
5430 <ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
5431 <Enabled>true</Enabled>
5432 <ChangeSid>false</ChangeSid>
5433 <VirtualMachineId>{}</VirtualMachineId>
5434 <JoinDomainEnabled>false</JoinDomainEnabled>
5435 <UseOrgSettings>false</UseOrgSettings>
5436 <AdminPasswordEnabled>false</AdminPasswordEnabled>
5437 <AdminPasswordAuto>true</AdminPasswordAuto>
5438 <AdminAutoLogonEnabled>false</AdminAutoLogonEnabled>
5439 <AdminAutoLogonCount>0</AdminAutoLogonCount>
5440 <ResetPasswordRequired>false</ResetPasswordRequired>
5441 <CustomizationScript>{}</CustomizationScript>
5442 <ComputerName>{}</ComputerName>
5443 <Link href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml" rel="edit"/>
5444 </GuestCustomizationSection>
5445 """.format(vm_customization_url
,
5449 vm_customization_url
)
5451 response
= self
.perform_request(req_type
='PUT',
5452 url
=vm_customization_url
,
5455 if response
.status_code
== 202:
5456 guest_task
= self
.get_task_from_response(response
.content
)
5457 self
.client
.get_task_monitor().wait_for_success(task
=guest_task
)
5458 self
.logger
.info("guest_customization : customized guest os task "\
5459 "completed for VM {}".format(vm_name
))
5461 self
.logger
.error("guest_customization : task for customized guest os"\
5462 "failed for VM {}".format(vm_name
))
5463 raise vimconn
.vimconnException("guest_customization : failed to perform"\
5464 "guest os customization on VM {}".format(vm_name
))
5466 def add_new_disk(self
, vapp_uuid
, disk_size
):
5468 Method to create an empty vm disk
5471 vapp_uuid - is vapp identifier.
5472 disk_size - size of disk to be created in GB
5480 #Disk size in GB, convert it into MB
5481 if disk_size
is not None:
5482 disk_size_mb
= int(disk_size
) * 1024
5483 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
5485 if vm_details
and "vm_virtual_hardware" in vm_details
:
5486 self
.logger
.info("Adding disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
5487 disk_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
5488 status
= self
.add_new_disk_rest(disk_href
, disk_size_mb
)
5490 except Exception as exp
:
5491 msg
= "Error occurred while creating new disk {}.".format(exp
)
5492 self
.rollback_newvm(vapp_uuid
, msg
)
5495 self
.logger
.info("Added new disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
5497 #If failed to add disk, delete VM
5498 msg
= "add_new_disk: Failed to add new disk to {}".format(vm_details
["name"])
5499 self
.rollback_newvm(vapp_uuid
, msg
)
5502 def add_new_disk_rest(self
, disk_href
, disk_size_mb
):
5504 Retrives vApp Disks section & add new empty disk
5507 disk_href: Disk section href to addd disk
5508 disk_size_mb: Disk size in MB
5510 Returns: Status of add new disk task
5513 if self
.client
._session
:
5514 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5515 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
5516 response
= self
.perform_request(req_type
='GET',
5520 if response
.status_code
== 403:
5521 response
= self
.retry_rest('GET', disk_href
)
5523 if response
.status_code
!= requests
.codes
.ok
:
5524 self
.logger
.error("add_new_disk_rest: GET REST API call {} failed. Return status code {}"
5525 .format(disk_href
, response
.status_code
))
5528 #Find but type & max of instance IDs assigned to disks
5529 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
5530 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
5532 #namespaces = {prefix:uri for prefix,uri in lxmlroot_respond.nsmap.items() if prefix}
5533 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
5535 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
5536 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
5537 inst_id
= int(item
.find("rasd:InstanceID" ,namespaces
).text
)
5538 if inst_id
> instance_id
:
5539 instance_id
= inst_id
5540 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
5541 bus_subtype
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busSubType"]
5542 bus_type
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busType"]
5544 instance_id
= instance_id
+ 1
5545 new_item
= """<Item>
5546 <rasd:Description>Hard disk</rasd:Description>
5547 <rasd:ElementName>New disk</rasd:ElementName>
5549 xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
5550 vcloud:capacity="{}"
5551 vcloud:busSubType="{}"
5552 vcloud:busType="{}"></rasd:HostResource>
5553 <rasd:InstanceID>{}</rasd:InstanceID>
5554 <rasd:ResourceType>17</rasd:ResourceType>
5555 </Item>""".format(disk_size_mb
, bus_subtype
, bus_type
, instance_id
)
5557 new_data
= response
.content
5558 #Add new item at the bottom
5559 new_data
= new_data
.replace('</Item>\n</RasdItemsList>', '</Item>\n{}\n</RasdItemsList>'.format(new_item
))
5561 # Send PUT request to modify virtual hardware section with new disk
5562 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
5564 response
= self
.perform_request(req_type
='PUT',
5569 if response
.status_code
== 403:
5570 add_headers
= {'Content-Type': headers
['Content-Type']}
5571 response
= self
.retry_rest('PUT', disk_href
, add_headers
, new_data
)
5573 if response
.status_code
!= 202:
5574 self
.logger
.error("PUT REST API call {} failed. Return status code {}. Response Content:{}"
5575 .format(disk_href
, response
.status_code
, response
.content
))
5577 add_disk_task
= self
.get_task_from_response(response
.content
)
5578 result
= self
.client
.get_task_monitor().wait_for_success(task
=add_disk_task
)
5579 if result
.get('status') == 'success':
5582 self
.logger
.error("Add new disk REST task failed to add {} MB disk".format(disk_size_mb
))
5584 except Exception as exp
:
5585 self
.logger
.error("Error occurred calling rest api for creating new disk {}".format(exp
))
5590 def add_existing_disk(self
, catalogs
=None, image_id
=None, size
=None, template_name
=None, vapp_uuid
=None):
5592 Method to add existing disk to vm
5594 catalogs - List of VDC catalogs
5595 image_id - Catalog ID
5596 template_name - Name of template in catalog
5597 vapp_uuid - UUID of vApp
5602 vcenter_conect
, content
= self
.get_vcenter_content()
5603 #find moref-id of vm in image
5604 catalog_vm_info
= self
.get_vapp_template_details(catalogs
=catalogs
,
5608 if catalog_vm_info
and "vm_vcenter_info" in catalog_vm_info
:
5609 if "vm_moref_id" in catalog_vm_info
["vm_vcenter_info"]:
5610 catalog_vm_moref_id
= catalog_vm_info
["vm_vcenter_info"].get("vm_moref_id", None)
5611 if catalog_vm_moref_id
:
5612 self
.logger
.info("Moref_id of VM in catalog : {}" .format(catalog_vm_moref_id
))
5613 host
, catalog_vm_obj
= self
.get_vm_obj(content
, catalog_vm_moref_id
)
5616 disk_info
= self
.find_disk(catalog_vm_obj
)
5618 exp_msg
= "No VM with image id {} found".format(image_id
)
5619 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
5621 exp_msg
= "No Image found with image ID {} ".format(image_id
)
5622 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
5625 self
.logger
.info("Existing disk_info : {}".format(disk_info
))
5627 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
5628 host
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
5630 status
= self
.add_disk(vcenter_conect
=vcenter_conect
,
5632 disk_info
=disk_info
,
5637 self
.logger
.info("Disk from image id {} added to {}".format(image_id
,
5641 msg
= "No disk found with image id {} to add in VM {}".format(
5644 self
.rollback_newvm(vapp_uuid
, msg
, exp_type
="NotFound")
5647 def find_disk(self
, vm_obj
):
5649 Method to find details of existing disk in VM
5651 vm_obj - vCenter object of VM
5652 image_id - Catalog ID
5654 disk_info : dict of disk details
5659 devices
= vm_obj
.config
.hardware
.device
5660 for device
in devices
:
5661 if type(device
) is vim
.vm
.device
.VirtualDisk
:
5662 if isinstance(device
.backing
,vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo
) and hasattr(device
.backing
, 'fileName'):
5663 disk_info
["full_path"] = device
.backing
.fileName
5664 disk_info
["datastore"] = device
.backing
.datastore
5665 disk_info
["capacityKB"] = device
.capacityInKB
5667 except Exception as exp
:
5668 self
.logger
.error("find_disk() : exception occurred while "\
5669 "getting existing disk details :{}".format(exp
))
5673 def add_disk(self
, vcenter_conect
=None, vm
=None, size
=None, vapp_uuid
=None, disk_info
={}):
5675 Method to add existing disk in VM
5677 vcenter_conect - vCenter content object
5678 vm - vCenter vm object
5679 disk_info : dict of disk details
5681 status : status of add disk task
5683 datastore
= disk_info
["datastore"] if "datastore" in disk_info
else None
5684 fullpath
= disk_info
["full_path"] if "full_path" in disk_info
else None
5685 capacityKB
= disk_info
["capacityKB"] if "capacityKB" in disk_info
else None
5686 if size
is not None:
5687 #Convert size from GB to KB
5688 sizeKB
= int(size
) * 1024 * 1024
5689 #compare size of existing disk and user given size.Assign whicherver is greater
5690 self
.logger
.info("Add Existing disk : sizeKB {} , capacityKB {}".format(
5691 sizeKB
, capacityKB
))
5692 if sizeKB
> capacityKB
:
5695 if datastore
and fullpath
and capacityKB
:
5697 spec
= vim
.vm
.ConfigSpec()
5698 # get all disks on a VM, set unit_number to the next available
5700 for dev
in vm
.config
.hardware
.device
:
5701 if hasattr(dev
.backing
, 'fileName'):
5702 unit_number
= int(dev
.unitNumber
) + 1
5703 # unit_number 7 reserved for scsi controller
5704 if unit_number
== 7:
5706 if isinstance(dev
, vim
.vm
.device
.VirtualDisk
):
5707 #vim.vm.device.VirtualSCSIController
5708 controller_key
= dev
.controllerKey
5710 self
.logger
.info("Add Existing disk : unit number {} , controller key {}".format(
5711 unit_number
, controller_key
))
5714 disk_spec
= vim
.vm
.device
.VirtualDeviceSpec()
5715 disk_spec
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
5716 disk_spec
.device
= vim
.vm
.device
.VirtualDisk()
5717 disk_spec
.device
.backing
= \
5718 vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo()
5719 disk_spec
.device
.backing
.thinProvisioned
= True
5720 disk_spec
.device
.backing
.diskMode
= 'persistent'
5721 disk_spec
.device
.backing
.datastore
= datastore
5722 disk_spec
.device
.backing
.fileName
= fullpath
5724 disk_spec
.device
.unitNumber
= unit_number
5725 disk_spec
.device
.capacityInKB
= capacityKB
5726 disk_spec
.device
.controllerKey
= controller_key
5727 dev_changes
.append(disk_spec
)
5728 spec
.deviceChange
= dev_changes
5729 task
= vm
.ReconfigVM_Task(spec
=spec
)
5730 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5732 except Exception as exp
:
5733 exp_msg
= "add_disk() : exception {} occurred while adding disk "\
5734 "{} to vm {}".format(exp
,
5737 self
.rollback_newvm(vapp_uuid
, exp_msg
)
5739 msg
= "add_disk() : Can not add disk to VM with disk info {} ".format(disk_info
)
5740 self
.rollback_newvm(vapp_uuid
, msg
)
5743 def get_vcenter_content(self
):
5745 Get the vsphere content object
5748 vm_vcenter_info
= self
.get_vm_vcenter_info()
5749 except Exception as exp
:
5750 self
.logger
.error("Error occurred while getting vCenter infromationn"\
5751 " for VM : {}".format(exp
))
5752 raise vimconn
.vimconnException(message
=exp
)
5755 if hasattr(ssl
, '_create_unverified_context'):
5756 context
= ssl
._create
_unverified
_context
()
5758 vcenter_conect
= SmartConnect(
5759 host
=vm_vcenter_info
["vm_vcenter_ip"],
5760 user
=vm_vcenter_info
["vm_vcenter_user"],
5761 pwd
=vm_vcenter_info
["vm_vcenter_password"],
5762 port
=int(vm_vcenter_info
["vm_vcenter_port"]),
5765 atexit
.register(Disconnect
, vcenter_conect
)
5766 content
= vcenter_conect
.RetrieveContent()
5767 return vcenter_conect
, content
5770 def get_vm_moref_id(self
, vapp_uuid
):
5772 Get the moref_id of given VM
5776 vm_details
= self
.get_vapp_details_rest(vapp_uuid
, need_admin_access
=True)
5777 if vm_details
and "vm_vcenter_info" in vm_details
:
5778 vm_moref_id
= vm_details
["vm_vcenter_info"].get("vm_moref_id", None)
5781 except Exception as exp
:
5782 self
.logger
.error("Error occurred while getting VM moref ID "\
5783 " for VM : {}".format(exp
))
5787 def get_vapp_template_details(self
, catalogs
=None, image_id
=None , template_name
=None):
5789 Method to get vApp template details
5791 catalogs - list of VDC catalogs
5792 image_id - Catalog ID to find
5793 template_name : template name in catalog
5795 parsed_respond : dict of vApp tempalte details
5797 parsed_response
= {}
5799 vca
= self
.connect_as_admin()
5801 raise vimconn
.vimconnConnectionException("Failed to connect vCD")
5804 org
, vdc
= self
.get_vdc_details()
5805 catalog
= self
.get_catalog_obj(image_id
, catalogs
)
5807 items
= org
.get_catalog_item(catalog
.get('name'), catalog
.get('name'))
5808 catalog_items
= [items
.attrib
]
5810 if len(catalog_items
) == 1:
5811 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
5812 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
5814 response
= self
.perform_request(req_type
='GET',
5815 url
=catalog_items
[0].get('href'),
5817 catalogItem
= XmlElementTree
.fromstring(response
.content
)
5818 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
5819 vapp_tempalte_href
= entity
.get("href")
5820 #get vapp details and parse moref id
5822 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
5823 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
5824 'vmw': 'http://www.vmware.com/schema/ovf',
5825 'vm': 'http://www.vmware.com/vcloud/v1.5',
5826 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
5827 'vmext':"http://www.vmware.com/vcloud/extension/v1.5",
5828 'xmlns':"http://www.vmware.com/vcloud/v1.5"
5832 response
= self
.perform_request(req_type
='GET',
5833 url
=vapp_tempalte_href
,
5836 if response
.status_code
!= requests
.codes
.ok
:
5837 self
.logger
.debug("REST API call {} failed. Return status code {}".format(
5838 vapp_tempalte_href
, response
.status_code
))
5841 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
5842 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
5843 if children_section
is not None:
5844 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
5845 if vCloud_extension_section
is not None:
5846 vm_vcenter_info
= {}
5847 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
5848 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
5849 if vmext
is not None:
5850 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
5851 parsed_response
["vm_vcenter_info"]= vm_vcenter_info
5853 except Exception as exp
:
5854 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
5856 return parsed_response
5859 def rollback_newvm(self
, vapp_uuid
, msg
, exp_type
="Genric"):
5861 Method to delete vApp
5863 vapp_uuid - vApp UUID
5864 msg - Error message to be logged
5865 exp_type : Exception type
5870 status
= self
.delete_vminstance(vapp_uuid
)
5873 self
.logger
.error(msg
)
5874 if exp_type
== "Genric":
5875 raise vimconn
.vimconnException(msg
)
5876 elif exp_type
== "NotFound":
5877 raise vimconn
.vimconnNotFoundException(message
=msg
)
5879 def add_sriov(self
, vapp_uuid
, sriov_nets
, vmname_andid
):
5881 Method to attach SRIOV adapters to VM
5884 vapp_uuid - uuid of vApp/VM
5885 sriov_nets - SRIOV devices infromation as specified in VNFD (flavor)
5886 vmname_andid - vmname
5889 The status of add SRIOV adapter task , vm object and
5890 vcenter_conect object
5893 vcenter_conect
, content
= self
.get_vcenter_content()
5894 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
5898 no_of_sriov_devices
= len(sriov_nets
)
5899 if no_of_sriov_devices
> 0:
5900 #Get VM and its host
5901 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
5902 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
5903 if host_obj
and vm_obj
:
5904 #get SRIOV devies from host on which vapp is currently installed
5905 avilable_sriov_devices
= self
.get_sriov_devices(host_obj
,
5906 no_of_sriov_devices
,
5909 if len(avilable_sriov_devices
) == 0:
5910 #find other hosts with active pci devices
5911 new_host_obj
, avilable_sriov_devices
= self
.get_host_and_sriov_devices(
5913 no_of_sriov_devices
,
5916 if new_host_obj
is not None and len(avilable_sriov_devices
)> 0:
5917 #Migrate vm to the host where SRIOV devices are available
5918 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
,
5920 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
5921 if task
is not None:
5922 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5923 self
.logger
.info("Migrate VM status: {}".format(result
))
5924 host_obj
= new_host_obj
5926 self
.logger
.info("Fail to migrate VM : {}".format(result
))
5927 raise vimconn
.vimconnNotFoundException(
5928 "Fail to migrate VM : {} to host {}".format(
5933 if host_obj
is not None and avilable_sriov_devices
is not None and len(avilable_sriov_devices
)> 0:
5934 #Add SRIOV devices one by one
5935 for sriov_net
in sriov_nets
:
5936 network_name
= sriov_net
.get('net_id')
5937 dvs_portgr_name
= self
.create_dvPort_group(network_name
)
5938 if sriov_net
.get('type') == "VF" or sriov_net
.get('type') == "SR-IOV":
5939 #add vlan ID ,Modify portgroup for vlan ID
5940 self
.configure_vlanID(content
, vcenter_conect
, network_name
)
5942 task
= self
.add_sriov_to_vm(content
,
5946 avilable_sriov_devices
[0]
5949 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
5951 self
.logger
.info("Added SRIOV {} to VM {}".format(
5952 no_of_sriov_devices
,
5955 self
.logger
.error("Fail to add SRIOV {} to VM {}".format(
5956 no_of_sriov_devices
,
5958 raise vimconn
.vimconnUnexpectedResponse(
5959 "Fail to add SRIOV adapter in VM ".format(str(vm_obj
))
5961 return True, vm_obj
, vcenter_conect
5963 self
.logger
.error("Currently there is no host with"\
5964 " {} number of avaialble SRIOV "\
5965 "VFs required for VM {}".format(
5966 no_of_sriov_devices
,
5969 raise vimconn
.vimconnNotFoundException(
5970 "Currently there is no host with {} "\
5971 "number of avaialble SRIOV devices required for VM {}".format(
5972 no_of_sriov_devices
,
5975 self
.logger
.debug("No infromation about SRIOV devices {} ",sriov_nets
)
5977 except vmodl
.MethodFault
as error
:
5978 self
.logger
.error("Error occurred while adding SRIOV {} ",error
)
5979 return None, vm_obj
, vcenter_conect
5982 def get_sriov_devices(self
,host
, no_of_vfs
):
5984 Method to get the details of SRIOV devices on given host
5986 host - vSphere host object
5987 no_of_vfs - number of VFs needed on host
5990 array of SRIOV devices
5994 for device
in host
.config
.pciPassthruInfo
:
5995 if isinstance(device
,vim
.host
.SriovInfo
) and device
.sriovActive
:
5996 if device
.numVirtualFunction
>= no_of_vfs
:
5997 sriovInfo
.append(device
)
6002 def get_host_and_sriov_devices(self
, content
, no_of_vfs
):
6004 Method to get the details of SRIOV devices infromation on all hosts
6007 content - vSphere host object
6008 no_of_vfs - number of pci VFs needed on host
6011 array of SRIOV devices and host object
6014 sriov_device_objs
= None
6017 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
6018 [vim
.HostSystem
], True)
6019 for host
in container
.view
:
6020 devices
= self
.get_sriov_devices(host
, no_of_vfs
)
6023 sriov_device_objs
= devices
6025 except Exception as exp
:
6026 self
.logger
.error("Error {} occurred while finding SRIOV devices on host: {}".format(exp
, host_obj
))
6028 return host_obj
,sriov_device_objs
6031 def add_sriov_to_vm(self
,content
, vm_obj
, host_obj
, network_name
, sriov_device
):
6033 Method to add SRIOV adapter to vm
6036 host_obj - vSphere host object
6037 vm_obj - vSphere vm object
6038 content - vCenter content object
6039 network_name - name of distributed virtaul portgroup
6040 sriov_device - SRIOV device info
6046 vnic_label
= "sriov nic"
6048 dvs_portgr
= self
.get_dvport_group(network_name
)
6049 network_name
= dvs_portgr
.name
6050 nic
= vim
.vm
.device
.VirtualDeviceSpec()
6052 nic
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
6053 nic
.device
= vim
.vm
.device
.VirtualSriovEthernetCard()
6054 nic
.device
.addressType
= 'assigned'
6055 #nic.device.key = 13016
6056 nic
.device
.deviceInfo
= vim
.Description()
6057 nic
.device
.deviceInfo
.label
= vnic_label
6058 nic
.device
.deviceInfo
.summary
= network_name
6059 nic
.device
.backing
= vim
.vm
.device
.VirtualEthernetCard
.NetworkBackingInfo()
6061 nic
.device
.backing
.network
= self
.get_obj(content
, [vim
.Network
], network_name
)
6062 nic
.device
.backing
.deviceName
= network_name
6063 nic
.device
.backing
.useAutoDetect
= False
6064 nic
.device
.connectable
= vim
.vm
.device
.VirtualDevice
.ConnectInfo()
6065 nic
.device
.connectable
.startConnected
= True
6066 nic
.device
.connectable
.allowGuestControl
= True
6068 nic
.device
.sriovBacking
= vim
.vm
.device
.VirtualSriovEthernetCard
.SriovBackingInfo()
6069 nic
.device
.sriovBacking
.physicalFunctionBacking
= vim
.vm
.device
.VirtualPCIPassthrough
.DeviceBackingInfo()
6070 nic
.device
.sriovBacking
.physicalFunctionBacking
.id = sriov_device
.id
6073 vmconf
= vim
.vm
.ConfigSpec(deviceChange
=devices
)
6074 task
= vm_obj
.ReconfigVM_Task(vmconf
)
6076 except Exception as exp
:
6077 self
.logger
.error("Error {} occurred while adding SRIOV adapter in VM: {}".format(exp
, vm_obj
))
6081 def create_dvPort_group(self
, network_name
):
6083 Method to create disributed virtual portgroup
6086 network_name - name of network/portgroup
6092 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
6093 network_name
=''.join(new_network_name
)
6094 vcenter_conect
, content
= self
.get_vcenter_content()
6096 dv_switch
= self
.get_obj(content
, [vim
.DistributedVirtualSwitch
], self
.dvs_name
)
6098 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
6099 dv_pg_spec
.name
= network_name
6101 dv_pg_spec
.type = vim
.dvs
.DistributedVirtualPortgroup
.PortgroupType
.earlyBinding
6102 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
6103 dv_pg_spec
.defaultPortConfig
.securityPolicy
= vim
.dvs
.VmwareDistributedVirtualSwitch
.SecurityPolicy()
6104 dv_pg_spec
.defaultPortConfig
.securityPolicy
.allowPromiscuous
= vim
.BoolPolicy(value
=False)
6105 dv_pg_spec
.defaultPortConfig
.securityPolicy
.forgedTransmits
= vim
.BoolPolicy(value
=False)
6106 dv_pg_spec
.defaultPortConfig
.securityPolicy
.macChanges
= vim
.BoolPolicy(value
=False)
6108 task
= dv_switch
.AddDVPortgroup_Task([dv_pg_spec
])
6109 self
.wait_for_vcenter_task(task
, vcenter_conect
)
6111 dvPort_group
= self
.get_obj(content
, [vim
.dvs
.DistributedVirtualPortgroup
], network_name
)
6113 self
.logger
.info("Created disributed virtaul port group: {}".format(dvPort_group
))
6114 return dvPort_group
.key
6116 self
.logger
.debug("No disributed virtual switch found with name {}".format(network_name
))
6118 except Exception as exp
:
6119 self
.logger
.error("Error occurred while creating disributed virtaul port group {}"\
6120 " : {}".format(network_name
, exp
))
6123 def reconfig_portgroup(self
, content
, dvPort_group_name
, config_info
={}):
6125 Method to reconfigure disributed virtual portgroup
6128 dvPort_group_name - name of disributed virtual portgroup
6129 content - vCenter content object
6130 config_info - disributed virtual portgroup configuration
6136 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
6138 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
6139 dv_pg_spec
.configVersion
= dvPort_group
.config
.configVersion
6140 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
6141 if "vlanID" in config_info
:
6142 dv_pg_spec
.defaultPortConfig
.vlan
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VlanIdSpec()
6143 dv_pg_spec
.defaultPortConfig
.vlan
.vlanId
= config_info
.get('vlanID')
6145 task
= dvPort_group
.ReconfigureDVPortgroup_Task(spec
=dv_pg_spec
)
6149 except Exception as exp
:
6150 self
.logger
.error("Error occurred while reconfiguraing disributed virtaul port group {}"\
6151 " : {}".format(dvPort_group_name
, exp
))
6155 def destroy_dvport_group(self
, dvPort_group_name
):
6157 Method to destroy disributed virtual portgroup
6160 network_name - name of network/portgroup
6163 True if portgroup successfully got deleted else false
6165 vcenter_conect
, content
= self
.get_vcenter_content()
6168 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
6170 task
= dvPort_group
.Destroy_Task()
6171 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
6173 except vmodl
.MethodFault
as exp
:
6174 self
.logger
.error("Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
6175 exp
, dvPort_group_name
))
6179 def get_dvport_group(self
, dvPort_group_name
):
6181 Method to get disributed virtual portgroup
6184 network_name - name of network/portgroup
6189 vcenter_conect
, content
= self
.get_vcenter_content()
6192 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, [vim
.dvs
.DistributedVirtualPortgroup
], True)
6193 for item
in container
.view
:
6194 if item
.key
== dvPort_group_name
:
6198 except vmodl
.MethodFault
as exp
:
6199 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
6200 exp
, dvPort_group_name
))
6203 def get_vlanID_from_dvs_portgr(self
, dvPort_group_name
):
6205 Method to get disributed virtual portgroup vlanID
6208 network_name - name of network/portgroup
6215 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
6217 vlanId
= dvPort_group
.config
.defaultPortConfig
.vlan
.vlanId
6218 except vmodl
.MethodFault
as exp
:
6219 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
6220 exp
, dvPort_group_name
))
6224 def configure_vlanID(self
, content
, vcenter_conect
, dvPort_group_name
):
6226 Method to configure vlanID in disributed virtual portgroup vlanID
6229 network_name - name of network/portgroup
6234 vlanID
= self
.get_vlanID_from_dvs_portgr(dvPort_group_name
)
6237 vlanID
= self
.genrate_vlanID(dvPort_group_name
)
6238 config
= {"vlanID":vlanID
}
6239 task
= self
.reconfig_portgroup(content
, dvPort_group_name
,
6242 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
6244 self
.logger
.info("Reconfigured Port group {} for vlan ID {}".format(
6245 dvPort_group_name
,vlanID
))
6247 self
.logger
.error("Fail reconfigure portgroup {} for vlanID{}".format(
6248 dvPort_group_name
, vlanID
))
6251 def genrate_vlanID(self
, network_name
):
6253 Method to get unused vlanID
6255 network_name - name of network/portgroup
6261 if self
.config
.get('vlanID_range') == None:
6262 raise vimconn
.vimconnConflictException("You must provide a 'vlanID_range' "\
6263 "at config value before creating sriov network with vlan tag")
6264 if "used_vlanIDs" not in self
.persistent_info
:
6265 self
.persistent_info
["used_vlanIDs"] = {}
6267 used_ids
= self
.persistent_info
["used_vlanIDs"].values()
6269 #used_ids = list(self.persistent_info["used_vlanIDs"].values())
6271 for vlanID_range
in self
.config
.get('vlanID_range'):
6272 start_vlanid
, end_vlanid
= vlanID_range
.split("-")
6273 if start_vlanid
> end_vlanid
:
6274 raise vimconn
.vimconnConflictException("Invalid vlan ID range {}".format(
6277 for id in xrange(int(start_vlanid
), int(end_vlanid
) + 1):
6279 #for id in range(int(start_vlanid), int(end_vlanid) + 1):
6280 if id not in used_ids
:
6282 self
.persistent_info
["used_vlanIDs"][network_name
] = vlan_id
6285 raise vimconn
.vimconnConflictException("All Vlan IDs are in use")
6288 def get_obj(self
, content
, vimtype
, name
):
6290 Get the vsphere object associated with a given text name
6293 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, vimtype
, True)
6294 for item
in container
.view
:
6295 if item
.name
== name
:
6301 def insert_media_to_vm(self
, vapp
, image_id
):
6303 Method to insert media CD-ROM (ISO image) from catalog to vm.
6304 vapp - vapp object to get vm id
6305 Image_id - image id for cdrom to be inerted to vm
6307 # create connection object
6308 vca
= self
.connect()
6310 # fetching catalog details
6311 rest_url
= "{}/api/catalog/{}".format(self
.url
, image_id
)
6313 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6314 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
6315 response
= self
.perform_request(req_type
='GET',
6319 if response
.status_code
!= 200:
6320 self
.logger
.error("REST call {} failed reason : {}"\
6321 "status code : {}".format(url_rest_call
,
6323 response
.status_code
))
6324 raise vimconn
.vimconnException("insert_media_to_vm(): Failed to get "\
6326 # searching iso name and id
6327 iso_name
,media_id
= self
.get_media_details(vca
, response
.content
)
6329 if iso_name
and media_id
:
6330 data
="""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
6331 <ns6:MediaInsertOrEjectParams
6332 xmlns="http://www.vmware.com/vcloud/versions" xmlns:ns2="http://schemas.dmtf.org/ovf/envelope/1"
6333 xmlns:ns3="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
6334 xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/common"
6335 xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
6336 xmlns:ns6="http://www.vmware.com/vcloud/v1.5"
6337 xmlns:ns7="http://www.vmware.com/schema/ovf"
6338 xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1"
6339 xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">
6341 type="application/vnd.vmware.vcloud.media+xml"
6343 id="urn:vcloud:media:{}"
6344 href="https://{}/api/media/{}"/>
6345 </ns6:MediaInsertOrEjectParams>""".format(iso_name
, media_id
,
6348 for vms
in vapp
.get_all_vms():
6349 vm_id
= vms
.get('id').split(':')[-1]
6351 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.mediaInsertOrEjectParams+xml'
6352 rest_url
= "{}/api/vApp/vm-{}/media/action/insertMedia".format(self
.url
,vm_id
)
6354 response
= self
.perform_request(req_type
='POST',
6359 if response
.status_code
!= 202:
6360 error_msg
= "insert_media_to_vm() : Failed to insert CD-ROM to vm. Reason {}. " \
6361 "Status code {}".format(response
.text
, response
.status_code
)
6362 self
.logger
.error(error_msg
)
6363 raise vimconn
.vimconnException(error_msg
)
6365 task
= self
.get_task_from_response(response
.content
)
6366 result
= self
.client
.get_task_monitor().wait_for_success(task
=task
)
6367 if result
.get('status') == 'success':
6368 self
.logger
.info("insert_media_to_vm(): Sucessfully inserted media ISO"\
6369 " image to vm {}".format(vm_id
))
6371 except Exception as exp
:
6372 self
.logger
.error("insert_media_to_vm() : exception occurred "\
6373 "while inserting media CD-ROM")
6374 raise vimconn
.vimconnException(message
=exp
)
6377 def get_media_details(self
, vca
, content
):
6379 Method to get catalog item details
6380 vca - connection object
6381 content - Catalog details
6382 Return - Media name, media id
6384 cataloghref_list
= []
6387 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
6388 for child
in vm_list_xmlroot
.iter():
6389 if 'CatalogItem' in child
.tag
:
6390 cataloghref_list
.append(child
.attrib
.get('href'))
6391 if cataloghref_list
is not None:
6392 for href
in cataloghref_list
:
6394 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6395 'x-vcloud-authorization': vca
._session
.headers
['x-vcloud-authorization']}
6396 response
= self
.perform_request(req_type
='GET',
6399 if response
.status_code
!= 200:
6400 self
.logger
.error("REST call {} failed reason : {}"\
6401 "status code : {}".format(href
,
6403 response
.status_code
))
6404 raise vimconn
.vimconnException("get_media_details : Failed to get "\
6405 "catalogitem details")
6406 list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
6407 for child
in list_xmlroot
.iter():
6408 if 'Entity' in child
.tag
:
6409 if 'media' in child
.attrib
.get('href'):
6410 name
= child
.attrib
.get('name')
6411 media_id
= child
.attrib
.get('href').split('/').pop()
6412 return name
,media_id
6414 self
.logger
.debug("Media name and id not found")
6416 except Exception as exp
:
6417 self
.logger
.error("get_media_details : exception occurred "\
6418 "getting media details")
6419 raise vimconn
.vimconnException(message
=exp
)
6422 def retry_rest(self
, method
, url
, add_headers
=None, data
=None):
6423 """ Method to get Token & retry respective REST request
6425 api - REST API - Can be one of 'GET' or 'PUT' or 'POST'
6426 url - request url to be used
6427 add_headers - Additional headers (optional)
6428 data - Request payload data to be passed in request
6430 response - Response of request
6437 if self
.client
._session
:
6438 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6439 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
6442 headers
.update(add_headers
)
6445 response
= self
.perform_request(req_type
='GET',
6448 elif method
== 'PUT':
6449 response
= self
.perform_request(req_type
='PUT',
6453 elif method
== 'POST':
6454 response
= self
.perform_request(req_type
='POST',
6458 elif method
== 'DELETE':
6459 response
= self
.perform_request(req_type
='DELETE',
6465 def get_token(self
):
6466 """ Generate a new token if expired
6469 The return client object that letter can be used to connect to vCloud director as admin for VDC
6472 self
.logger
.debug("Generate token for vca {} as {} to datacenter {}.".format(self
.org_name
,
6476 client
= Client(host
, verify_ssl_certs
=False)
6477 client
.set_credentials(BasicLoginCredentials(self
.user
, self
.org_name
, self
.passwd
))
6479 self
.client
= client
6482 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
6483 "{} as user: {}".format(self
.org_name
, self
.user
))
6486 raise vimconn
.vimconnConnectionException("Failed while reconnecting vCD")
6489 def get_vdc_details(self
):
6490 """ Get VDC details using pyVcloud Lib
6492 Returns org and vdc object
6496 org
= Org(self
.client
, resource
=self
.client
.get_org())
6497 vdc
= org
.get_vdc(self
.tenant_name
)
6498 except Exception as e
:
6499 # pyvcloud not giving a specific exception, Refresh nevertheless
6500 self
.logger
.debug("Received exception {}, refreshing token ".format(str(e
)))
6502 #Retry once, if failed by refreshing token
6505 org
= Org(self
.client
, resource
=self
.client
.get_org())
6506 vdc
= org
.get_vdc(self
.tenant_name
)
6511 def perform_request(self
, req_type
, url
, headers
=None, data
=None):
6512 """Perform the POST/PUT/GET/DELETE request."""
6514 #Log REST request details
6515 self
.log_request(req_type
, url
=url
, headers
=headers
, data
=data
)
6516 # perform request and return its result
6517 if req_type
== 'GET':
6518 response
= requests
.get(url
=url
,
6521 elif req_type
== 'PUT':
6522 response
= requests
.put(url
=url
,
6526 elif req_type
== 'POST':
6527 response
= requests
.post(url
=url
,
6531 elif req_type
== 'DELETE':
6532 response
= requests
.delete(url
=url
,
6535 #Log the REST response
6536 self
.log_response(response
)
6541 def log_request(self
, req_type
, url
=None, headers
=None, data
=None):
6542 """Logs REST request details"""
6544 if req_type
is not None:
6545 self
.logger
.debug("Request type: {}".format(req_type
))
6548 self
.logger
.debug("Request url: {}".format(url
))
6550 if headers
is not None:
6551 for header
in headers
:
6552 self
.logger
.debug("Request header: {}: {}".format(header
, headers
[header
]))
6554 if data
is not None:
6555 self
.logger
.debug("Request data: {}".format(data
))
6558 def log_response(self
, response
):
6559 """Logs REST response details"""
6561 self
.logger
.debug("Response status code: {} ".format(response
.status_code
))
6564 def get_task_from_response(self
, content
):
6566 content - API response content(response.content)
6569 xmlroot
= XmlElementTree
.fromstring(content
)
6570 if xmlroot
.tag
.split('}')[1] == "Task":
6574 if ele
.tag
.split("}")[1] == "Tasks":
6580 def power_on_vapp(self
,vapp_id
, vapp_name
):
6583 vapp_name - vAapp name
6584 return - Task object
6586 headers
= {'Accept':'application/*+xml;version=' + API_VERSION
,
6587 'x-vcloud-authorization': self
.client
._session
.headers
['x-vcloud-authorization']}
6589 poweron_href
= "{}/api/vApp/vapp-{}/power/action/powerOn".format(self
.url
,
6591 response
= self
.perform_request(req_type
='POST',
6595 if response
.status_code
!= 202:
6596 self
.logger
.error("REST call {} failed reason : {}"\
6597 "status code : {} ".format(poweron_href
,
6599 response
.status_code
))
6600 raise vimconn
.vimconnException("power_on_vapp() : Failed to power on "\
6601 "vApp {}".format(vapp_name
))
6603 poweron_task
= self
.get_task_from_response(response
.content
)