1 # -*- coding: utf-8 -*-
4 # Copyright 2016-2017 VMware Inc.
5 # This file is part of ETSI OSM
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
20 # For those usages not covered by the Apache License, Version 2.0 please
21 # contact: osslegalrouting@vmware.com
25 vimconn_vmware implementation an Abstract class in order to interact with VMware vCloud Director.
28 from progressbar
import Percentage
, Bar
, ETA
, FileTransferSpeed
, ProgressBar
38 from pyVmomi
import vim
, vmodl
39 from pyVim
.connect
import SmartConnect
, Disconnect
41 from xml
.etree
import ElementTree
as XmlElementTree
42 from lxml
import etree
as lxmlElementTree
45 from pyvcloud
import Http
46 from pyvcloud
.vcloudair
import VCA
47 from pyvcloud
.schema
.vcd
.v1_5
.schemas
.vcloud
import sessionType
, organizationType
, \
48 vAppType
, organizationListType
, vdcType
, catalogType
, queryRecordViewType
, \
49 networkType
, vcloudType
, taskType
, diskType
, vmsType
, vdcTemplateListType
, mediaType
50 from xml
.sax
.saxutils
import escape
52 from pyvcloud
.schema
.vcd
.v1_5
.schemas
.admin
.vCloudEntities
import TaskType
53 from pyvcloud
.schema
.vcd
.v1_5
.schemas
.vcloud
.taskType
import TaskType
as GenericTask
54 from pyvcloud
.schema
.vcd
.v1_5
.schemas
.vcloud
.vAppType
import TaskType
as VappTask
55 from pyvcloud
.schema
.vcd
.v1_5
.schemas
.admin
.vCloudEntities
import TasksInProgressType
68 # global variable for vcd connector type
69 STANDALONE
= 'standalone'
71 # key for flavor dicts
72 FLAVOR_RAM_KEY
= 'ram'
73 FLAVOR_VCPUS_KEY
= 'vcpus'
74 FLAVOR_DISK_KEY
= 'disk'
75 DEFAULT_IP_PROFILE
= {'dhcp_count':50,
79 # global variable for wait time
85 __author__
= "Mustafa Bayramov, Arpita Kate, Sachin Bhangare"
86 __date__
= "$12-Jan-2017 11:09:29$"
89 # -1: "Could not be created",
95 # 5: "Waiting for user input",
97 # 7: "Unrecognized state",
99 # 9: "Inconsistent state",
100 # 10: "Children do not all have the same status",
101 # 11: "Upload initiated, OVF descriptor pending",
102 # 12: "Upload initiated, copying contents",
103 # 13: "Upload initiated , disk contents pending",
104 # 14: "Upload has been quarantined",
105 # 15: "Upload quarantine period has expired"
107 # mapping vCD status to MANO
108 vcdStatusCode2manoFormat
= {4: 'ACTIVE',
117 netStatus2manoFormat
= {'ACTIVE': 'ACTIVE', 'PAUSED': 'PAUSED', 'INACTIVE': 'INACTIVE', 'BUILD': 'BUILD',
118 'ERROR': 'ERROR', 'DELETED': 'DELETED'
121 class vimconnector(vimconn
.vimconnector
):
122 # dict used to store flavor in memory
125 def __init__(self
, uuid
=None, name
=None, tenant_id
=None, tenant_name
=None,
126 url
=None, url_admin
=None, user
=None, passwd
=None, log_level
=None, config
={}, persistent_info
={}):
128 Constructor create vmware connector to vCloud director.
130 By default construct doesn't validate connection state. So client can create object with None arguments.
131 If client specified username , password and host and VDC name. Connector initialize other missing attributes.
133 a) It initialize organization UUID
134 b) Initialize tenant_id/vdc ID. (This information derived from tenant name)
137 uuid - is organization uuid.
138 name - is organization name that must be presented in vCloud director.
139 tenant_id - is VDC uuid it must be presented in vCloud director
140 tenant_name - is VDC name.
141 url - is hostname or ip address of vCloud director
142 url_admin - same as above.
143 user - is user that administrator for organization. Caller must make sure that
144 username has right privileges.
146 password - is password for a user.
148 VMware connector also requires PVDC administrative privileges and separate account.
149 This variables must be passed via config argument dict contains keys
151 dict['admin_username']
152 dict['admin_password']
153 config - Provide NSX and vCenter information
159 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
,
160 url_admin
, user
, passwd
, log_level
, config
)
162 self
.logger
= logging
.getLogger('openmano.vim.vmware')
163 self
.logger
.setLevel(10)
164 self
.persistent_info
= persistent_info
169 self
.url_admin
= url_admin
170 self
.tenant_id
= tenant_id
171 self
.tenant_name
= tenant_name
175 self
.admin_password
= None
176 self
.admin_user
= None
178 self
.nsx_manager
= None
180 self
.nsx_password
= None
182 if tenant_name
is not None:
183 orgnameandtenant
= tenant_name
.split(":")
184 if len(orgnameandtenant
) == 2:
185 self
.tenant_name
= orgnameandtenant
[1]
186 self
.org_name
= orgnameandtenant
[0]
188 self
.tenant_name
= tenant_name
189 if "orgname" in config
:
190 self
.org_name
= config
['orgname']
193 self
.logger
.setLevel(getattr(logging
, log_level
))
196 self
.admin_user
= config
['admin_username']
197 self
.admin_password
= config
['admin_password']
199 raise vimconn
.vimconnException(message
="Error admin username or admin password is empty.")
202 self
.nsx_manager
= config
['nsx_manager']
203 self
.nsx_user
= config
['nsx_user']
204 self
.nsx_password
= config
['nsx_password']
206 raise vimconn
.vimconnException(message
="Error: nsx manager or nsx user or nsx password is empty in Config")
208 self
.vcenter_ip
= config
.get("vcenter_ip", None)
209 self
.vcenter_port
= config
.get("vcenter_port", None)
210 self
.vcenter_user
= config
.get("vcenter_user", None)
211 self
.vcenter_password
= config
.get("vcenter_password", None)
213 # ############# Stub code for SRIOV #################
215 # self.dvs_name = config['dv_switch_name']
217 # raise vimconn.vimconnException(message="Error: distributed virtaul switch name is empty in Config")
219 # self.vlanID_range = config.get("vlanID_range", None)
225 raise vimconn
.vimconnException('url param can not be NoneType')
227 if not self
.url_admin
: # try to use normal url
228 self
.url_admin
= self
.url
230 logging
.debug("UUID: {} name: {} tenant_id: {} tenant name {}".format(self
.id, self
.org_name
,
231 self
.tenant_id
, self
.tenant_name
))
232 logging
.debug("vcd url {} vcd username: {} vcd password: {}".format(self
.url
, self
.user
, self
.passwd
))
233 logging
.debug("vcd admin username {} vcd admin passowrd {}".format(self
.admin_user
, self
.admin_password
))
235 # initialize organization
236 if self
.user
is not None and self
.passwd
is not None and self
.url
:
237 self
.init_organization()
239 def __getitem__(self
, index
):
242 if index
== 'tenant_id':
243 return self
.tenant_id
244 if index
== 'tenant_name':
245 return self
.tenant_name
248 elif index
== 'org_name':
250 elif index
== 'org_uuid':
252 elif index
== 'user':
254 elif index
== 'passwd':
258 elif index
== 'url_admin':
259 return self
.url_admin
260 elif index
== "config":
263 raise KeyError("Invalid key '%s'" % str(index
))
265 def __setitem__(self
, index
, value
):
268 if index
== 'tenant_id':
269 self
.tenant_id
= value
270 if index
== 'tenant_name':
271 self
.tenant_name
= value
274 elif index
== 'org_name':
275 self
.org_name
= value
276 elif index
== 'org_uuid':
277 self
.org_uuid
= value
278 elif index
== 'user':
280 elif index
== 'passwd':
284 elif index
== 'url_admin':
285 self
.url_admin
= value
287 raise KeyError("Invalid key '%s'" % str(index
))
289 def connect_as_admin(self
):
290 """ Method connect as pvdc admin user to vCloud director.
291 There are certain action that can be done only by provider vdc admin user.
292 Organization creation / provider network creation etc.
295 The return vca object that letter can be used to connect to vcloud direct as admin for provider vdc
298 self
.logger
.debug("Logging in to a vca {} as admin.".format(self
.org_name
))
300 vca_admin
= VCA(host
=self
.url
,
301 username
=self
.admin_user
,
302 service_type
=STANDALONE
,
306 result
= vca_admin
.login(password
=self
.admin_password
, org
='System')
308 raise vimconn
.vimconnConnectionException(
309 "Can't connect to a vCloud director as: {}".format(self
.admin_user
))
310 result
= vca_admin
.login(token
=vca_admin
.token
, org
='System', org_url
=vca_admin
.vcloud_session
.org_url
)
313 "Successfully logged to a vcloud direct org: {} as user: {}".format('System', self
.admin_user
))
318 """ Method connect as normal user to vCloud director.
321 The return vca object that letter can be used to connect to vCloud director as admin for VDC
325 self
.logger
.debug("Logging in to a vca {} as {} to datacenter {}.".format(self
.org_name
,
328 vca
= VCA(host
=self
.url
,
330 service_type
=STANDALONE
,
335 result
= vca
.login(password
=self
.passwd
, org
=self
.org_name
)
337 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director as: {}".format(self
.user
))
338 result
= vca
.login(token
=vca
.token
, org
=self
.org_name
, org_url
=vca
.vcloud_session
.org_url
)
341 "Successfully logged to a vcloud direct org: {} as user: {}".format(self
.org_name
, self
.user
))
344 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
345 "{} as user: {}".format(self
.org_name
, self
.user
))
349 def init_organization(self
):
350 """ Method initialize organization UUID and VDC parameters.
352 At bare minimum client must provide organization name that present in vCloud director and VDC.
354 The VDC - UUID ( tenant_id) will be initialized at the run time if client didn't call constructor.
355 The Org - UUID will be initialized at the run time if data center present in vCloud director.
358 The return vca object that letter can be used to connect to vcloud direct as admin
362 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
366 if self
.org_uuid
is None:
367 org_dict
= self
.get_org_list()
369 # we set org UUID at the init phase but we can do it only when we have valid credential.
370 if org_dict
[org
] == self
.org_name
:
372 self
.logger
.debug("Setting organization UUID {}".format(self
.org_uuid
))
375 raise vimconn
.vimconnException("Vcloud director organization {} not found".format(self
.org_name
))
377 # if well good we require for org details
378 org_details_dict
= self
.get_org(org_uuid
=self
.org_uuid
)
380 # we have two case if we want to initialize VDC ID or VDC name at run time
381 # tenant_name provided but no tenant id
382 if self
.tenant_id
is None and self
.tenant_name
is not None and 'vdcs' in org_details_dict
:
383 vdcs_dict
= org_details_dict
['vdcs']
384 for vdc
in vdcs_dict
:
385 if vdcs_dict
[vdc
] == self
.tenant_name
:
387 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
391 raise vimconn
.vimconnException("Tenant name indicated but not present in vcloud director.")
392 # case two we have tenant_id but we don't have tenant name so we find and set it.
393 if self
.tenant_id
is not None and self
.tenant_name
is None and 'vdcs' in org_details_dict
:
394 vdcs_dict
= org_details_dict
['vdcs']
395 for vdc
in vdcs_dict
:
396 if vdc
== self
.tenant_id
:
397 self
.tenant_name
= vdcs_dict
[vdc
]
398 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
402 raise vimconn
.vimconnException("Tenant id indicated but not present in vcloud director")
403 self
.logger
.debug("Setting organization uuid {}".format(self
.org_uuid
))
405 self
.logger
.debug("Failed initialize organization UUID for org {}".format(self
.org_name
))
406 self
.logger
.debug(traceback
.format_exc())
409 def new_tenant(self
, tenant_name
=None, tenant_description
=None):
410 """ Method adds a new tenant to VIM with this name.
411 This action requires access to create VDC action in vCloud director.
414 tenant_name is tenant_name to be created.
415 tenant_description not used for this call
418 returns the tenant identifier in UUID format.
419 If action is failed method will throw vimconn.vimconnException method
421 vdc_task
= self
.create_vdc(vdc_name
=tenant_name
)
422 if vdc_task
is not None:
423 vdc_uuid
, value
= vdc_task
.popitem()
424 self
.logger
.info("Crated new vdc {} and uuid: {}".format(tenant_name
, vdc_uuid
))
427 raise vimconn
.vimconnException("Failed create tenant {}".format(tenant_name
))
429 def delete_tenant(self
, tenant_id
=None):
430 """ Delete a tenant from VIM
432 tenant_id is tenant_id to be deleted.
435 returns the tenant identifier in UUID format.
436 If action is failed method will throw exception
438 vca
= self
.connect_as_admin()
440 raise vimconn
.vimconnConnectionException("self.connect() is failed")
442 if tenant_id
is not None:
443 if vca
.vcloud_session
and vca
.vcloud_session
.organization
:
445 url_list
= [self
.vca
.host
, '/api/vdc/', tenant_id
]
446 orgvdc_herf
= ''.join(url_list
)
447 response
= Http
.get(url
=orgvdc_herf
,
448 headers
=vca
.vcloud_session
.get_vcloud_headers(),
452 if response
.status_code
!= requests
.codes
.ok
:
453 self
.logger
.debug("delete_tenant():GET REST API call {} failed. "\
454 "Return status code {}".format(orgvdc_herf
,
455 response
.status_code
))
456 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
458 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
459 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
460 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
461 vdc_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
462 vdc_remove_href
= vdc_remove_href
+ '?recursive=true&force=true'
465 response
= Http
.delete(url
=vdc_remove_href
,
466 headers
=vca
.vcloud_session
.get_vcloud_headers(),
470 if response
.status_code
== 202:
471 delete_vdc_task
= taskType
.parseString(response
.content
, True)
472 if type(delete_vdc_task
) is GenericTask
:
473 self
.vca
.block_until_completed(delete_vdc_task
)
474 self
.logger
.info("Deleted tenant with ID {}".format(tenant_id
))
477 self
.logger
.debug("delete_tenant(): DELETE REST API call {} failed. "\
478 "Return status code {}".format(vdc_remove_href
,
479 response
.status_code
))
480 raise vimconn
.vimconnException("Fail to delete tenant with ID {}".format(tenant_id
))
482 self
.logger
.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id
))
483 raise vimconn
.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id
))
486 def get_tenant_list(self
, filter_dict
={}):
487 """Obtain tenants of VIM
488 filter_dict can contain the following keys:
489 name: filter by tenant name
490 id: filter by tenant uuid/id
492 Returns the tenant list of dictionaries:
493 [{'name':'<name>, 'id':'<id>, ...}, ...]
496 org_dict
= self
.get_org(self
.org_uuid
)
497 vdcs_dict
= org_dict
['vdcs']
502 entry
= {'name': vdcs_dict
[k
], 'id': k
}
503 # if caller didn't specify dictionary we return all tenants.
504 if filter_dict
is not None and filter_dict
:
505 filtered_entry
= entry
.copy()
506 filtered_dict
= set(entry
.keys()) - set(filter_dict
)
507 for unwanted_key
in filtered_dict
: del entry
[unwanted_key
]
508 if filter_dict
== entry
:
509 vdclist
.append(filtered_entry
)
511 vdclist
.append(entry
)
513 self
.logger
.debug("Error in get_tenant_list()")
514 self
.logger
.debug(traceback
.format_exc())
515 raise vimconn
.vimconnException("Incorrect state. {}")
519 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False):
520 """Adds a tenant network to VIM
522 net_type can be 'bridge','data'.'ptp'.
523 ip_profile is a dict containing the IP parameters of the network
525 Returns the network identifier"""
527 self
.logger
.debug("new_network tenant {} net_type {} ip_profile {} shared {}"
528 .format(net_name
, net_type
, ip_profile
, shared
))
534 # ############# Stub code for SRIOV #################
535 # if net_type == "data" or net_type == "ptp":
536 # if self.config.get('dv_switch_name') == None:
537 # raise vimconn.vimconnConflictException("You must provide 'dv_switch_name' at config value")
538 # network_uuid = self.create_dvPort_group(net_name)
540 network_uuid
= self
.create_network(network_name
=net_name
, net_type
=net_type
,
541 ip_profile
=ip_profile
, isshared
=isshared
)
542 if network_uuid
is not None:
545 raise vimconn
.vimconnUnexpectedResponse("Failed create a new network {}".format(net_name
))
547 def get_vcd_network_list(self
):
548 """ Method available organization for a logged in tenant
551 The return vca object that letter can be used to connect to vcloud direct as admin
554 self
.logger
.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
556 if not self
.tenant_name
:
557 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
559 vdc
= self
.get_vdc_details()
561 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self
.tenant_name
))
563 vdc_uuid
= vdc
.get_id().split(":")[3]
564 networks
= self
.vca
.get_networks(vdc
.get_name())
567 for network
in networks
:
569 netid
= network
.get_id().split(":")
573 filter_dict
["name"] = network
.get_name()
574 filter_dict
["id"] = netid
[3]
575 filter_dict
["shared"] = network
.get_IsShared()
576 filter_dict
["tenant_id"] = vdc_uuid
577 if network
.get_status() == 1:
578 filter_dict
["admin_state_up"] = True
580 filter_dict
["admin_state_up"] = False
581 filter_dict
["status"] = "ACTIVE"
582 filter_dict
["type"] = "bridge"
583 network_list
.append(filter_dict
)
584 self
.logger
.debug("get_vcd_network_list adding entry {}".format(filter_dict
))
586 self
.logger
.debug("Error in get_vcd_network_list")
587 self
.logger
.debug(traceback
.format_exc())
590 self
.logger
.debug("get_vcd_network_list returning {}".format(network_list
))
593 def get_network_list(self
, filter_dict
={}):
594 """Obtain tenant networks of VIM
596 name: network name OR/AND
597 id: network uuid OR/AND
598 shared: boolean OR/AND
599 tenant_id: tenant OR/AND
600 admin_state_up: boolean
603 [{key : value , key : value}]
605 Returns the network list of dictionaries:
606 [{<the fields at Filter_dict plus some VIM specific>}, ...]
610 self
.logger
.debug("get_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
612 if not self
.tenant_name
:
613 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
615 vdc
= self
.get_vdc_details()
617 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}.".format(self
.tenant_name
))
620 vdcid
= vdc
.get_id().split(":")[3]
621 networks
= self
.vca
.get_networks(vdc
.get_name())
624 for network
in networks
:
626 net_uuid
= network
.get_id().split(":")
627 if len(net_uuid
) != 4:
630 net_uuid
= net_uuid
[3]
632 self
.logger
.debug("Adding {} to a list vcd id {} network {}".format(net_uuid
,
635 filter_entry
["name"] = network
.get_name()
636 filter_entry
["id"] = net_uuid
637 filter_entry
["shared"] = network
.get_IsShared()
638 filter_entry
["tenant_id"] = vdcid
639 if network
.get_status() == 1:
640 filter_entry
["admin_state_up"] = True
642 filter_entry
["admin_state_up"] = False
643 filter_entry
["status"] = "ACTIVE"
644 filter_entry
["type"] = "bridge"
645 filtered_entry
= filter_entry
.copy()
647 if filter_dict
is not None and filter_dict
:
648 # we remove all the key : value we don't care and match only
650 filtered_dict
= set(filter_entry
.keys()) - set(filter_dict
)
651 for unwanted_key
in filtered_dict
: del filter_entry
[unwanted_key
]
652 if filter_dict
== filter_entry
:
653 network_list
.append(filtered_entry
)
655 network_list
.append(filtered_entry
)
657 self
.logger
.debug("Error in get_vcd_network_list")
658 self
.logger
.debug(traceback
.format_exc())
660 self
.logger
.debug("Returning {}".format(network_list
))
663 def get_network(self
, net_id
):
664 """Method obtains network details of net_id VIM network
665 Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
668 vdc
= self
.get_vdc_details()
669 vdc_id
= vdc
.get_id().split(":")[3]
671 networks
= self
.vca
.get_networks(vdc
.get_name())
674 for network
in networks
:
675 vdc_network_id
= network
.get_id().split(":")
676 if len(vdc_network_id
) == 4 and vdc_network_id
[3] == net_id
:
677 filter_dict
["name"] = network
.get_name()
678 filter_dict
["id"] = vdc_network_id
[3]
679 filter_dict
["shared"] = network
.get_IsShared()
680 filter_dict
["tenant_id"] = vdc_id
681 if network
.get_status() == 1:
682 filter_dict
["admin_state_up"] = True
684 filter_dict
["admin_state_up"] = False
685 filter_dict
["status"] = "ACTIVE"
686 filter_dict
["type"] = "bridge"
687 self
.logger
.debug("Returning {}".format(filter_dict
))
690 self
.logger
.debug("Error in get_network")
691 self
.logger
.debug(traceback
.format_exc())
695 def delete_network(self
, net_id
):
697 Method Deletes a tenant network from VIM, provide the network id.
699 Returns the network identifier or raise an exception
702 # ############# Stub code for SRIOV #################
703 # dvport_group = self.get_dvport_group(net_id)
706 # status = self.destroy_dvport_group(net_id)
708 # # Remove vlanID from persistent info
709 # if net_id in self.persistent_info["used_vlanIDs"]:
710 # del self.persistent_info["used_vlanIDs"][net_id]
714 vcd_network
= self
.get_vcd_network(network_uuid
=net_id
)
715 if vcd_network
is not None and vcd_network
:
716 if self
.delete_network_action(network_uuid
=net_id
):
719 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
721 def refresh_nets_status(self
, net_list
):
722 """Get the status of the networks
723 Params: the list of network identifiers
724 Returns a dictionary with:
725 net_id: #VIM id of this network
726 status: #Mandatory. Text with one of:
727 # DELETED (not found at vim)
728 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
729 # OTHER (Vim reported other status not understood)
730 # ERROR (VIM indicates an ERROR status)
731 # ACTIVE, INACTIVE, DOWN (admin down),
732 # BUILD (on building process)
734 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
735 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
743 vcd_network
= self
.get_vcd_network(network_uuid
=net
)
744 if vcd_network
is not None and vcd_network
:
745 if vcd_network
['status'] == '1':
751 errormsg
= 'Network not found.'
753 dict_entry
[net
] = {'status': status
, 'error_msg': errormsg
,
754 'vim_info': yaml
.safe_dump(vcd_network
)}
756 self
.logger
.debug("Error in refresh_nets_status")
757 self
.logger
.debug(traceback
.format_exc())
761 def get_flavor(self
, flavor_id
):
762 """Obtain flavor details from the VIM
763 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
765 if flavor_id
not in vimconnector
.flavorlist
:
766 raise vimconn
.vimconnNotFoundException("Flavor not found.")
767 return vimconnector
.flavorlist
[flavor_id
]
769 def new_flavor(self
, flavor_data
):
770 """Adds a tenant flavor to VIM
771 flavor_data contains a dictionary with information, keys:
773 ram: memory (cloud type) in MBytes
774 vpcus: cpus (cloud type)
775 extended: EPA parameters
776 - numas: #items requested in same NUMA
777 memory: number of 1G huge pages memory
778 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
779 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
780 - name: interface name
781 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
782 bandwidth: X Gbps; requested guarantee bandwidth
783 vpci: requested virtual PCI address
787 Returns the flavor identifier"""
789 # generate a new uuid put to internal dict and return it.
790 self
.logger
.debug("Creating new flavor - flavor_data: {}".format(flavor_data
))
791 new_flavor
=flavor_data
792 ram
= flavor_data
.get(FLAVOR_RAM_KEY
, 1024)
793 cpu
= flavor_data
.get(FLAVOR_VCPUS_KEY
, 1)
794 disk
= flavor_data
.get(FLAVOR_DISK_KEY
, 1)
796 if not isinstance(ram
, int):
797 raise vimconn
.vimconnException("Non-integer value for ram")
798 elif not isinstance(cpu
, int):
799 raise vimconn
.vimconnException("Non-integer value for cpu")
800 elif not isinstance(disk
, int):
801 raise vimconn
.vimconnException("Non-integer value for disk")
803 extended_flv
= flavor_data
.get("extended")
805 numas
=extended_flv
.get("numas")
808 #overwrite ram and vcpus
809 ram
= numa
['memory']*1024
810 if 'paired-threads' in numa
:
811 cpu
= numa
['paired-threads']*2
812 elif 'cores' in numa
:
814 elif 'threads' in numa
:
815 cpu
= numa
['threads']
817 new_flavor
[FLAVOR_RAM_KEY
] = ram
818 new_flavor
[FLAVOR_VCPUS_KEY
] = cpu
819 new_flavor
[FLAVOR_DISK_KEY
] = disk
820 # generate a new uuid put to internal dict and return it.
821 flavor_id
= uuid
.uuid4()
822 vimconnector
.flavorlist
[str(flavor_id
)] = new_flavor
823 self
.logger
.debug("Created flavor - {} : {}".format(flavor_id
, new_flavor
))
825 return str(flavor_id
)
827 def delete_flavor(self
, flavor_id
):
828 """Deletes a tenant flavor from VIM identify by its id
830 Returns the used id or raise an exception
832 if flavor_id
not in vimconnector
.flavorlist
:
833 raise vimconn
.vimconnNotFoundException("Flavor not found.")
835 vimconnector
.flavorlist
.pop(flavor_id
, None)
838 def new_image(self
, image_dict
):
840 Adds a tenant image to VIM
842 200, image-id if the image is created
843 <0, message if there is an error
846 return self
.get_image_id_from_path(image_dict
['location'])
848 def delete_image(self
, image_id
):
850 Deletes a tenant image from VIM
852 image_id is ID of Image to be deleted
854 returns the image identifier in UUID format or raises an exception on error
856 vca
= self
.connect_as_admin()
858 raise vimconn
.vimconnConnectionException("self.connect() is failed")
859 # Get Catalog details
860 url_list
= [self
.vca
.host
, '/api/catalog/', image_id
]
861 catalog_herf
= ''.join(url_list
)
862 response
= Http
.get(url
=catalog_herf
,
863 headers
=vca
.vcloud_session
.get_vcloud_headers(),
867 if response
.status_code
!= requests
.codes
.ok
:
868 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
869 "Return status code {}".format(catalog_herf
,
870 response
.status_code
))
871 raise vimconn
.vimconnNotFoundException("Fail to get image {}".format(image_id
))
873 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
874 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
875 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
877 catalogItems_section
= lxmlroot_respond
.find("xmlns:CatalogItems",namespaces
)
878 catalogItems
= catalogItems_section
.iterfind("xmlns:CatalogItem",namespaces
)
879 for catalogItem
in catalogItems
:
880 catalogItem_href
= catalogItem
.attrib
['href']
882 #GET details of catalogItem
883 response
= Http
.get(url
=catalogItem_href
,
884 headers
=vca
.vcloud_session
.get_vcloud_headers(),
888 if response
.status_code
!= requests
.codes
.ok
:
889 self
.logger
.debug("delete_image():GET REST API call {} failed. "\
890 "Return status code {}".format(catalog_herf
,
891 response
.status_code
))
892 raise vimconn
.vimconnNotFoundException("Fail to get catalogItem {} for catalog {}".format(
896 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
897 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
898 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
899 catalogitem_remove_href
= lxmlroot_respond
.find("xmlns:Link[@rel='remove']",namespaces
).attrib
['href']
902 response
= Http
.delete(url
= catalogitem_remove_href
,
903 headers
=vca
.vcloud_session
.get_vcloud_headers(),
906 if response
.status_code
== requests
.codes
.no_content
:
907 self
.logger
.debug("Deleted Catalog item {}".format(catalogItem
))
909 raise vimconn
.vimconnException("Fail to delete Catalog Item {}".format(catalogItem
))
912 url_list
= [self
.vca
.host
, '/api/admin/catalog/', image_id
]
913 catalog_remove_herf
= ''.join(url_list
)
914 response
= Http
.delete(url
= catalog_remove_herf
,
915 headers
=vca
.vcloud_session
.get_vcloud_headers(),
919 if response
.status_code
== requests
.codes
.no_content
:
920 self
.logger
.debug("Deleted Catalog {}".format(image_id
))
923 raise vimconn
.vimconnException("Fail to delete Catalog {}".format(image_id
))
926 def catalog_exists(self
, catalog_name
, catalogs
):
933 for catalog
in catalogs
:
934 if catalog
.name
== catalog_name
:
938 def create_vimcatalog(self
, vca
=None, catalog_name
=None):
939 """ Create new catalog entry in vCloud director.
942 vca: vCloud director.
943 catalog_name catalog that client wish to create. Note no validation done for a name.
944 Client must make sure that provide valid string representation.
946 Return (bool) True if catalog created.
950 task
= vca
.create_catalog(catalog_name
, catalog_name
)
951 result
= vca
.block_until_completed(task
)
954 catalogs
= vca
.get_catalogs()
957 return self
.catalog_exists(catalog_name
, catalogs
)
959 # noinspection PyIncorrectDocstring
960 def upload_ovf(self
, vca
=None, catalog_name
=None, image_name
=None, media_file_name
=None,
961 description
='', progress
=False, chunk_bytes
=128 * 1024):
963 Uploads a OVF file to a vCloud catalog
970 :param catalog_name: (str): The name of the catalog to upload the media.
971 :param media_file_name: (str): The name of the local media file to upload.
972 :return: (bool) True if the media file was successfully uploaded, false otherwise.
974 os
.path
.isfile(media_file_name
)
975 statinfo
= os
.stat(media_file_name
)
977 # find a catalog entry where we upload OVF.
978 # create vApp Template and check the status if vCD able to read OVF it will respond with appropirate
980 # if VCD can parse OVF we upload VMDK file
982 for catalog
in vca
.get_catalogs():
983 if catalog_name
!= catalog
.name
:
985 link
= filter(lambda link
: link
.get_type() == "application/vnd.vmware.vcloud.media+xml" and
986 link
.get_rel() == 'add', catalog
.get_Link())
987 assert len(link
) == 1
989 <UploadVAppTemplateParams name="%s" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>%s vApp Template</Description></UploadVAppTemplateParams>
990 """ % (escape(catalog_name
), escape(description
))
991 headers
= vca
.vcloud_session
.get_vcloud_headers()
992 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
993 response
= Http
.post(link
[0].get_href(), headers
=headers
, data
=data
, verify
=vca
.verify
, logger
=self
.logger
)
994 if response
.status_code
== requests
.codes
.created
:
995 catalogItem
= XmlElementTree
.fromstring(response
.content
)
996 entity
= [child
for child
in catalogItem
if
997 child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
998 href
= entity
.get('href')
1000 response
= Http
.get(href
, headers
=vca
.vcloud_session
.get_vcloud_headers(),
1001 verify
=vca
.verify
, logger
=self
.logger
)
1003 if response
.status_code
== requests
.codes
.ok
:
1004 media
= mediaType
.parseString(response
.content
, True)
1005 link
= filter(lambda link
: link
.get_rel() == 'upload:default',
1006 media
.get_Files().get_File()[0].get_Link())[0]
1007 headers
= vca
.vcloud_session
.get_vcloud_headers()
1008 headers
['Content-Type'] = 'Content-Type text/xml'
1009 response
= Http
.put(link
.get_href(),
1010 data
=open(media_file_name
, 'rb'),
1012 verify
=vca
.verify
, logger
=self
.logger
)
1013 if response
.status_code
!= requests
.codes
.ok
:
1015 "Failed create vApp template for catalog name {} and image {}".format(catalog_name
,
1019 # TODO fix this with aync block
1022 self
.logger
.debug("vApp template for catalog name {} and image {}".format(catalog_name
, media_file_name
))
1024 # uploading VMDK file
1025 # check status of OVF upload and upload remaining files.
1026 response
= Http
.get(template
,
1027 headers
=vca
.vcloud_session
.get_vcloud_headers(),
1031 if response
.status_code
== requests
.codes
.ok
:
1032 media
= mediaType
.parseString(response
.content
, True)
1033 number_of_files
= len(media
.get_Files().get_File())
1034 for index
in xrange(0, number_of_files
):
1035 links_list
= filter(lambda link
: link
.get_rel() == 'upload:default',
1036 media
.get_Files().get_File()[index
].get_Link())
1037 for link
in links_list
:
1038 # we skip ovf since it already uploaded.
1039 if 'ovf' in link
.get_href():
1041 # The OVF file and VMDK must be in a same directory
1042 head
, tail
= os
.path
.split(media_file_name
)
1043 file_vmdk
= head
+ '/' + link
.get_href().split("/")[-1]
1044 if not os
.path
.isfile(file_vmdk
):
1046 statinfo
= os
.stat(file_vmdk
)
1047 if statinfo
.st_size
== 0:
1049 hrefvmdk
= link
.get_href()
1052 print("Uploading file: {}".format(file_vmdk
))
1054 widgets
= ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
1055 FileTransferSpeed()]
1056 progress_bar
= ProgressBar(widgets
=widgets
, maxval
=statinfo
.st_size
).start()
1058 bytes_transferred
= 0
1059 f
= open(file_vmdk
, 'rb')
1060 while bytes_transferred
< statinfo
.st_size
:
1061 my_bytes
= f
.read(chunk_bytes
)
1062 if len(my_bytes
) <= chunk_bytes
:
1063 headers
= vca
.vcloud_session
.get_vcloud_headers()
1064 headers
['Content-Range'] = 'bytes %s-%s/%s' % (
1065 bytes_transferred
, len(my_bytes
) - 1, statinfo
.st_size
)
1066 headers
['Content-Length'] = str(len(my_bytes
))
1067 response
= Http
.put(hrefvmdk
,
1073 if response
.status_code
== requests
.codes
.ok
:
1074 bytes_transferred
+= len(my_bytes
)
1076 progress_bar
.update(bytes_transferred
)
1079 'file upload failed with error: [%s] %s' % (response
.status_code
,
1086 progress_bar
.finish()
1090 self
.logger
.debug("Failed retrieve vApp template for catalog name {} for OVF {}".
1091 format(catalog_name
, media_file_name
))
1093 except Exception as exp
:
1094 self
.logger
.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1095 .format(catalog_name
,media_file_name
, exp
))
1096 raise vimconn
.vimconnException(
1097 "Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
1098 .format(catalog_name
,media_file_name
, exp
))
1100 self
.logger
.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name
, media_file_name
))
1103 def upload_vimimage(self
, vca
=None, catalog_name
=None, media_name
=None, medial_file_name
=None, progress
=False):
1104 """Upload media file"""
1105 # TODO add named parameters for readability
1107 return self
.upload_ovf(vca
=vca
, catalog_name
=catalog_name
, image_name
=media_name
.split(".")[0],
1108 media_file_name
=medial_file_name
, description
='medial_file_name', progress
=progress
)
1110 def validate_uuid4(self
, uuid_string
=None):
1111 """ Method validate correct format of UUID.
1113 Return: true if string represent valid uuid
1116 val
= uuid
.UUID(uuid_string
, version
=4)
1121 def get_catalogid(self
, catalog_name
=None, catalogs
=None):
1122 """ Method check catalog and return catalog ID in UUID format.
1125 catalog_name: catalog name as string
1126 catalogs: list of catalogs.
1128 Return: catalogs uuid
1131 for catalog
in catalogs
:
1132 if catalog
.name
== catalog_name
:
1133 catalog_id
= catalog
.get_id().split(":")
1134 return catalog_id
[3]
1137 def get_catalogbyid(self
, catalog_uuid
=None, catalogs
=None):
1138 """ Method check catalog and return catalog name lookup done by catalog UUID.
1141 catalog_name: catalog name as string
1142 catalogs: list of catalogs.
1144 Return: catalogs name or None
1147 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1150 for catalog
in catalogs
:
1151 catalog_id
= catalog
.get_id().split(":")[3]
1152 if catalog_id
== catalog_uuid
:
1156 def get_catalog_obj(self
, catalog_uuid
=None, catalogs
=None):
1157 """ Method check catalog and return catalog name lookup done by catalog UUID.
1160 catalog_name: catalog name as string
1161 catalogs: list of catalogs.
1163 Return: catalogs name or None
1166 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
1169 for catalog
in catalogs
:
1170 catalog_id
= catalog
.get_id().split(":")[3]
1171 if catalog_id
== catalog_uuid
:
1175 def get_image_id_from_path(self
, path
=None, progress
=False):
1176 """ Method upload OVF image to vCloud director.
1178 Each OVF image represented as single catalog entry in vcloud director.
1179 The method check for existing catalog entry. The check done by file name without file extension.
1181 if given catalog name already present method will respond with existing catalog uuid otherwise
1182 it will create new catalog entry and upload OVF file to newly created catalog.
1184 If method can't create catalog entry or upload a file it will throw exception.
1186 Method accept boolean flag progress that will output progress bar. It useful method
1187 for standalone upload use case. In case to test large file upload.
1190 path: - valid path to OVF file.
1191 progress - boolean progress bar show progress bar.
1193 Return: if image uploaded correct method will provide image catalog UUID.
1197 raise vimconn
.vimconnException("Image path can't be None.")
1199 if not os
.path
.isfile(path
):
1200 raise vimconn
.vimconnException("Can't read file. File not found.")
1202 if not os
.access(path
, os
.R_OK
):
1203 raise vimconn
.vimconnException("Can't read file. Check file permission to read.")
1205 self
.logger
.debug("get_image_id_from_path() client requesting {} ".format(path
))
1207 dirpath
, filename
= os
.path
.split(path
)
1208 flname
, file_extension
= os
.path
.splitext(path
)
1209 if file_extension
!= '.ovf':
1210 self
.logger
.debug("Wrong file extension {} connector support only OVF container.".format(file_extension
))
1211 raise vimconn
.vimconnException("Wrong container. vCloud director supports only OVF.")
1213 catalog_name
= os
.path
.splitext(filename
)[0]
1214 catalog_md5_name
= hashlib
.md5(path
).hexdigest()
1215 self
.logger
.debug("File name {} Catalog Name {} file path {} "
1216 "vdc catalog name {}".format(filename
, catalog_name
, path
, catalog_md5_name
))
1219 catalogs
= self
.vca
.get_catalogs()
1220 except Exception as exp
:
1221 self
.logger
.debug("Failed get catalogs() with Exception {} ".format(exp
))
1222 raise vimconn
.vimconnException("Failed get catalogs() with Exception {} ".format(exp
))
1224 if len(catalogs
) == 0:
1225 self
.logger
.info("Creating a new catalog entry {} in vcloud director".format(catalog_name
))
1226 result
= self
.create_vimcatalog(self
.vca
, catalog_md5_name
)
1228 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1229 result
= self
.upload_vimimage(vca
=self
.vca
, catalog_name
=catalog_md5_name
,
1230 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1232 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_name
))
1233 return self
.get_catalogid(catalog_name
, self
.vca
.get_catalogs())
1235 for catalog
in catalogs
:
1236 # search for existing catalog if we find same name we return ID
1237 # TODO optimize this
1238 if catalog
.name
== catalog_md5_name
:
1239 self
.logger
.debug("Found existing catalog entry for {} "
1240 "catalog id {}".format(catalog_name
,
1241 self
.get_catalogid(catalog_md5_name
, catalogs
)))
1242 return self
.get_catalogid(catalog_md5_name
, self
.vca
.get_catalogs())
1244 # if we didn't find existing catalog we create a new one and upload image.
1245 self
.logger
.debug("Creating new catalog entry {} - {}".format(catalog_name
, catalog_md5_name
))
1246 result
= self
.create_vimcatalog(self
.vca
, catalog_md5_name
)
1248 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1250 result
= self
.upload_vimimage(vca
=self
.vca
, catalog_name
=catalog_md5_name
,
1251 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1253 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_md5_name
))
1255 return self
.get_catalogid(catalog_md5_name
, self
.vca
.get_catalogs())
1257 def get_image_list(self
, filter_dict
={}):
1258 '''Obtain tenant images from VIM
1262 checksum: image checksum
1263 location: image path
1264 Returns the image list of dictionaries:
1265 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1271 catalogs
= self
.vca
.get_catalogs()
1272 if len(catalogs
) == 0:
1275 for catalog
in catalogs
:
1276 catalog_uuid
= catalog
.get_id().split(":")[3]
1279 if filter_dict
.get("name") and filter_dict
["name"] != name
:
1281 if filter_dict
.get("id") and filter_dict
["id"] != catalog_uuid
:
1283 filtered_dict
["name"] = name
1284 filtered_dict
["id"] = catalog_uuid
1285 image_list
.append(filtered_dict
)
1287 self
.logger
.debug("List of already created catalog items: {}".format(image_list
))
1289 except Exception as exp
:
1290 raise vimconn
.vimconnException("Exception occured while retriving catalog items {}".format(exp
))
1292 def get_vappid(self
, vdc
=None, vapp_name
=None):
1293 """ Method takes vdc object and vApp name and returns vapp uuid or None
1296 vdc: The VDC object.
1297 vapp_name: is application vappp name identifier
1300 The return vApp name otherwise None
1302 if vdc
is None or vapp_name
is None:
1304 # UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
1306 refs
= filter(lambda ref
: ref
.name
== vapp_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1307 vdc
.ResourceEntities
.ResourceEntity
)
1309 return refs
[0].href
.split("vapp")[1][1:]
1310 except Exception as e
:
1311 self
.logger
.exception(e
)
1315 def check_vapp(self
, vdc
=None, vapp_uuid
=None):
1316 """ Method Method returns True or False if vapp deployed in vCloud director
1319 vca: Connector to VCA
1320 vdc: The VDC object.
1321 vappid: vappid is application identifier
1324 The return True if vApp deployed
1329 refs
= filter(lambda ref
:
1330 ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1331 vdc
.ResourceEntities
.ResourceEntity
)
1333 vappid
= ref
.href
.split("vapp")[1][1:]
1334 # find vapp with respected vapp uuid
1335 if vappid
== vapp_uuid
:
1337 except Exception as e
:
1338 self
.logger
.exception(e
)
1342 def get_namebyvappid(self
, vdc
=None, vapp_uuid
=None):
1343 """Method returns vApp name from vCD and lookup done by vapp_id.
1346 vca: Connector to VCA
1347 vdc: The VDC object.
1348 vapp_uuid: vappid is application identifier
1351 The return vApp name otherwise None
1355 refs
= filter(lambda ref
: ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1356 vdc
.ResourceEntities
.ResourceEntity
)
1358 # we care only about UUID the rest doesn't matter
1359 vappid
= ref
.href
.split("vapp")[1][1:]
1360 if vappid
== vapp_uuid
:
1361 response
= Http
.get(ref
.href
, headers
=self
.vca
.vcloud_session
.get_vcloud_headers(), verify
=self
.vca
.verify
,
1364 #Retry login if session expired & retry sending request
1365 if response
.status_code
== 403:
1366 response
= self
.retry_rest('GET', ref
.href
)
1368 tree
= XmlElementTree
.fromstring(response
.content
)
1369 return tree
.attrib
['name']
1370 except Exception as e
:
1371 self
.logger
.exception(e
)
1375 def new_vminstance(self
, name
=None, description
="", start
=False, image_id
=None, flavor_id
=None, net_list
=[],
1376 cloud_config
=None, disk_list
=None, availability_zone_index
=None, availability_zone_list
=None):
1377 """Adds a VM instance to VIM
1379 'start': (boolean) indicates if VM must start or created in pause mode.
1380 'image_id','flavor_id': image and flavor VIM id to use for the VM
1381 'net_list': list of interfaces, each one is a dictionary with:
1382 'name': (optional) name for the interface.
1383 'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
1384 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
1385 'model': (optional and only have sense for type==virtual) interface model: virtio, e2000, ...
1386 'mac_address': (optional) mac address to assign to this interface
1387 #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
1388 the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
1389 'type': (mandatory) can be one of:
1390 'virtual', in this case always connected to a network of type 'net_type=bridge'
1391 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
1392 can created unconnected
1393 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
1394 'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
1395 are allocated on the same physical NIC
1396 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS
1397 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing
1398 or True, it must apply the default VIM behaviour
1399 After execution the method will add the key:
1400 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this
1401 interface. 'net_list' is modified
1402 'cloud_config': (optional) dictionary with:
1403 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1404 'users': (optional) list of users to be inserted, each item is a dict with:
1405 'name': (mandatory) user name,
1406 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1407 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
1408 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
1409 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1410 'dest': (mandatory) string with the destination absolute path
1411 'encoding': (optional, by default text). Can be one of:
1412 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1413 'content' (mandatory): string with the content of the file
1414 'permissions': (optional) string with file permissions, typically octal notation '0644'
1415 'owner': (optional) file owner, string with the format 'owner:group'
1416 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1417 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1418 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1419 'size': (mandatory) string with the size of the disk in GB
1420 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1421 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1422 availability_zone_index is None
1423 Returns the instance identifier or raises an exception on error
1425 self
.logger
.info("Creating new instance for entry {}".format(name
))
1426 self
.logger
.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {} disk_list {}".format(
1427 description
, start
, image_id
, flavor_id
, net_list
, cloud_config
, disk_list
))
1429 #new vm name = vmname + tenant_id + uuid
1430 new_vm_name
= [name
, '-', str(uuid
.uuid4())]
1431 vmname_andid
= ''.join(new_vm_name
)
1433 # if vm already deployed we return existing uuid
1434 # vapp_uuid = self.get_vappid(vca.get_vdc(self.tenant_name), name)
1435 # if vapp_uuid is not None:
1438 # we check for presence of VDC, Catalog entry and Flavor.
1439 vdc
= self
.get_vdc_details()
1441 raise vimconn
.vimconnNotFoundException(
1442 "new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name
))
1443 catalogs
= self
.vca
.get_catalogs()
1444 if catalogs
is None:
1445 #Retry once, if failed by refreshing token
1447 catalogs
= self
.vca
.get_catalogs()
1448 if catalogs
is None:
1449 raise vimconn
.vimconnNotFoundException(
1450 "new_vminstance(): Failed create vApp {}: (Failed retrieve catalogs list)".format(name
))
1452 catalog_hash_name
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1453 if catalog_hash_name
:
1454 self
.logger
.info("Found catalog entry {} for image id {}".format(catalog_hash_name
, image_id
))
1456 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1457 "(Failed retrieve catalog information {})".format(name
, image_id
))
1460 # Set vCPU and Memory based on flavor.
1466 if flavor_id
is not None:
1467 if flavor_id
not in vimconnector
.flavorlist
:
1468 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1469 "Failed retrieve flavor information "
1470 "flavor id {}".format(name
, flavor_id
))
1473 flavor
= vimconnector
.flavorlist
[flavor_id
]
1474 vm_cpus
= flavor
[FLAVOR_VCPUS_KEY
]
1475 vm_memory
= flavor
[FLAVOR_RAM_KEY
]
1476 vm_disk
= flavor
[FLAVOR_DISK_KEY
]
1477 extended
= flavor
.get("extended", None)
1479 numas
=extended
.get("numas", None)
1481 except Exception as exp
:
1482 raise vimconn
.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id
, exp
))
1484 # image upload creates template name as catalog name space Template.
1485 templateName
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1490 # client must provide at least one entry in net_list if not we report error
1491 #If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
1492 #If no mgmt, then the 1st NN in netlist is considered as primary net.
1494 primary_netname
= None
1495 network_mode
= 'bridged'
1496 if net_list
is not None and len(net_list
) > 0:
1497 for net
in net_list
:
1498 if 'use' in net
and net
['use'] == 'mgmt' and not primary_net
:
1500 if primary_net
is None:
1501 primary_net
= net_list
[0]
1504 primary_net_id
= primary_net
['net_id']
1505 network_dict
= self
.get_vcd_network(network_uuid
=primary_net_id
)
1506 if 'name' in network_dict
:
1507 primary_netname
= network_dict
['name']
1510 raise vimconn
.vimconnException("Corrupted flavor. {}".format(primary_net
))
1512 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name
))
1514 # use: 'data', 'bridge', 'mgmt'
1515 # create vApp. Set vcpu and ram based on flavor id.
1518 vapptask
= self
.vca
.create_vapp(self
.tenant_name
, vmname_andid
, templateName
,
1519 self
.get_catalogbyid(image_id
, catalogs
),
1520 network_name
=None, # None while creating vapp
1521 network_mode
=network_mode
,
1522 vm_name
=vmname_andid
,
1523 vm_cpus
=vm_cpus
, # can be None if flavor is None
1524 vm_memory
=vm_memory
) # can be None if flavor is None
1526 if not vapptask
and retry
==1:
1527 self
.get_token() # Retry getting token
1532 if vapptask
is None or vapptask
is False:
1533 raise vimconn
.vimconnUnexpectedResponse(
1534 "new_vminstance(): failed to create vApp {}".format(vmname_andid
))
1535 if type(vapptask
) is VappTask
:
1536 self
.vca
.block_until_completed(vapptask
)
1538 except Exception as exp
:
1539 raise vimconn
.vimconnUnexpectedResponse(
1540 "new_vminstance(): failed to create vApp {} with Exception:{}".format(vmname_andid
, exp
))
1542 # we should have now vapp in undeployed state.
1544 vapp_uuid
= self
.get_vappid(self
.get_vdc_details(), vmname_andid
)
1546 except Exception as exp
:
1547 raise vimconn
.vimconnUnexpectedResponse(
1548 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
1549 .format(vmname_andid
, exp
))
1551 if vapp_uuid
is None:
1552 raise vimconn
.vimconnUnexpectedResponse(
1553 "new_vminstance(): Failed to retrieve vApp {} after creation".format(
1556 #Add PCI passthrough/SRIOV configrations
1558 pci_devices_info
= []
1560 reserve_memory
= False
1562 for net
in net_list
:
1563 if net
["type"]=="PF":
1564 pci_devices_info
.append(net
)
1565 elif (net
["type"]=="VF" or net
["type"]=="VFnotShared") and 'net_id'in net
:
1566 sriov_net_info
.append(net
)
1569 if len(pci_devices_info
) > 0:
1570 self
.logger
.info("Need to add PCI devices {} into VM {}".format(pci_devices_info
,
1572 PCI_devices_status
, vm_obj
, vcenter_conect
= self
.add_pci_devices(vapp_uuid
,
1575 if PCI_devices_status
:
1576 self
.logger
.info("Added PCI devives {} to VM {}".format(
1580 reserve_memory
= True
1582 self
.logger
.info("Fail to add PCI devives {} to VM {}".format(
1587 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vmname_andid
)
1590 #Assuming there is only one disk in ovf and fast provisioning in organization vDC is disabled
1591 result
= self
.modify_vm_disk(vapp_uuid
, vm_disk
)
1593 self
.logger
.debug("Modified Disk size of VM {} ".format(vmname_andid
))
1595 #Add new or existing disks to vApp
1597 added_existing_disk
= False
1598 for disk
in disk_list
:
1599 if 'device_type' in disk
and disk
['device_type'] == 'cdrom':
1600 image_id
= disk
['image_id']
1601 # Adding CD-ROM to VM
1602 # will revisit code once specification ready to support this feature
1603 self
.insert_media_to_vm(vapp
, image_id
)
1604 elif "image_id" in disk
and disk
["image_id"] is not None:
1605 self
.logger
.debug("Adding existing disk from image {} to vm {} ".format(
1606 disk
["image_id"] , vapp_uuid
))
1607 self
.add_existing_disk(catalogs
=catalogs
,
1608 image_id
=disk
["image_id"],
1609 size
= disk
["size"],
1610 template_name
=templateName
,
1613 added_existing_disk
= True
1615 #Wait till added existing disk gets reflected into vCD database/API
1616 if added_existing_disk
:
1618 added_existing_disk
= False
1619 self
.add_new_disk(vapp_uuid
, disk
['size'])
1622 # Assigning numa affinity setting
1624 if 'paired-threads-id' in numa
:
1625 paired_threads_id
= numa
['paired-threads-id']
1626 self
.set_numa_affinity(vapp_uuid
, paired_threads_id
)
1628 # add NICs & connect to networks in netlist
1630 self
.logger
.info("Request to connect VM to a network: {}".format(net_list
))
1632 primary_nic_index
= 0
1633 for net
in net_list
:
1634 # openmano uses network id in UUID format.
1635 # vCloud Director need a name so we do reverse operation from provided UUID we lookup a name
1636 # [{'use': 'bridge', 'net_id': '527d4bf7-566a-41e7-a9e7-ca3cdd9cef4f', 'type': 'virtual',
1637 # 'vpci': '0000:00:11.0', 'name': 'eth0'}]
1639 if 'net_id' not in net
:
1642 #Using net_id as a vim_id i.e. vim interface id, as do not have saperate vim interface id
1643 #Same will be returned in refresh_vms_status() as vim_interface_id
1644 net
['vim_id'] = net
['net_id'] # Provide the same VIM identifier as the VIM network
1646 interface_net_id
= net
['net_id']
1647 interface_net_name
= self
.get_network_name_by_id(network_uuid
=interface_net_id
)
1648 interface_network_mode
= net
['use']
1650 if interface_network_mode
== 'mgmt':
1651 primary_nic_index
= nicIndex
1653 """- POOL (A static IP address is allocated automatically from a pool of addresses.)
1654 - DHCP (The IP address is obtained from a DHCP service.)
1655 - MANUAL (The IP address is assigned manually in the IpAddress element.)
1656 - NONE (No IP addressing mode specified.)"""
1658 if primary_netname
is not None:
1659 nets
= filter(lambda n
: n
.name
== interface_net_name
, self
.vca
.get_networks(self
.tenant_name
))
1661 self
.logger
.info("new_vminstance(): Found requested network: {}".format(nets
[0].name
))
1663 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vmname_andid
)
1664 task
= vapp
.connect_to_network(nets
[0].name
, nets
[0].href
)
1665 if type(task
) is GenericTask
:
1666 self
.vca
.block_until_completed(task
)
1667 # connect network to VM - with all DHCP by default
1669 type_list
= ['PF','VF','VFnotShared']
1670 if 'type' in net
and net
['type'] not in type_list
:
1671 # fetching nic type from vnf
1673 nic_type
= net
['model']
1674 self
.logger
.info("new_vminstance(): adding network adapter "\
1675 "to a network {}".format(nets
[0].name
))
1676 self
.add_network_adapter_to_vms(vapp
, nets
[0].name
,
1682 self
.logger
.info("new_vminstance(): adding network adapter "\
1683 "to a network {}".format(nets
[0].name
))
1684 self
.add_network_adapter_to_vms(vapp
, nets
[0].name
,
1690 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vmname_andid
)
1691 # cloud-init for ssh-key injection
1693 self
.cloud_init(vapp
,cloud_config
)
1695 # deploy and power on vm
1696 self
.logger
.debug("new_vminstance(): Deploying vApp {} ".format(name
))
1697 deploytask
= vapp
.deploy(powerOn
=False)
1698 if type(deploytask
) is GenericTask
:
1699 self
.vca
.block_until_completed(deploytask
)
1701 # ############# Stub code for SRIOV #################
1703 # if len(sriov_net_info) > 0:
1704 # self.logger.info("Need to add SRIOV adapters {} into VM {}".format(sriov_net_info,
1706 # sriov_status, vm_obj, vcenter_conect = self.add_sriov(vapp_uuid,
1710 # self.logger.info("Added SRIOV {} to VM {}".format(
1714 # reserve_memory = True
1716 # self.logger.info("Fail to add SRIOV {} to VM {}".format(
1721 # If VM has PCI devices or SRIOV reserve memory for VM
1723 memReserve
= vm_obj
.config
.hardware
.memoryMB
1724 spec
= vim
.vm
.ConfigSpec()
1725 spec
.memoryAllocation
= vim
.ResourceAllocationInfo(reservation
=memReserve
)
1726 task
= vm_obj
.ReconfigVM_Task(spec
=spec
)
1728 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
1729 self
.logger
.info("Reserved memory {} MB for "
1730 "VM VM status: {}".format(str(memReserve
), result
))
1732 self
.logger
.info("Fail to reserved memory {} to VM {}".format(
1733 str(memReserve
), str(vm_obj
)))
1735 self
.logger
.debug("new_vminstance(): power on vApp {} ".format(name
))
1737 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vmname_andid
)
1738 poweron_task
= vapp
.poweron()
1739 if type(poweron_task
) is GenericTask
:
1740 self
.vca
.block_until_completed(poweron_task
)
1742 except Exception as exp
:
1743 # it might be a case if specific mandatory entry in dict is empty or some other pyVcloud exception
1744 self
.logger
.debug("new_vminstance(): Failed create new vm instance {} with exception {}"
1746 raise vimconn
.vimconnException("new_vminstance(): Failed create new vm instance {} with exception {}"
1749 # check if vApp deployed and if that the case return vApp UUID otherwise -1
1752 while wait_time
<= MAX_WAIT_TIME
:
1754 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vmname_andid
)
1755 except Exception as exp
:
1756 raise vimconn
.vimconnUnexpectedResponse(
1757 "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
1758 .format(vmname_andid
, exp
))
1760 if vapp
and vapp
.me
.deployed
:
1761 vapp_uuid
= self
.get_vappid(self
.get_vdc_details(), vmname_andid
)
1764 self
.logger
.debug("new_vminstance(): Wait for vApp {} to deploy".format(name
))
1765 time
.sleep(INTERVAL_TIME
)
1767 wait_time
+=INTERVAL_TIME
1769 if vapp_uuid
is not None:
1772 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name
))
1776 ## based on current discussion
1780 # created: '2016-09-08T11:51:58'
1781 # description: simple-instance.linux1.1
1782 # flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
1783 # hostId: e836c036-74e7-11e6-b249-0800273e724c
1784 # image: dde30fe6-75a9-11e6-ad5f-0800273e724c
1789 def get_vminstance(self
, vim_vm_uuid
=None):
1790 """Returns the VM instance information from VIM"""
1792 self
.logger
.debug("Client requesting vm instance {} ".format(vim_vm_uuid
))
1794 vdc
= self
.get_vdc_details()
1796 raise vimconn
.vimconnConnectionException(
1797 "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
1799 vm_info_dict
= self
.get_vapp_details_rest(vapp_uuid
=vim_vm_uuid
)
1800 if not vm_info_dict
:
1801 self
.logger
.debug("get_vminstance(): Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
1802 raise vimconn
.vimconnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
1804 status_key
= vm_info_dict
['status']
1807 vm_dict
= {'created': vm_info_dict
['created'],
1808 'description': vm_info_dict
['name'],
1809 'status': vcdStatusCode2manoFormat
[int(status_key
)],
1810 'hostId': vm_info_dict
['vmuuid'],
1812 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
1814 if 'interfaces' in vm_info_dict
:
1815 vm_dict
['interfaces'] = vm_info_dict
['interfaces']
1817 vm_dict
['interfaces'] = []
1819 vm_dict
= {'created': '',
1821 'status': vcdStatusCode2manoFormat
[int(-1)],
1822 'hostId': vm_info_dict
['vmuuid'],
1823 'error_msg': "Inconsistency state",
1824 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
1828 def delete_vminstance(self
, vm__vim_uuid
):
1829 """Method poweroff and remove VM instance from vcloud director network.
1832 vm__vim_uuid: VM UUID
1835 Returns the instance identifier
1838 self
.logger
.debug("Client requesting delete vm instance {} ".format(vm__vim_uuid
))
1840 vdc
= self
.get_vdc_details()
1842 self
.logger
.debug("delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(
1844 raise vimconn
.vimconnException(
1845 "delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
1848 vapp_name
= self
.get_namebyvappid(vdc
, vm__vim_uuid
)
1849 if vapp_name
is None:
1850 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1851 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1853 self
.logger
.info("Deleting vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
1855 # Delete vApp and wait for status change if task executed and vApp is None.
1856 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vapp_name
)
1859 if vapp
.me
.deployed
:
1860 self
.logger
.info("Powering off vApp {}".format(vapp_name
))
1864 while wait_time
<= MAX_WAIT_TIME
:
1865 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vapp_name
)
1867 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1868 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1870 power_off_task
= vapp
.poweroff()
1871 if type(power_off_task
) is GenericTask
:
1872 result
= self
.vca
.block_until_completed(power_off_task
)
1877 self
.logger
.info("Wait for vApp {} to power off".format(vapp_name
))
1878 time
.sleep(INTERVAL_TIME
)
1880 wait_time
+=INTERVAL_TIME
1882 self
.logger
.debug("delete_vminstance(): Failed to power off VM instance {} ".format(vm__vim_uuid
))
1884 self
.logger
.info("delete_vminstance(): Powered off VM instance {} ".format(vm__vim_uuid
))
1887 self
.logger
.info("Undeploy vApp {}".format(vapp_name
))
1890 while wait_time
<= MAX_WAIT_TIME
:
1891 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vapp_name
)
1893 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1894 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1895 undeploy_task
= vapp
.undeploy(action
='powerOff')
1897 if type(undeploy_task
) is GenericTask
:
1898 result
= self
.vca
.block_until_completed(undeploy_task
)
1903 self
.logger
.debug("Wait for vApp {} to undeploy".format(vapp_name
))
1904 time
.sleep(INTERVAL_TIME
)
1906 wait_time
+=INTERVAL_TIME
1909 self
.logger
.debug("delete_vminstance(): Failed to undeploy vApp {} ".format(vm__vim_uuid
))
1912 self
.logger
.info("Start deletion of vApp {} ".format(vapp_name
))
1913 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vapp_name
)
1915 if vapp
is not None:
1919 while wait_time
<= MAX_WAIT_TIME
:
1920 vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vapp_name
)
1922 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1923 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1925 delete_task
= vapp
.delete()
1927 if type(delete_task
) is GenericTask
:
1928 self
.vca
.block_until_completed(delete_task
)
1929 result
= self
.vca
.block_until_completed(delete_task
)
1933 self
.logger
.debug("Wait for vApp {} to delete".format(vapp_name
))
1934 time
.sleep(INTERVAL_TIME
)
1936 wait_time
+=INTERVAL_TIME
1939 self
.logger
.debug("delete_vminstance(): Failed delete uuid {} ".format(vm__vim_uuid
))
1942 self
.logger
.debug(traceback
.format_exc())
1943 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
1945 if self
.vca
.get_vapp(self
.get_vdc_details(), vapp_name
) is None:
1946 self
.logger
.info("Deleted vm instance {} sccessfully".format(vm__vim_uuid
))
1949 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
1951 def refresh_vms_status(self
, vm_list
):
1952 """Get the status of the virtual machines and their interfaces/ports
1953 Params: the list of VM identifiers
1954 Returns a dictionary with:
1955 vm_id: #VIM id of this Virtual Machine
1956 status: #Mandatory. Text with one of:
1957 # DELETED (not found at vim)
1958 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1959 # OTHER (Vim reported other status not understood)
1960 # ERROR (VIM indicates an ERROR status)
1961 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1962 # CREATING (on building process), ERROR
1963 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1965 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1966 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1968 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1969 mac_address: #Text format XX:XX:XX:XX:XX:XX
1970 vim_net_id: #network id where this interface is connected
1971 vim_interface_id: #interface/port VIM id
1972 ip_address: #null, or text with IPv4, IPv6 address
1975 self
.logger
.debug("Client requesting refresh vm status for {} ".format(vm_list
))
1977 vdc
= self
.get_vdc_details()
1979 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
1983 for vmuuid
in vm_list
:
1984 vmname
= self
.get_namebyvappid(self
.get_vdc_details(), vmuuid
)
1985 if vmname
is not None:
1988 vm_pci_details
= self
.get_vm_pci_details(vmuuid
)
1989 the_vapp
= self
.vca
.get_vapp(self
.get_vdc_details(), vmname
)
1990 vm_info
= the_vapp
.get_vms_details()
1991 vm_status
= vm_info
[0]['status']
1992 vm_info
[0].update(vm_pci_details
)
1994 vm_dict
= {'status': vcdStatusCode2manoFormat
[the_vapp
.me
.get_status()],
1995 'error_msg': vcdStatusCode2manoFormat
[the_vapp
.me
.get_status()],
1996 'vim_info': yaml
.safe_dump(vm_info
), 'interfaces': []}
1999 vm_app_networks
= the_vapp
.get_vms_network_info()
2000 for vapp_network
in vm_app_networks
:
2001 for vm_network
in vapp_network
:
2002 if vm_network
['name'] == vmname
:
2003 #Assign IP Address based on MAC Address in NSX DHCP lease info
2004 if vm_network
['ip'] is None:
2005 if not nsx_edge_list
:
2006 nsx_edge_list
= self
.get_edge_details()
2007 if nsx_edge_list
is None:
2008 raise vimconn
.vimconnException("refresh_vms_status:"\
2009 "Failed to get edge details from NSX Manager")
2010 if vm_network
['mac'] is not None:
2011 vm_network
['ip'] = self
.get_ipaddr_from_NSXedge(nsx_edge_list
, vm_network
['mac'])
2013 vm_net_id
= self
.get_network_id_by_name(vm_network
['network_name'])
2014 interface
= {"mac_address": vm_network
['mac'],
2015 "vim_net_id": vm_net_id
,
2016 "vim_interface_id": vm_net_id
,
2017 'ip_address': vm_network
['ip']}
2018 # interface['vim_info'] = yaml.safe_dump(vm_network)
2019 vm_dict
["interfaces"].append(interface
)
2020 # add a vm to vm dict
2021 vms_dict
.setdefault(vmuuid
, vm_dict
)
2022 except Exception as exp
:
2023 self
.logger
.debug("Error in response {}".format(exp
))
2024 self
.logger
.debug(traceback
.format_exc())
2029 def get_edge_details(self
):
2030 """Get the NSX edge list from NSX Manager
2031 Returns list of NSX edges
2034 rheaders
= {'Content-Type': 'application/xml'}
2035 nsx_api_url
= '/api/4.0/edges'
2037 self
.logger
.debug("Get edge details from NSX Manager {} {}".format(self
.nsx_manager
, nsx_api_url
))
2040 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2041 auth
= (self
.nsx_user
, self
.nsx_password
),
2042 verify
= False, headers
= rheaders
)
2043 if resp
.status_code
== requests
.codes
.ok
:
2044 paged_Edge_List
= XmlElementTree
.fromstring(resp
.text
)
2045 for edge_pages
in paged_Edge_List
:
2046 if edge_pages
.tag
== 'edgePage':
2047 for edge_summary
in edge_pages
:
2048 if edge_summary
.tag
== 'pagingInfo':
2049 for element
in edge_summary
:
2050 if element
.tag
== 'totalCount' and element
.text
== '0':
2051 raise vimconn
.vimconnException("get_edge_details: No NSX edges details found: {}"
2052 .format(self
.nsx_manager
))
2054 if edge_summary
.tag
== 'edgeSummary':
2055 for element
in edge_summary
:
2056 if element
.tag
== 'id':
2057 edge_list
.append(element
.text
)
2059 raise vimconn
.vimconnException("get_edge_details: No NSX edge details found: {}"
2060 .format(self
.nsx_manager
))
2063 raise vimconn
.vimconnException("get_edge_details: "\
2064 "No NSX edge details found: {}"
2065 .format(self
.nsx_manager
))
2067 self
.logger
.debug("get_edge_details: Found NSX edges {}".format(edge_list
))
2070 self
.logger
.debug("get_edge_details: "
2071 "Failed to get NSX edge details from NSX Manager: {}"
2072 .format(resp
.content
))
2075 except Exception as exp
:
2076 self
.logger
.debug("get_edge_details: "\
2077 "Failed to get NSX edge details from NSX Manager: {}"
2079 raise vimconn
.vimconnException("get_edge_details: "\
2080 "Failed to get NSX edge details from NSX Manager: {}"
2084 def get_ipaddr_from_NSXedge(self
, nsx_edges
, mac_address
):
2085 """Get IP address details from NSX edges, using the MAC address
2086 PARAMS: nsx_edges : List of NSX edges
2087 mac_address : Find IP address corresponding to this MAC address
2088 Returns: IP address corrresponding to the provided MAC address
2092 rheaders
= {'Content-Type': 'application/xml'}
2094 self
.logger
.debug("get_ipaddr_from_NSXedge: Finding IP addr from NSX edge")
2097 for edge
in nsx_edges
:
2098 nsx_api_url
= '/api/4.0/edges/'+ edge
+'/dhcp/leaseInfo'
2100 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
2101 auth
= (self
.nsx_user
, self
.nsx_password
),
2102 verify
= False, headers
= rheaders
)
2104 if resp
.status_code
== requests
.codes
.ok
:
2105 dhcp_leases
= XmlElementTree
.fromstring(resp
.text
)
2106 for child
in dhcp_leases
:
2107 if child
.tag
== 'dhcpLeaseInfo':
2108 dhcpLeaseInfo
= child
2109 for leaseInfo
in dhcpLeaseInfo
:
2110 for elem
in leaseInfo
:
2111 if (elem
.tag
)=='macAddress':
2112 edge_mac_addr
= elem
.text
2113 if (elem
.tag
)=='ipAddress':
2115 if edge_mac_addr
is not None:
2116 if edge_mac_addr
== mac_address
:
2117 self
.logger
.debug("Found ip addr {} for mac {} at NSX edge {}"
2118 .format(ip_addr
, mac_address
,edge
))
2121 self
.logger
.debug("get_ipaddr_from_NSXedge: "\
2122 "Error occurred while getting DHCP lease info from NSX Manager: {}"
2123 .format(resp
.content
))
2125 self
.logger
.debug("get_ipaddr_from_NSXedge: No IP addr found in any NSX edge")
2128 except XmlElementTree
.ParseError
as Err
:
2129 self
.logger
.debug("ParseError in response from NSX Manager {}".format(Err
.message
), exc_info
=True)
2132 def action_vminstance(self
, vm__vim_uuid
=None, action_dict
=None):
2133 """Send and action over a VM instance from VIM
2134 Returns the vm_id if the action was successfully sent to the VIM"""
2136 self
.logger
.debug("Received action for vm {} and action dict {}".format(vm__vim_uuid
, action_dict
))
2137 if vm__vim_uuid
is None or action_dict
is None:
2138 raise vimconn
.vimconnException("Invalid request. VM id or action is None.")
2140 vdc
= self
.get_vdc_details()
2142 return -1, "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
)
2144 vapp_name
= self
.get_namebyvappid(vdc
, vm__vim_uuid
)
2145 if vapp_name
is None:
2146 self
.logger
.debug("action_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2147 raise vimconn
.vimconnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
2149 self
.logger
.info("Action_vminstance vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
2152 the_vapp
= self
.vca
.get_vapp(vdc
, vapp_name
)
2153 # TODO fix all status
2154 if "start" in action_dict
:
2155 vm_info
= the_vapp
.get_vms_details()
2156 vm_status
= vm_info
[0]['status']
2157 self
.logger
.info("action_vminstance: Power on vApp: {}".format(vapp_name
))
2158 if vm_status
== "Suspended" or vm_status
== "Powered off":
2159 power_on_task
= the_vapp
.poweron()
2160 result
= self
.vca
.block_until_completed(power_on_task
)
2161 self
.instance_actions_result("start", result
, vapp_name
)
2162 elif "rebuild" in action_dict
:
2163 self
.logger
.info("action_vminstance: Rebuild vApp: {}".format(vapp_name
))
2164 rebuild_task
= the_vapp
.deploy(powerOn
=True)
2165 result
= self
.vca
.block_until_completed(rebuild_task
)
2166 self
.instance_actions_result("rebuild", result
, vapp_name
)
2167 elif "pause" in action_dict
:
2168 self
.logger
.info("action_vminstance: pause vApp: {}".format(vapp_name
))
2169 pause_task
= the_vapp
.undeploy(action
='suspend')
2170 result
= self
.vca
.block_until_completed(pause_task
)
2171 self
.instance_actions_result("pause", result
, vapp_name
)
2172 elif "resume" in action_dict
:
2173 self
.logger
.info("action_vminstance: resume vApp: {}".format(vapp_name
))
2174 power_task
= the_vapp
.poweron()
2175 result
= self
.vca
.block_until_completed(power_task
)
2176 self
.instance_actions_result("resume", result
, vapp_name
)
2177 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
2178 action_name
, value
= action_dict
.items()[0]
2179 self
.logger
.info("action_vminstance: {} vApp: {}".format(action_name
, vapp_name
))
2180 power_off_task
= the_vapp
.undeploy(action
='powerOff')
2181 result
= self
.vca
.block_until_completed(power_off_task
)
2182 if action_name
== "shutdown":
2183 self
.instance_actions_result("shutdown", result
, vapp_name
)
2185 self
.instance_actions_result("shutoff", result
, vapp_name
)
2186 elif "forceOff" in action_dict
:
2187 result
= the_vapp
.undeploy(action
='force')
2188 self
.instance_actions_result("forceOff", result
, vapp_name
)
2189 elif "reboot" in action_dict
:
2190 self
.logger
.info("action_vminstance: reboot vApp: {}".format(vapp_name
))
2191 reboot_task
= the_vapp
.reboot()
2193 raise vimconn
.vimconnException("action_vminstance: Invalid action {} or action is None.".format(action_dict
))
2195 except Exception as exp
:
2196 self
.logger
.debug("action_vminstance: Failed with Exception {}".format(exp
))
2197 raise vimconn
.vimconnException("action_vminstance: Failed with Exception {}".format(exp
))
2199 def instance_actions_result(self
, action
, result
, vapp_name
):
2201 self
.logger
.info("action_vminstance: Sucessfully {} the vApp: {}".format(action
, vapp_name
))
2203 self
.logger
.error("action_vminstance: Failed to {} vApp: {}".format(action
, vapp_name
))
2205 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
2207 Get a console for the virtual machine
2209 vm_id: uuid of the VM
2210 console_type, can be:
2211 "novnc" (by default), "xvpvnc" for VNC types,
2212 "rdp-html5" for RDP types, "spice-html5" for SPICE types
2213 Returns dict with the console parameters:
2214 protocol: ssh, ftp, http, https, ...
2215 server: usually ip address
2216 port: the http, ssh, ... port
2217 suffix: extra text, e.g. the http path and query string
2219 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2221 # NOT USED METHODS in current version
2223 def host_vim2gui(self
, host
, server_dict
):
2224 """Transform host dictionary from VIM format to GUI format,
2225 and append to the server_dict
2227 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2229 def get_hosts_info(self
):
2230 """Get the information of deployed hosts
2231 Returns the hosts content"""
2232 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2234 def get_hosts(self
, vim_tenant
):
2235 """Get the hosts and deployed instances
2236 Returns the hosts content"""
2237 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2239 def get_processor_rankings(self
):
2240 """Get the processor rankings in the VIM database"""
2241 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2243 def new_host(self
, host_data
):
2244 """Adds a new host to VIM"""
2245 '''Returns status code of the VIM response'''
2246 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2248 def new_external_port(self
, port_data
):
2249 """Adds a external port to VIM"""
2250 '''Returns the port identifier'''
2251 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2253 def new_external_network(self
, net_name
, net_type
):
2254 """Adds a external network to VIM (shared)"""
2255 '''Returns the network identifier'''
2256 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2258 def connect_port_network(self
, port_id
, network_id
, admin
=False):
2259 """Connects a external port to a network"""
2260 '''Returns status code of the VIM response'''
2261 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2263 def new_vminstancefromJSON(self
, vm_data
):
2264 """Adds a VM instance to VIM"""
2265 '''Returns the instance identifier'''
2266 raise vimconn
.vimconnNotImplemented("Should have implemented this")
2268 def get_network_name_by_id(self
, network_uuid
=None):
2269 """Method gets vcloud director network named based on supplied uuid.
2272 network_uuid: network_id
2275 The return network name.
2278 if not network_uuid
:
2282 org_dict
= self
.get_org(self
.org_uuid
)
2283 if 'networks' in org_dict
:
2284 org_network_dict
= org_dict
['networks']
2285 for net_uuid
in org_network_dict
:
2286 if net_uuid
== network_uuid
:
2287 return org_network_dict
[net_uuid
]
2289 self
.logger
.debug("Exception in get_network_name_by_id")
2290 self
.logger
.debug(traceback
.format_exc())
2294 def get_network_id_by_name(self
, network_name
=None):
2295 """Method gets vcloud director network uuid based on supplied name.
2298 network_name: network_name
2300 The return network uuid.
2301 network_uuid: network_id
2304 if not network_name
:
2305 self
.logger
.debug("get_network_id_by_name() : Network name is empty")
2309 org_dict
= self
.get_org(self
.org_uuid
)
2310 if org_dict
and 'networks' in org_dict
:
2311 org_network_dict
= org_dict
['networks']
2312 for net_uuid
,net_name
in org_network_dict
.iteritems():
2313 if net_name
== network_name
:
2316 except KeyError as exp
:
2317 self
.logger
.debug("get_network_id_by_name() : KeyError- {} ".format(exp
))
2321 def list_org_action(self
):
2323 Method leverages vCloud director and query for available organization for particular user
2326 vca - is active VCA connection.
2327 vdc_name - is a vdc name that will be used to query vms action
2330 The return XML respond
2333 url_list
= [self
.vca
.host
, '/api/org']
2334 vm_list_rest_call
= ''.join(url_list
)
2336 if not (not self
.vca
.vcloud_session
or not self
.vca
.vcloud_session
.organization
):
2337 response
= Http
.get(url
=vm_list_rest_call
,
2338 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
2339 verify
=self
.vca
.verify
,
2340 logger
=self
.vca
.logger
)
2342 if response
.status_code
== 403:
2343 response
= self
.retry_rest('GET', vm_list_rest_call
)
2345 if response
.status_code
== requests
.codes
.ok
:
2346 return response
.content
2350 def get_org_action(self
, org_uuid
=None):
2352 Method leverages vCloud director and retrieve available object fdr organization.
2355 vca - is active VCA connection.
2356 vdc_name - is a vdc name that will be used to query vms action
2359 The return XML respond
2362 if org_uuid
is None:
2365 url_list
= [self
.vca
.host
, '/api/org/', org_uuid
]
2366 vm_list_rest_call
= ''.join(url_list
)
2368 if not (not self
.vca
.vcloud_session
or not self
.vca
.vcloud_session
.organization
):
2369 response
= Http
.get(url
=vm_list_rest_call
,
2370 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
2371 verify
=self
.vca
.verify
,
2372 logger
=self
.vca
.logger
)
2374 #Retry login if session expired & retry sending request
2375 if response
.status_code
== 403:
2376 response
= self
.retry_rest('GET', vm_list_rest_call
)
2378 if response
.status_code
== requests
.codes
.ok
:
2379 return response
.content
2383 def get_org(self
, org_uuid
=None):
2385 Method retrieves available organization in vCloud Director
2388 org_uuid - is a organization uuid.
2391 The return dictionary with following key
2392 "network" - for network list under the org
2393 "catalogs" - for network list under the org
2394 "vdcs" - for vdc list under org
2399 if org_uuid
is None:
2402 content
= self
.get_org_action(org_uuid
=org_uuid
)
2407 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2408 for child
in vm_list_xmlroot
:
2409 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.vdc+xml':
2410 vdc_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2411 org_dict
['vdcs'] = vdc_list
2412 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.orgNetwork+xml':
2413 network_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2414 org_dict
['networks'] = network_list
2415 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
2416 catalog_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2417 org_dict
['catalogs'] = catalog_list
2423 def get_org_list(self
):
2425 Method retrieves available organization in vCloud Director
2428 vca - is active VCA connection.
2431 The return dictionary and key for each entry VDC UUID
2436 content
= self
.list_org_action()
2438 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2439 for vm_xml
in vm_list_xmlroot
:
2440 if vm_xml
.tag
.split("}")[1] == 'Org':
2441 org_uuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2442 org_dict
[org_uuid
[0]] = vm_xml
.attrib
['name']
2448 def vms_view_action(self
, vdc_name
=None):
2449 """ Method leverages vCloud director vms query call
2452 vca - is active VCA connection.
2453 vdc_name - is a vdc name that will be used to query vms action
2456 The return XML respond
2458 vca
= self
.connect()
2459 if vdc_name
is None:
2462 url_list
= [vca
.host
, '/api/vms/query']
2463 vm_list_rest_call
= ''.join(url_list
)
2465 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2466 refs
= filter(lambda ref
: ref
.name
== vdc_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vdc+xml',
2467 vca
.vcloud_session
.organization
.Link
)
2469 response
= Http
.get(url
=vm_list_rest_call
,
2470 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2473 if response
.status_code
== requests
.codes
.ok
:
2474 return response
.content
2478 def get_vapp_list(self
, vdc_name
=None):
2480 Method retrieves vApp list deployed vCloud director and returns a dictionary
2481 contains a list of all vapp deployed for queried VDC.
2482 The key for a dictionary is vApp UUID
2486 vca - is active VCA connection.
2487 vdc_name - is a vdc name that will be used to query vms action
2490 The return dictionary and key for each entry vapp UUID
2494 if vdc_name
is None:
2497 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2499 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2500 for vm_xml
in vm_list_xmlroot
:
2501 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
2502 if vm_xml
.attrib
['isVAppTemplate'] == 'true':
2503 rawuuid
= vm_xml
.attrib
['container'].split('/')[-1:]
2504 if 'vappTemplate-' in rawuuid
[0]:
2505 # vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
2506 # vm and use raw UUID as key
2507 vapp_dict
[rawuuid
[0][13:]] = vm_xml
.attrib
2513 def get_vm_list(self
, vdc_name
=None):
2515 Method retrieves VM's list deployed vCloud director. It returns a dictionary
2516 contains a list of all VM's deployed for queried VDC.
2517 The key for a dictionary is VM UUID
2521 vca - is active VCA connection.
2522 vdc_name - is a vdc name that will be used to query vms action
2525 The return dictionary and key for each entry vapp UUID
2529 if vdc_name
is None:
2532 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2534 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2535 for vm_xml
in vm_list_xmlroot
:
2536 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
2537 if vm_xml
.attrib
['isVAppTemplate'] == 'false':
2538 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2539 if 'vm-' in rawuuid
[0]:
2540 # vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
2541 # vm and use raw UUID as key
2542 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2548 def get_vapp(self
, vdc_name
=None, vapp_name
=None, isuuid
=False):
2550 Method retrieves VM deployed vCloud director. It returns VM attribute as dictionary
2551 contains a list of all VM's deployed for queried VDC.
2552 The key for a dictionary is VM UUID
2556 vca - is active VCA connection.
2557 vdc_name - is a vdc name that will be used to query vms action
2560 The return dictionary and key for each entry vapp UUID
2563 vca
= self
.connect()
2565 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2567 if vdc_name
is None:
2570 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2572 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2573 for vm_xml
in vm_list_xmlroot
:
2574 if vm_xml
.tag
.split("}")[1] == 'VMRecord' and vm_xml
.attrib
['isVAppTemplate'] == 'false':
2575 # lookup done by UUID
2577 if vapp_name
in vm_xml
.attrib
['container']:
2578 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2579 if 'vm-' in rawuuid
[0]:
2580 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2582 # lookup done by Name
2584 if vapp_name
in vm_xml
.attrib
['name']:
2585 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2586 if 'vm-' in rawuuid
[0]:
2587 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2594 def get_network_action(self
, network_uuid
=None):
2596 Method leverages vCloud director and query network based on network uuid
2599 vca - is active VCA connection.
2600 network_uuid - is a network uuid
2603 The return XML respond
2606 if network_uuid
is None:
2609 url_list
= [self
.vca
.host
, '/api/network/', network_uuid
]
2610 vm_list_rest_call
= ''.join(url_list
)
2612 if not (not self
.vca
.vcloud_session
or not self
.vca
.vcloud_session
.organization
):
2613 response
= Http
.get(url
=vm_list_rest_call
,
2614 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
2615 verify
=self
.vca
.verify
,
2616 logger
=self
.vca
.logger
)
2618 #Retry login if session expired & retry sending request
2619 if response
.status_code
== 403:
2620 response
= self
.retry_rest('GET', vm_list_rest_call
)
2622 if response
.status_code
== requests
.codes
.ok
:
2623 return response
.content
2627 def get_vcd_network(self
, network_uuid
=None):
2629 Method retrieves available network from vCloud Director
2632 network_uuid - is VCD network UUID
2634 Each element serialized as key : value pair
2636 Following keys available for access. network_configuration['Gateway'}
2640 <IsInherited>true</IsInherited>
2641 <Gateway>172.16.252.100</Gateway>
2642 <Netmask>255.255.255.0</Netmask>
2643 <Dns1>172.16.254.201</Dns1>
2644 <Dns2>172.16.254.202</Dns2>
2645 <DnsSuffix>vmwarelab.edu</DnsSuffix>
2646 <IsEnabled>true</IsEnabled>
2649 <StartAddress>172.16.252.1</StartAddress>
2650 <EndAddress>172.16.252.99</EndAddress>
2655 <FenceMode>bridged</FenceMode>
2658 The return dictionary and key for each entry vapp UUID
2661 network_configuration
= {}
2662 if network_uuid
is None:
2666 content
= self
.get_network_action(network_uuid
=network_uuid
)
2667 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2669 network_configuration
['status'] = vm_list_xmlroot
.get("status")
2670 network_configuration
['name'] = vm_list_xmlroot
.get("name")
2671 network_configuration
['uuid'] = vm_list_xmlroot
.get("id").split(":")[3]
2673 for child
in vm_list_xmlroot
:
2674 if child
.tag
.split("}")[1] == 'IsShared':
2675 network_configuration
['isShared'] = child
.text
.strip()
2676 if child
.tag
.split("}")[1] == 'Configuration':
2677 for configuration
in child
.iter():
2678 tagKey
= configuration
.tag
.split("}")[1].strip()
2680 network_configuration
[tagKey
] = configuration
.text
.strip()
2681 return network_configuration
2682 except Exception as exp
:
2683 self
.logger
.debug("get_vcd_network: Failed with Exception {}".format(exp
))
2684 raise vimconn
.vimconnException("get_vcd_network: Failed with Exception {}".format(exp
))
2686 return network_configuration
2688 def delete_network_action(self
, network_uuid
=None):
2690 Method delete given network from vCloud director
2693 network_uuid - is a network uuid that client wish to delete
2696 The return None or XML respond or false
2699 vca
= self
.connect_as_admin()
2701 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2702 if network_uuid
is None:
2705 url_list
= [vca
.host
, '/api/admin/network/', network_uuid
]
2706 vm_list_rest_call
= ''.join(url_list
)
2708 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2709 response
= Http
.delete(url
=vm_list_rest_call
,
2710 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2714 if response
.status_code
== 202:
2719 def create_network(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
2720 ip_profile
=None, isshared
='true'):
2722 Method create network in vCloud director
2725 network_name - is network name to be created.
2726 net_type - can be 'bridge','data','ptp','mgmt'.
2727 ip_profile is a dict containing the IP parameters of the network
2728 isshared - is a boolean
2729 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2730 It optional attribute. by default if no parent network indicate the first available will be used.
2733 The return network uuid or return None
2736 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
2737 content
= self
.create_network_rest(network_name
=''.join(new_network_name
),
2738 ip_profile
=ip_profile
,
2740 parent_network_uuid
=parent_network_uuid
,
2743 self
.logger
.debug("Failed create network {}.".format(network_name
))
2747 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2748 vcd_uuid
= vm_list_xmlroot
.get('id').split(":")
2749 if len(vcd_uuid
) == 4:
2750 self
.logger
.info("Created new network name: {} uuid: {}".format(network_name
, vcd_uuid
[3]))
2753 self
.logger
.debug("Failed create network {}".format(network_name
))
2756 def create_network_rest(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
2757 ip_profile
=None, isshared
='true'):
2759 Method create network in vCloud director
2762 network_name - is network name to be created.
2763 net_type - can be 'bridge','data','ptp','mgmt'.
2764 ip_profile is a dict containing the IP parameters of the network
2765 isshared - is a boolean
2766 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2767 It optional attribute. by default if no parent network indicate the first available will be used.
2770 The return network uuid or return None
2773 vca
= self
.connect_as_admin()
2775 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
2776 if network_name
is None:
2779 url_list
= [vca
.host
, '/api/admin/vdc/', self
.tenant_id
]
2780 vm_list_rest_call
= ''.join(url_list
)
2781 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2782 response
= Http
.get(url
=vm_list_rest_call
,
2783 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2787 provider_network
= None
2788 available_networks
= None
2789 add_vdc_rest_url
= None
2791 if response
.status_code
!= requests
.codes
.ok
:
2792 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
2793 response
.status_code
))
2797 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
2798 for child
in vm_list_xmlroot
:
2799 if child
.tag
.split("}")[1] == 'ProviderVdcReference':
2800 provider_network
= child
.attrib
.get('href')
2801 # application/vnd.vmware.admin.providervdc+xml
2802 if child
.tag
.split("}")[1] == 'Link':
2803 if child
.attrib
.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
2804 and child
.attrib
.get('rel') == 'add':
2805 add_vdc_rest_url
= child
.attrib
.get('href')
2807 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
2808 self
.logger
.debug("Respond body {}".format(response
.content
))
2811 # find pvdc provided available network
2812 response
= Http
.get(url
=provider_network
,
2813 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2816 if response
.status_code
!= requests
.codes
.ok
:
2817 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
2818 response
.status_code
))
2821 # available_networks.split("/")[-1]
2823 if parent_network_uuid
is None:
2825 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
2826 for child
in vm_list_xmlroot
.iter():
2827 if child
.tag
.split("}")[1] == 'AvailableNetworks':
2828 for networks
in child
.iter():
2829 # application/vnd.vmware.admin.network+xml
2830 if networks
.attrib
.get('href') is not None:
2831 available_networks
= networks
.attrib
.get('href')
2837 #Configure IP profile of the network
2838 ip_profile
= ip_profile
if ip_profile
is not None else DEFAULT_IP_PROFILE
2840 if 'subnet_address' not in ip_profile
or ip_profile
['subnet_address'] is None:
2841 subnet_rand
= random
.randint(0, 255)
2842 ip_base
= "192.168.{}.".format(subnet_rand
)
2843 ip_profile
['subnet_address'] = ip_base
+ "0/24"
2845 ip_base
= ip_profile
['subnet_address'].rsplit('.',1)[0] + '.'
2847 if 'gateway_address' not in ip_profile
or ip_profile
['gateway_address'] is None:
2848 ip_profile
['gateway_address']=ip_base
+ "1"
2849 if 'dhcp_count' not in ip_profile
or ip_profile
['dhcp_count'] is None:
2850 ip_profile
['dhcp_count']=DEFAULT_IP_PROFILE
['dhcp_count']
2851 if 'dhcp_enabled' not in ip_profile
or ip_profile
['dhcp_enabled'] is None:
2852 ip_profile
['dhcp_enabled']=DEFAULT_IP_PROFILE
['dhcp_enabled']
2853 if 'dhcp_start_address' not in ip_profile
or ip_profile
['dhcp_start_address'] is None:
2854 ip_profile
['dhcp_start_address']=ip_base
+ "3"
2855 if 'ip_version' not in ip_profile
or ip_profile
['ip_version'] is None:
2856 ip_profile
['ip_version']=DEFAULT_IP_PROFILE
['ip_version']
2857 if 'dns_address' not in ip_profile
or ip_profile
['dns_address'] is None:
2858 ip_profile
['dns_address']=ip_base
+ "2"
2860 gateway_address
=ip_profile
['gateway_address']
2861 dhcp_count
=int(ip_profile
['dhcp_count'])
2862 subnet_address
=self
.convert_cidr_to_netmask(ip_profile
['subnet_address'])
2864 if ip_profile
['dhcp_enabled']==True:
2867 dhcp_enabled
='false'
2868 dhcp_start_address
=ip_profile
['dhcp_start_address']
2870 #derive dhcp_end_address from dhcp_start_address & dhcp_count
2871 end_ip_int
= int(netaddr
.IPAddress(dhcp_start_address
))
2872 end_ip_int
+= dhcp_count
- 1
2873 dhcp_end_address
= str(netaddr
.IPAddress(end_ip_int
))
2875 ip_version
=ip_profile
['ip_version']
2876 dns_address
=ip_profile
['dns_address']
2877 except KeyError as exp
:
2878 self
.logger
.debug("Create Network REST: Key error {}".format(exp
))
2879 raise vimconn
.vimconnException("Create Network REST: Key error{}".format(exp
))
2881 # either use client provided UUID or search for a first available
2882 # if both are not defined we return none
2883 if parent_network_uuid
is not None:
2884 url_list
= [vca
.host
, '/api/admin/network/', parent_network_uuid
]
2885 add_vdc_rest_url
= ''.join(url_list
)
2887 #Creating all networks as Direct Org VDC type networks.
2888 #Unused in case of Underlay (data/ptp) network interface.
2889 fence_mode
="bridged"
2890 is_inherited
='false'
2891 dns_list
= dns_address
.split(";")
2894 if len(dns_list
) >= 2:
2895 dns2_text
= "\n <Dns2>{}</Dns2>\n".format(dns_list
[1])
2896 data
= """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
2897 <Description>Openmano created</Description>
2901 <IsInherited>{1:s}</IsInherited>
2902 <Gateway>{2:s}</Gateway>
2903 <Netmask>{3:s}</Netmask>
2904 <Dns1>{4:s}</Dns1>{5:s}
2905 <IsEnabled>{6:s}</IsEnabled>
2908 <StartAddress>{7:s}</StartAddress>
2909 <EndAddress>{8:s}</EndAddress>
2914 <ParentNetwork href="{9:s}"/>
2915 <FenceMode>{10:s}</FenceMode>
2917 <IsShared>{11:s}</IsShared>
2918 </OrgVdcNetwork> """.format(escape(network_name
), is_inherited
, gateway_address
,
2919 subnet_address
, dns1
, dns2_text
, dhcp_enabled
,
2920 dhcp_start_address
, dhcp_end_address
, available_networks
,
2921 fence_mode
, isshared
)
2923 headers
= vca
.vcloud_session
.get_vcloud_headers()
2924 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
2926 response
= Http
.post(url
=add_vdc_rest_url
,
2932 if response
.status_code
!= 201:
2933 self
.logger
.debug("Create Network POST REST API call failed. Return status code {}, Response content: {}"
2934 .format(response
.status_code
,response
.content
))
2936 network
= networkType
.parseString(response
.content
, True)
2937 create_nw_task
= network
.get_Tasks().get_Task()[0]
2939 # if we all ok we respond with content after network creation completes
2940 # otherwise by default return None
2941 if create_nw_task
is not None:
2942 self
.logger
.debug("Create Network REST : Waiting for Network creation complete")
2943 status
= vca
.block_until_completed(create_nw_task
)
2945 return response
.content
2947 self
.logger
.debug("create_network_rest task failed. Network Create response : {}"
2948 .format(response
.content
))
2949 except Exception as exp
:
2950 self
.logger
.debug("create_network_rest : Exception : {} ".format(exp
))
2954 def convert_cidr_to_netmask(self
, cidr_ip
=None):
2956 Method sets convert CIDR netmask address to normal IP format
2958 cidr_ip : CIDR IP address
2960 netmask : Converted netmask
2962 if cidr_ip
is not None:
2964 network
, net_bits
= cidr_ip
.split('/')
2965 netmask
= socket
.inet_ntoa(struct
.pack(">I", (0xffffffff << (32 - int(net_bits
))) & 0xffffffff))
2971 def get_provider_rest(self
, vca
=None):
2973 Method gets provider vdc view from vcloud director
2976 network_name - is network name to be created.
2977 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2978 It optional attribute. by default if no parent network indicate the first available will be used.
2981 The return xml content of respond or None
2984 url_list
= [vca
.host
, '/api/admin']
2985 response
= Http
.get(url
=''.join(url_list
),
2986 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2990 if response
.status_code
== requests
.codes
.ok
:
2991 return response
.content
2994 def create_vdc(self
, vdc_name
=None):
2998 xml_content
= self
.create_vdc_from_tmpl_rest(vdc_name
=vdc_name
)
2999 if xml_content
is not None:
3001 task_resp_xmlroot
= XmlElementTree
.fromstring(xml_content
)
3002 for child
in task_resp_xmlroot
:
3003 if child
.tag
.split("}")[1] == 'Owner':
3004 vdc_id
= child
.attrib
.get('href').split("/")[-1]
3005 vdc_dict
[vdc_id
] = task_resp_xmlroot
.get('href')
3008 self
.logger
.debug("Respond body {}".format(xml_content
))
3012 def create_vdc_from_tmpl_rest(self
, vdc_name
=None):
3014 Method create vdc in vCloud director based on VDC template.
3015 it uses pre-defined template that must be named openmano
3018 vdc_name - name of a new vdc.
3021 The return xml content of respond or None
3024 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
3025 vca
= self
.connect()
3027 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3028 if vdc_name
is None:
3031 url_list
= [vca
.host
, '/api/vdcTemplates']
3032 vm_list_rest_call
= ''.join(url_list
)
3033 response
= Http
.get(url
=vm_list_rest_call
,
3034 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3038 # container url to a template
3039 vdc_template_ref
= None
3041 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3042 for child
in vm_list_xmlroot
:
3043 # application/vnd.vmware.admin.providervdc+xml
3044 # we need find a template from witch we instantiate VDC
3045 if child
.tag
.split("}")[1] == 'VdcTemplate':
3046 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml':
3047 vdc_template_ref
= child
.attrib
.get('href')
3049 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3050 self
.logger
.debug("Respond body {}".format(response
.content
))
3053 # if we didn't found required pre defined template we return None
3054 if vdc_template_ref
is None:
3059 url_list
= [vca
.host
, '/api/org/', self
.org_uuid
, '/action/instantiate']
3060 vm_list_rest_call
= ''.join(url_list
)
3061 data
= """<InstantiateVdcTemplateParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
3062 <Source href="{1:s}"></Source>
3063 <Description>opnemano</Description>
3064 </InstantiateVdcTemplateParams>""".format(vdc_name
, vdc_template_ref
)
3065 headers
= vca
.vcloud_session
.get_vcloud_headers()
3066 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVdcTemplateParams+xml'
3067 response
= Http
.post(url
=vm_list_rest_call
, headers
=headers
, data
=data
, verify
=vca
.verify
,
3070 vdc_task
= taskType
.parseString(response
.content
, True)
3071 if type(vdc_task
) is GenericTask
:
3072 self
.vca
.block_until_completed(vdc_task
)
3074 # if we all ok we respond with content otherwise by default None
3075 if response
.status_code
>= 200 and response
.status_code
< 300:
3076 return response
.content
3079 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3080 self
.logger
.debug("Respond body {}".format(response
.content
))
3084 def create_vdc_rest(self
, vdc_name
=None):
3086 Method create network in vCloud director
3089 network_name - is network name to be created.
3090 parent_network_uuid - is parent provider vdc network that will be used for mapping.
3091 It optional attribute. by default if no parent network indicate the first available will be used.
3094 The return network uuid or return None
3097 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
3099 vca
= self
.connect_as_admin()
3101 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3102 if vdc_name
is None:
3105 url_list
= [vca
.host
, '/api/admin/org/', self
.org_uuid
]
3106 vm_list_rest_call
= ''.join(url_list
)
3107 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
3108 response
= Http
.get(url
=vm_list_rest_call
,
3109 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3113 provider_vdc_ref
= None
3114 add_vdc_rest_url
= None
3115 available_networks
= None
3117 if response
.status_code
!= requests
.codes
.ok
:
3118 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
3119 response
.status_code
))
3123 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
3124 for child
in vm_list_xmlroot
:
3125 # application/vnd.vmware.admin.providervdc+xml
3126 if child
.tag
.split("}")[1] == 'Link':
3127 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
3128 and child
.attrib
.get('rel') == 'add':
3129 add_vdc_rest_url
= child
.attrib
.get('href')
3131 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3132 self
.logger
.debug("Respond body {}".format(response
.content
))
3135 response
= self
.get_provider_rest(vca
=vca
)
3137 vm_list_xmlroot
= XmlElementTree
.fromstring(response
)
3138 for child
in vm_list_xmlroot
:
3139 if child
.tag
.split("}")[1] == 'ProviderVdcReferences':
3140 for sub_child
in child
:
3141 provider_vdc_ref
= sub_child
.attrib
.get('href')
3143 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
3144 self
.logger
.debug("Respond body {}".format(response
))
3147 if add_vdc_rest_url
is not None and provider_vdc_ref
is not None:
3148 data
= """ <CreateVdcParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5"><Description>{1:s}</Description>
3149 <AllocationModel>ReservationPool</AllocationModel>
3150 <ComputeCapacity><Cpu><Units>MHz</Units><Allocated>2048</Allocated><Limit>2048</Limit></Cpu>
3151 <Memory><Units>MB</Units><Allocated>2048</Allocated><Limit>2048</Limit></Memory>
3152 </ComputeCapacity><NicQuota>0</NicQuota><NetworkQuota>100</NetworkQuota>
3153 <VdcStorageProfile><Enabled>true</Enabled><Units>MB</Units><Limit>20480</Limit><Default>true</Default></VdcStorageProfile>
3154 <ProviderVdcReference
3155 name="Main Provider"
3157 <UsesFastProvisioning>true</UsesFastProvisioning></CreateVdcParams>""".format(escape(vdc_name
),
3161 headers
= vca
.vcloud_session
.get_vcloud_headers()
3162 headers
['Content-Type'] = 'application/vnd.vmware.admin.createVdcParams+xml'
3163 response
= Http
.post(url
=add_vdc_rest_url
, headers
=headers
, data
=data
, verify
=vca
.verify
,
3166 # if we all ok we respond with content otherwise by default None
3167 if response
.status_code
== 201:
3168 return response
.content
3171 def get_vapp_details_rest(self
, vapp_uuid
=None, need_admin_access
=False):
3173 Method retrieve vapp detail from vCloud director
3176 vapp_uuid - is vapp identifier.
3179 The return network uuid or return None
3185 if need_admin_access
:
3186 vca
= self
.connect_as_admin()
3191 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3192 if vapp_uuid
is None:
3195 url_list
= [vca
.host
, '/api/vApp/vapp-', vapp_uuid
]
3196 get_vapp_restcall
= ''.join(url_list
)
3198 if vca
.vcloud_session
and vca
.vcloud_session
.organization
:
3199 response
= Http
.get(url
=get_vapp_restcall
,
3200 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3204 if response
.status_code
== 403:
3205 if need_admin_access
== False:
3206 response
= self
.retry_rest('GET', get_vapp_restcall
)
3208 if response
.status_code
!= requests
.codes
.ok
:
3209 self
.logger
.debug("REST API call {} failed. Return status code {}".format(get_vapp_restcall
,
3210 response
.status_code
))
3211 return parsed_respond
3214 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
3215 parsed_respond
['ovfDescriptorUploaded'] = xmlroot_respond
.attrib
['ovfDescriptorUploaded']
3217 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
3218 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
3219 'vmw': 'http://www.vmware.com/schema/ovf',
3220 'vm': 'http://www.vmware.com/vcloud/v1.5',
3221 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
3222 "vmext":"http://www.vmware.com/vcloud/extension/v1.5",
3223 "xmlns":"http://www.vmware.com/vcloud/v1.5"
3226 created_section
= xmlroot_respond
.find('vm:DateCreated', namespaces
)
3227 if created_section
is not None:
3228 parsed_respond
['created'] = created_section
.text
3230 network_section
= xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig', namespaces
)
3231 if network_section
is not None and 'networkName' in network_section
.attrib
:
3232 parsed_respond
['networkname'] = network_section
.attrib
['networkName']
3234 ipscopes_section
= \
3235 xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig/vm:Configuration/vm:IpScopes',
3237 if ipscopes_section
is not None:
3238 for ipscope
in ipscopes_section
:
3239 for scope
in ipscope
:
3240 tag_key
= scope
.tag
.split("}")[1]
3241 if tag_key
== 'IpRanges':
3242 ip_ranges
= scope
.getchildren()
3243 for ipblock
in ip_ranges
:
3244 for block
in ipblock
:
3245 parsed_respond
[block
.tag
.split("}")[1]] = block
.text
3247 parsed_respond
[tag_key
] = scope
.text
3249 # parse children section for other attrib
3250 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
3251 if children_section
is not None:
3252 parsed_respond
['name'] = children_section
.attrib
['name']
3253 parsed_respond
['nestedHypervisorEnabled'] = children_section
.attrib
['nestedHypervisorEnabled'] \
3254 if "nestedHypervisorEnabled" in children_section
.attrib
else None
3255 parsed_respond
['deployed'] = children_section
.attrib
['deployed']
3256 parsed_respond
['status'] = children_section
.attrib
['status']
3257 parsed_respond
['vmuuid'] = children_section
.attrib
['id'].split(":")[-1]
3258 network_adapter
= children_section
.find('vm:NetworkConnectionSection', namespaces
)
3260 for adapters
in network_adapter
:
3261 adapter_key
= adapters
.tag
.split("}")[1]
3262 if adapter_key
== 'PrimaryNetworkConnectionIndex':
3263 parsed_respond
['primarynetwork'] = adapters
.text
3264 if adapter_key
== 'NetworkConnection':
3266 if 'network' in adapters
.attrib
:
3267 vnic
['network'] = adapters
.attrib
['network']
3268 for adapter
in adapters
:
3269 setting_key
= adapter
.tag
.split("}")[1]
3270 vnic
[setting_key
] = adapter
.text
3271 nic_list
.append(vnic
)
3273 for link
in children_section
:
3274 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
3275 if link
.attrib
['rel'] == 'screen:acquireTicket':
3276 parsed_respond
['acquireTicket'] = link
.attrib
3277 if link
.attrib
['rel'] == 'screen:acquireMksTicket':
3278 parsed_respond
['acquireMksTicket'] = link
.attrib
3280 parsed_respond
['interfaces'] = nic_list
3281 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
3282 if vCloud_extension_section
is not None:
3283 vm_vcenter_info
= {}
3284 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
3285 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
3286 if vmext
is not None:
3287 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
3288 parsed_respond
["vm_vcenter_info"]= vm_vcenter_info
3290 virtual_hardware_section
= children_section
.find('ovf:VirtualHardwareSection', namespaces
)
3291 vm_virtual_hardware_info
= {}
3292 if virtual_hardware_section
is not None:
3293 for item
in virtual_hardware_section
.iterfind('ovf:Item',namespaces
):
3294 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
3295 disk_size
= item
.find("rasd:HostResource" ,namespaces
3296 ).attrib
["{"+namespaces
['vm']+"}capacity"]
3298 vm_virtual_hardware_info
["disk_size"]= disk_size
3301 for link
in virtual_hardware_section
:
3302 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
3303 if link
.attrib
['rel'] == 'edit' and link
.attrib
['href'].endswith("/disks"):
3304 vm_virtual_hardware_info
["disk_edit_href"] = link
.attrib
['href']
3307 parsed_respond
["vm_virtual_hardware"]= vm_virtual_hardware_info
3308 except Exception as exp
:
3309 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
3310 return parsed_respond
3312 def acuire_console(self
, vm_uuid
=None):
3317 if not (not self
.vca
.vcloud_session
or not self
.vca
.vcloud_session
.organization
):
3318 vm_dict
= self
.get_vapp_details_rest(self
, vapp_uuid
=vm_uuid
)
3319 console_dict
= vm_dict
['acquireTicket']
3320 console_rest_call
= console_dict
['href']
3322 response
= Http
.post(url
=console_rest_call
,
3323 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
3324 verify
=self
.vca
.verify
,
3325 logger
=self
.vca
.logger
)
3326 if response
.status_code
== 403:
3327 response
= self
.retry_rest('POST', console_rest_call
)
3329 if response
.status_code
== requests
.codes
.ok
:
3330 return response
.content
3334 def modify_vm_disk(self
, vapp_uuid
, flavor_disk
):
3336 Method retrieve vm disk details
3339 vapp_uuid - is vapp identifier.
3340 flavor_disk - disk size as specified in VNFD (flavor)
3343 The return network uuid or return None
3347 #Flavor disk is in GB convert it into MB
3348 flavor_disk
= int(flavor_disk
) * 1024
3349 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
3351 vm_name
= vm_details
["name"]
3352 self
.logger
.info("VM: {} flavor_disk :{}".format(vm_name
, flavor_disk
))
3354 if vm_details
and "vm_virtual_hardware" in vm_details
:
3355 vm_disk
= int(vm_details
["vm_virtual_hardware"]["disk_size"])
3356 disk_edit_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
3358 self
.logger
.info("VM: {} VM_disk :{}".format(vm_name
, vm_disk
))
3360 if flavor_disk
> vm_disk
:
3361 status
= self
.modify_vm_disk_rest(disk_edit_href
,flavor_disk
)
3362 self
.logger
.info("Modify disk of VM {} from {} to {} MB".format(vm_name
,
3363 vm_disk
, flavor_disk
))
3366 self
.logger
.info("No need to modify disk of VM {}".format(vm_name
))
3369 except Exception as exp
:
3370 self
.logger
.info("Error occurred while modifing disk size {}".format(exp
))
3373 def modify_vm_disk_rest(self
, disk_href
, disk_size
):
3375 Method retrieve modify vm disk size
3378 disk_href - vCD API URL to GET and PUT disk data
3379 disk_size - disk size as specified in VNFD (flavor)
3382 The return network uuid or return None
3384 if disk_href
is None or disk_size
is None:
3387 if self
.vca
.vcloud_session
and self
.vca
.vcloud_session
.organization
:
3388 response
= Http
.get(url
=disk_href
,
3389 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
3390 verify
=self
.vca
.verify
,
3391 logger
=self
.vca
.logger
)
3393 if response
.status_code
== 403:
3394 response
= self
.retry_rest('GET', disk_href
)
3396 if response
.status_code
!= requests
.codes
.ok
:
3397 self
.logger
.debug("GET REST API call {} failed. Return status code {}".format(disk_href
,
3398 response
.status_code
))
3401 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
3402 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
3403 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
3405 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
3406 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
3407 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
3408 if disk_item
is not None:
3409 disk_item
.attrib
["{"+namespaces
['xmlns']+"}capacity"] = str(disk_size
)
3412 data
= lxmlElementTree
.tostring(lxmlroot_respond
, encoding
='utf8', method
='xml',
3413 xml_declaration
=True)
3415 #Send PUT request to modify disk size
3416 headers
= self
.vca
.vcloud_session
.get_vcloud_headers()
3417 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
3419 response
= Http
.put(url
=disk_href
,
3422 verify
=self
.vca
.verify
, logger
=self
.logger
)
3424 if response
.status_code
== 403:
3425 add_headers
= {'Content-Type': headers
['Content-Type']}
3426 response
= self
.retry_rest('PUT', disk_href
, add_headers
, data
)
3428 if response
.status_code
!= 202:
3429 self
.logger
.debug("PUT REST API call {} failed. Return status code {}".format(disk_href
,
3430 response
.status_code
))
3432 modify_disk_task
= taskType
.parseString(response
.content
, True)
3433 if type(modify_disk_task
) is GenericTask
:
3434 status
= self
.vca
.block_until_completed(modify_disk_task
)
3439 except Exception as exp
:
3440 self
.logger
.info("Error occurred calling rest api for modifing disk size {}".format(exp
))
3443 def add_pci_devices(self
, vapp_uuid
, pci_devices
, vmname_andid
):
3445 Method to attach pci devices to VM
3448 vapp_uuid - uuid of vApp/VM
3449 pci_devices - pci devices infromation as specified in VNFD (flavor)
3452 The status of add pci device task , vm object and
3453 vcenter_conect object
3456 self
.logger
.info("Add pci devices {} into vApp {}".format(pci_devices
, vapp_uuid
))
3457 vcenter_conect
, content
= self
.get_vcenter_content()
3458 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
3462 no_of_pci_devices
= len(pci_devices
)
3463 if no_of_pci_devices
> 0:
3464 #Get VM and its host
3465 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
3466 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
3467 if host_obj
and vm_obj
:
3468 #get PCI devies from host on which vapp is currently installed
3469 avilable_pci_devices
= self
.get_pci_devices(host_obj
, no_of_pci_devices
)
3471 if avilable_pci_devices
is None:
3472 #find other hosts with active pci devices
3473 new_host_obj
, avilable_pci_devices
= self
.get_host_and_PCIdevices(
3478 if new_host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
3479 #Migrate vm to the host where PCI devices are availble
3480 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
, new_host_obj
))
3481 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
3482 if task
is not None:
3483 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
3484 self
.logger
.info("Migrate VM status: {}".format(result
))
3485 host_obj
= new_host_obj
3487 self
.logger
.info("Fail to migrate VM : {}".format(result
))
3488 raise vimconn
.vimconnNotFoundException(
3489 "Fail to migrate VM : {} to host {}".format(
3494 if host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
3495 #Add PCI devices one by one
3496 for pci_device
in avilable_pci_devices
:
3497 task
= self
.add_pci_to_vm(host_obj
, vm_obj
, pci_device
)
3499 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
3501 self
.logger
.info("Added PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
3503 self
.logger
.error("Fail to add PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
3504 return True, vm_obj
, vcenter_conect
3506 self
.logger
.error("Currently there is no host with"\
3507 " {} number of avaialble PCI devices required for VM {}".format(
3511 raise vimconn
.vimconnNotFoundException(
3512 "Currently there is no host with {} "\
3513 "number of avaialble PCI devices required for VM {}".format(
3517 self
.logger
.debug("No infromation about PCI devices {} ",pci_devices
)
3519 except vmodl
.MethodFault
as error
:
3520 self
.logger
.error("Error occurred while adding PCI devices {} ",error
)
3521 return None, vm_obj
, vcenter_conect
3523 def get_vm_obj(self
, content
, mob_id
):
3525 Method to get the vsphere VM object associated with a given morf ID
3527 vapp_uuid - uuid of vApp/VM
3528 content - vCenter content object
3529 mob_id - mob_id of VM
3537 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
3538 [vim
.VirtualMachine
], True
3540 for vm
in container
.view
:
3541 mobID
= vm
._GetMoId
()
3544 host_obj
= vm_obj
.runtime
.host
3546 except Exception as exp
:
3547 self
.logger
.error("Error occurred while finding VM object : {}".format(exp
))
3548 return host_obj
, vm_obj
3550 def get_pci_devices(self
, host
, need_devices
):
3552 Method to get the details of pci devices on given host
3554 host - vSphere host object
3555 need_devices - number of pci devices needed on host
3558 array of pci devices
3562 used_devices_ids
= []
3566 pciPassthruInfo
= host
.config
.pciPassthruInfo
3567 pciDevies
= host
.hardware
.pciDevice
3569 for pci_status
in pciPassthruInfo
:
3570 if pci_status
.passthruActive
:
3571 for device
in pciDevies
:
3572 if device
.id == pci_status
.id:
3573 all_device_ids
.append(device
.id)
3574 all_devices
.append(device
)
3576 #check if devices are in use
3577 avalible_devices
= all_devices
3579 if vm
.runtime
.powerState
== vim
.VirtualMachinePowerState
.poweredOn
:
3580 vm_devices
= vm
.config
.hardware
.device
3581 for device
in vm_devices
:
3582 if type(device
) is vim
.vm
.device
.VirtualPCIPassthrough
:
3583 if device
.backing
.id in all_device_ids
:
3584 for use_device
in avalible_devices
:
3585 if use_device
.id == device
.backing
.id:
3586 avalible_devices
.remove(use_device
)
3587 used_devices_ids
.append(device
.backing
.id)
3588 self
.logger
.debug("Device {} from devices {}"\
3589 "is in use".format(device
.backing
.id,
3592 if len(avalible_devices
) < need_devices
:
3593 self
.logger
.debug("Host {} don't have {} number of active devices".format(host
,
3595 self
.logger
.debug("found only {} devives {}".format(len(avalible_devices
),
3599 required_devices
= avalible_devices
[:need_devices
]
3600 self
.logger
.info("Found {} PCI devivces on host {} but required only {}".format(
3601 len(avalible_devices
),
3604 self
.logger
.info("Retruning {} devices as {}".format(need_devices
,
3606 return required_devices
3608 except Exception as exp
:
3609 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host
))
3613 def get_host_and_PCIdevices(self
, content
, need_devices
):
3615 Method to get the details of pci devices infromation on all hosts
3618 content - vSphere host object
3619 need_devices - number of pci devices needed on host
3622 array of pci devices and host object
3625 pci_device_objs
= None
3628 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
3629 [vim
.HostSystem
], True)
3630 for host
in container
.view
:
3631 devices
= self
.get_pci_devices(host
, need_devices
)
3634 pci_device_objs
= devices
3636 except Exception as exp
:
3637 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host_obj
))
3639 return host_obj
,pci_device_objs
3641 def relocate_vm(self
, dest_host
, vm
) :
3643 Method to get the relocate VM to new host
3646 dest_host - vSphere host object
3647 vm - vSphere VM object
3654 relocate_spec
= vim
.vm
.RelocateSpec(host
=dest_host
)
3655 task
= vm
.Relocate(relocate_spec
)
3656 self
.logger
.info("Migrating {} to destination host {}".format(vm
, dest_host
))
3657 except Exception as exp
:
3658 self
.logger
.error("Error occurred while relocate VM {} to new host {}: {}".format(
3659 dest_host
, vm
, exp
))
3662 def wait_for_vcenter_task(self
, task
, actionName
='job', hideResult
=False):
3664 Waits and provides updates on a vSphere task
3666 while task
.info
.state
== vim
.TaskInfo
.State
.running
:
3669 if task
.info
.state
== vim
.TaskInfo
.State
.success
:
3670 if task
.info
.result
is not None and not hideResult
:
3671 self
.logger
.info('{} completed successfully, result: {}'.format(
3675 self
.logger
.info('Task {} completed successfully.'.format(actionName
))
3677 self
.logger
.error('{} did not complete successfully: {} '.format(
3682 return task
.info
.result
3684 def add_pci_to_vm(self
,host_object
, vm_object
, host_pci_dev
):
3686 Method to add pci device in given VM
3689 host_object - vSphere host object
3690 vm_object - vSphere VM object
3691 host_pci_dev - host_pci_dev must be one of the devices from the
3692 host_object.hardware.pciDevice list
3693 which is configured as a PCI passthrough device
3699 if vm_object
and host_object
and host_pci_dev
:
3701 #Add PCI device to VM
3702 pci_passthroughs
= vm_object
.environmentBrowser
.QueryConfigTarget(host
=None).pciPassthrough
3703 systemid_by_pciid
= {item
.pciDevice
.id: item
.systemId
for item
in pci_passthroughs
}
3705 if host_pci_dev
.id not in systemid_by_pciid
:
3706 self
.logger
.error("Device {} is not a passthrough device ".format(host_pci_dev
))
3709 deviceId
= hex(host_pci_dev
.deviceId
% 2**16).lstrip('0x')
3710 backing
= vim
.VirtualPCIPassthroughDeviceBackingInfo(deviceId
=deviceId
,
3712 systemId
=systemid_by_pciid
[host_pci_dev
.id],
3713 vendorId
=host_pci_dev
.vendorId
,
3714 deviceName
=host_pci_dev
.deviceName
)
3716 hba_object
= vim
.VirtualPCIPassthrough(key
=-100, backing
=backing
)
3718 new_device_config
= vim
.VirtualDeviceConfigSpec(device
=hba_object
)
3719 new_device_config
.operation
= "add"
3720 vmConfigSpec
= vim
.vm
.ConfigSpec()
3721 vmConfigSpec
.deviceChange
= [new_device_config
]
3723 task
= vm_object
.ReconfigVM_Task(spec
=vmConfigSpec
)
3724 self
.logger
.info("Adding PCI device {} into VM {} from host {} ".format(
3725 host_pci_dev
, vm_object
, host_object
)
3727 except Exception as exp
:
3728 self
.logger
.error("Error occurred while adding pci devive {} to VM {}: {}".format(
3734 def get_vm_vcenter_info(self
):
3736 Method to get details of vCenter and vm
3739 vapp_uuid - uuid of vApp or VM
3742 Moref Id of VM and deails of vCenter
3744 vm_vcenter_info
= {}
3746 if self
.vcenter_ip
is not None:
3747 vm_vcenter_info
["vm_vcenter_ip"] = self
.vcenter_ip
3749 raise vimconn
.vimconnException(message
="vCenter IP is not provided."\
3750 " Please provide vCenter IP while attaching datacenter to tenant in --config")
3751 if self
.vcenter_port
is not None:
3752 vm_vcenter_info
["vm_vcenter_port"] = self
.vcenter_port
3754 raise vimconn
.vimconnException(message
="vCenter port is not provided."\
3755 " Please provide vCenter port while attaching datacenter to tenant in --config")
3756 if self
.vcenter_user
is not None:
3757 vm_vcenter_info
["vm_vcenter_user"] = self
.vcenter_user
3759 raise vimconn
.vimconnException(message
="vCenter user is not provided."\
3760 " Please provide vCenter user while attaching datacenter to tenant in --config")
3762 if self
.vcenter_password
is not None:
3763 vm_vcenter_info
["vm_vcenter_password"] = self
.vcenter_password
3765 raise vimconn
.vimconnException(message
="vCenter user password is not provided."\
3766 " Please provide vCenter user password while attaching datacenter to tenant in --config")
3768 return vm_vcenter_info
3771 def get_vm_pci_details(self
, vmuuid
):
3773 Method to get VM PCI device details from vCenter
3776 vm_obj - vSphere VM object
3779 dict of PCI devives attached to VM
3782 vm_pci_devices_info
= {}
3784 vcenter_conect
, content
= self
.get_vcenter_content()
3785 vm_moref_id
= self
.get_vm_moref_id(vmuuid
)
3787 #Get VM and its host
3789 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
3790 if host_obj
and vm_obj
:
3791 vm_pci_devices_info
["host_name"]= host_obj
.name
3792 vm_pci_devices_info
["host_ip"]= host_obj
.config
.network
.vnic
[0].spec
.ip
.ipAddress
3793 for device
in vm_obj
.config
.hardware
.device
:
3794 if type(device
) == vim
.vm
.device
.VirtualPCIPassthrough
:
3795 device_details
={'devide_id':device
.backing
.id,
3796 'pciSlotNumber':device
.slotInfo
.pciSlotNumber
,
3798 vm_pci_devices_info
[device
.deviceInfo
.label
] = device_details
3800 self
.logger
.error("Can not connect to vCenter while getting "\
3801 "PCI devices infromationn")
3802 return vm_pci_devices_info
3803 except Exception as exp
:
3804 self
.logger
.error("Error occurred while getting VM infromationn"\
3805 " for VM : {}".format(exp
))
3806 raise vimconn
.vimconnException(message
=exp
)
3808 def add_network_adapter_to_vms(self
, vapp
, network_name
, primary_nic_index
, nicIndex
, net
, nic_type
=None):
3810 Method to add network adapter type to vm
3812 network_name - name of network
3813 primary_nic_index - int value for primary nic index
3814 nicIndex - int value for nic index
3815 nic_type - specify model name to which add to vm
3823 if 'floating_ip' in net
: floating_ip
= net
['floating_ip']
3825 # Stub for ip_address feature
3826 if 'ip_address' in net
: ip_address
= net
['ip_address']
3829 allocation_mode
= "POOL"
3831 allocation_mode
= "MANUAL"
3833 allocation_mode
= "DHCP"
3836 for vms
in vapp
._get
_vms
():
3837 vm_id
= (vms
.id).split(':')[-1]
3839 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.vca
.host
, vm_id
)
3841 response
= Http
.get(url
=url_rest_call
,
3842 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
3843 verify
=self
.vca
.verify
,
3844 logger
=self
.vca
.logger
)
3846 if response
.status_code
== 403:
3847 response
= self
.retry_rest('GET', url_rest_call
)
3849 if response
.status_code
!= 200:
3850 self
.logger
.error("REST call {} failed reason : {}"\
3851 "status code : {}".format(url_rest_call
,
3853 response
.status_code
))
3854 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
3855 "network connection section")
3857 data
= response
.content
3858 if '<PrimaryNetworkConnectionIndex>' not in data
:
3859 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
3860 <NetworkConnection network="{}">
3861 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
3862 <IsConnected>true</IsConnected>
3863 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
3864 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
3866 # Stub for ip_address feature
3868 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
3869 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
3871 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n'.format(item
))
3873 new_item
= """<NetworkConnection network="{}">
3874 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
3875 <IsConnected>true</IsConnected>
3876 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
3877 </NetworkConnection>""".format(network_name
, nicIndex
,
3879 # Stub for ip_address feature
3881 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
3882 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
3884 data
= data
.replace('</NetworkConnection>\n','</NetworkConnection>\n{}\n'.format(new_item
))
3886 headers
= self
.vca
.vcloud_session
.get_vcloud_headers()
3887 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
3888 response
= Http
.put(url
=url_rest_call
, headers
=headers
, data
=data
,
3889 verify
=self
.vca
.verify
,
3890 logger
=self
.vca
.logger
)
3892 if response
.status_code
== 403:
3893 add_headers
= {'Content-Type': headers
['Content-Type']}
3894 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
3896 if response
.status_code
!= 202:
3897 self
.logger
.error("REST call {} failed reason : {}"\
3898 "status code : {} ".format(url_rest_call
,
3900 response
.status_code
))
3901 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
3902 "network connection section")
3904 nic_task
= taskType
.parseString(response
.content
, True)
3905 if isinstance(nic_task
, GenericTask
):
3906 self
.vca
.block_until_completed(nic_task
)
3907 self
.logger
.info("add_network_adapter_to_vms(): VM {} conneced to "\
3908 "default NIC type".format(vm_id
))
3910 self
.logger
.error("add_network_adapter_to_vms(): VM {} failed to "\
3911 "connect NIC type".format(vm_id
))
3913 for vms
in vapp
._get
_vms
():
3914 vm_id
= (vms
.id).split(':')[-1]
3916 url_rest_call
= "{}/api/vApp/vm-{}/networkConnectionSection/".format(self
.vca
.host
, vm_id
)
3918 response
= Http
.get(url
=url_rest_call
,
3919 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
3920 verify
=self
.vca
.verify
,
3921 logger
=self
.vca
.logger
)
3923 if response
.status_code
== 403:
3924 response
= self
.retry_rest('GET', url_rest_call
)
3926 if response
.status_code
!= 200:
3927 self
.logger
.error("REST call {} failed reason : {}"\
3928 "status code : {}".format(url_rest_call
,
3930 response
.status_code
))
3931 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to get "\
3932 "network connection section")
3933 data
= response
.content
3934 if '<PrimaryNetworkConnectionIndex>' not in data
:
3935 item
= """<PrimaryNetworkConnectionIndex>{}</PrimaryNetworkConnectionIndex>
3936 <NetworkConnection network="{}">
3937 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
3938 <IsConnected>true</IsConnected>
3939 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
3940 <NetworkAdapterType>{}</NetworkAdapterType>
3941 </NetworkConnection>""".format(primary_nic_index
, network_name
, nicIndex
,
3942 allocation_mode
, nic_type
)
3943 # Stub for ip_address feature
3945 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
3946 item
= item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
3948 data
= data
.replace('</ovf:Info>\n','</ovf:Info>\n{}\n'.format(item
))
3950 new_item
= """<NetworkConnection network="{}">
3951 <NetworkConnectionIndex>{}</NetworkConnectionIndex>
3952 <IsConnected>true</IsConnected>
3953 <IpAddressAllocationMode>{}</IpAddressAllocationMode>
3954 <NetworkAdapterType>{}</NetworkAdapterType>
3955 </NetworkConnection>""".format(network_name
, nicIndex
,
3956 allocation_mode
, nic_type
)
3957 # Stub for ip_address feature
3959 ip_tag
= '<IpAddress>{}</IpAddress>'.format(ip_address
)
3960 new_item
= new_item
.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag
))
3962 data
= data
.replace('</NetworkConnection>\n','</NetworkConnection>\n{}\n'.format(new_item
))
3964 headers
= self
.vca
.vcloud_session
.get_vcloud_headers()
3965 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.networkConnectionSection+xml'
3966 response
= Http
.put(url
=url_rest_call
, headers
=headers
, data
=data
,
3967 verify
=self
.vca
.verify
,
3968 logger
=self
.vca
.logger
)
3970 if response
.status_code
== 403:
3971 add_headers
= {'Content-Type': headers
['Content-Type']}
3972 response
= self
.retry_rest('PUT', url_rest_call
, add_headers
, data
)
3974 if response
.status_code
!= 202:
3975 self
.logger
.error("REST call {} failed reason : {}"\
3976 "status code : {}".format(url_rest_call
,
3978 response
.status_code
))
3979 raise vimconn
.vimconnException("add_network_adapter_to_vms : Failed to update "\
3980 "network connection section")
3982 nic_task
= taskType
.parseString(response
.content
, True)
3983 if isinstance(nic_task
, GenericTask
):
3984 self
.vca
.block_until_completed(nic_task
)
3985 self
.logger
.info("add_network_adapter_to_vms(): VM {} "\
3986 "conneced to NIC type {}".format(vm_id
, nic_type
))
3988 self
.logger
.error("add_network_adapter_to_vms(): VM {} "\
3989 "failed to connect NIC type {}".format(vm_id
, nic_type
))
3990 except Exception as exp
:
3991 self
.logger
.error("add_network_adapter_to_vms() : exception occurred "\
3992 "while adding Network adapter")
3993 raise vimconn
.vimconnException(message
=exp
)
3996 def set_numa_affinity(self
, vmuuid
, paired_threads_id
):
3998 Method to assign numa affinity in vm configuration parammeters
4001 paired_threads_id - one or more virtual processor
4007 vm_moref_id
, vm_vcenter_host
, vm_vcenter_username
, vm_vcenter_port
= self
.get_vcenter_info_rest(vmuuid
)
4008 if vm_moref_id
and vm_vcenter_host
and vm_vcenter_username
:
4010 if hasattr(ssl
, '_create_unverified_context'):
4011 context
= ssl
._create
_unverified
_context
()
4012 vcenter_conect
= SmartConnect(host
=vm_vcenter_host
, user
=vm_vcenter_username
,
4013 pwd
=self
.passwd
, port
=int(vm_vcenter_port
),
4015 atexit
.register(Disconnect
, vcenter_conect
)
4016 content
= vcenter_conect
.RetrieveContent()
4018 host_obj
, vm_obj
= self
.get_vm_obj(content
,vm_moref_id
)
4020 config_spec
= vim
.vm
.ConfigSpec()
4021 config_spec
.extraConfig
= []
4022 opt
= vim
.option
.OptionValue()
4023 opt
.key
= 'numa.nodeAffinity'
4024 opt
.value
= str(paired_threads_id
)
4025 config_spec
.extraConfig
.append(opt
)
4026 task
= vm_obj
.ReconfigVM_Task(config_spec
)
4028 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4029 extra_config
= vm_obj
.config
.extraConfig
4031 for opts
in extra_config
:
4032 if 'numa.nodeAffinity' in opts
.key
:
4034 self
.logger
.info("set_numa_affinity: Sucessfully assign numa affinity "\
4035 "value {} for vm {}".format(opt
.value
, vm_obj
))
4039 self
.logger
.error("set_numa_affinity: Failed to assign numa affinity")
4040 except Exception as exp
:
4041 self
.logger
.error("set_numa_affinity : exception occurred while setting numa affinity "\
4042 "for VM {} : {}".format(vm_obj
, vm_moref_id
))
4043 raise vimconn
.vimconnException("set_numa_affinity : Error {} failed to assign numa "\
4044 "affinity".format(exp
))
4047 def cloud_init(self
, vapp
, cloud_config
):
4049 Method to inject ssh-key
4051 cloud_config a dictionary with:
4052 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
4053 'users': (optional) list of users to be inserted, each item is a dict with:
4054 'name': (mandatory) user name,
4055 'key-pairs': (optional) list of strings with the public key to be inserted to the user
4056 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init,
4057 or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file
4058 'config-files': (optional). List of files to be transferred. Each item is a dict with:
4059 'dest': (mandatory) string with the destination absolute path
4060 'encoding': (optional, by default text). Can be one of:
4061 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
4062 'content' (mandatory): string with the content of the file
4063 'permissions': (optional) string with file permissions, typically octal notation '0644'
4064 'owner': (optional) file owner, string with the format 'owner:group'
4065 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk
4068 if not isinstance(cloud_config
, dict):
4069 raise Exception("cloud_init : parameter cloud_config is not a dictionary")
4073 if "key-pairs" in cloud_config
:
4074 key_pairs
= cloud_config
["key-pairs"]
4076 if "users" in cloud_config
:
4077 userdata
= cloud_config
["users"]
4079 self
.logger
.debug("cloud_init : Guest os customization started..")
4080 customize_script
= self
.format_script(key_pairs
=key_pairs
, users_list
=userdata
)
4081 self
.guest_customization(vapp
, customize_script
)
4083 except Exception as exp
:
4084 self
.logger
.error("cloud_init : exception occurred while injecting "\
4086 raise vimconn
.vimconnException("cloud_init : Error {} failed to inject "\
4087 "ssh-key".format(exp
))
4089 def format_script(self
, key_pairs
=[], users_list
=[]):
4092 echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
4093 if [ "$1" = "precustomization" ];then
4094 echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
4097 keys
= "\n".join(key_pairs
)
4100 if [ ! -d /root/.ssh ];then
4102 chown root:root /root/.ssh
4103 chmod 700 /root/.ssh
4104 touch /root/.ssh/authorized_keys
4105 chown root:root /root/.ssh/authorized_keys
4106 chmod 600 /root/.ssh/authorized_keys
4107 # make centos with selinux happy
4108 which restorecon && restorecon -Rv /root/.ssh
4110 touch /root/.ssh/authorized_keys
4111 chown root:root /root/.ssh/authorized_keys
4112 chmod 600 /root/.ssh/authorized_keys
4114 echo '{key}' >> /root/.ssh/authorized_keys
4115 """.format(key
=keys
)
4117 bash_script
+= keys_data
4119 for user
in users_list
:
4120 if 'name' in user
: user_name
= user
['name']
4121 if 'key-pairs' in user
:
4122 user_keys
= "\n".join(user
['key-pairs'])
4127 useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
4128 """.format(user_name
=user_name
)
4130 bash_script
+= add_user_name
4133 user_keys_data
= """
4134 mkdir /home/{user_name}/.ssh
4135 chown {user_name}:{user_name} /home/{user_name}/.ssh
4136 chmod 700 /home/{user_name}/.ssh
4137 touch /home/{user_name}/.ssh/authorized_keys
4138 chown {user_name}:{user_name} /home/{user_name}/.ssh/authorized_keys
4139 chmod 600 /home/{user_name}/.ssh/authorized_keys
4140 # make centos with selinux happy
4141 which restorecon && restorecon -Rv /home/{user_name}/.ssh
4142 echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
4143 """.format(user_name
=user_name
,user_key
=user_keys
)
4145 bash_script
+= user_keys_data
4147 return bash_script
+"\n\tfi"
4149 def guest_customization(self
, vapp
, customize_script
):
4151 Method to customize guest os
4153 customize_script - Customize script to be run at first boot of VM.
4155 for vm
in vapp
._get
_vms
():
4157 task
= vapp
.customize_guest_os(vm_name
, customization_script
=customize_script
)
4158 if isinstance(task
, GenericTask
):
4159 self
.vca
.block_until_completed(task
)
4160 self
.logger
.info("guest_customization : customized guest os task "\
4161 "completed for VM {}".format(vm_name
))
4163 self
.logger
.error("guest_customization : task for customized guest os"\
4164 "failed for VM {}".format(vm_name
))
4165 raise vimconn
.vimconnException("guest_customization : failed to perform"\
4166 "guest os customization on VM {}".format(vm_name
))
4168 def add_new_disk(self
, vapp_uuid
, disk_size
):
4170 Method to create an empty vm disk
4173 vapp_uuid - is vapp identifier.
4174 disk_size - size of disk to be created in GB
4182 #Disk size in GB, convert it into MB
4183 if disk_size
is not None:
4184 disk_size_mb
= int(disk_size
) * 1024
4185 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
4187 if vm_details
and "vm_virtual_hardware" in vm_details
:
4188 self
.logger
.info("Adding disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
4189 disk_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
4190 status
= self
.add_new_disk_rest(disk_href
, disk_size_mb
)
4192 except Exception as exp
:
4193 msg
= "Error occurred while creating new disk {}.".format(exp
)
4194 self
.rollback_newvm(vapp_uuid
, msg
)
4197 self
.logger
.info("Added new disk to VM: {} disk size:{}GB".format(vm_details
["name"], disk_size
))
4199 #If failed to add disk, delete VM
4200 msg
= "add_new_disk: Failed to add new disk to {}".format(vm_details
["name"])
4201 self
.rollback_newvm(vapp_uuid
, msg
)
4204 def add_new_disk_rest(self
, disk_href
, disk_size_mb
):
4206 Retrives vApp Disks section & add new empty disk
4209 disk_href: Disk section href to addd disk
4210 disk_size_mb: Disk size in MB
4212 Returns: Status of add new disk task
4215 if self
.vca
.vcloud_session
and self
.vca
.vcloud_session
.organization
:
4216 response
= Http
.get(url
=disk_href
,
4217 headers
=self
.vca
.vcloud_session
.get_vcloud_headers(),
4218 verify
=self
.vca
.verify
,
4219 logger
=self
.vca
.logger
)
4221 if response
.status_code
== 403:
4222 response
= self
.retry_rest('GET', disk_href
)
4224 if response
.status_code
!= requests
.codes
.ok
:
4225 self
.logger
.error("add_new_disk_rest: GET REST API call {} failed. Return status code {}"
4226 .format(disk_href
, response
.status_code
))
4229 #Find but type & max of instance IDs assigned to disks
4230 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
4231 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
4232 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
4234 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
4235 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
4236 inst_id
= int(item
.find("rasd:InstanceID" ,namespaces
).text
)
4237 if inst_id
> instance_id
:
4238 instance_id
= inst_id
4239 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
4240 bus_subtype
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busSubType"]
4241 bus_type
= disk_item
.attrib
["{"+namespaces
['xmlns']+"}busType"]
4243 instance_id
= instance_id
+ 1
4244 new_item
= """<Item>
4245 <rasd:Description>Hard disk</rasd:Description>
4246 <rasd:ElementName>New disk</rasd:ElementName>
4248 xmlns:vcloud="http://www.vmware.com/vcloud/v1.5"
4249 vcloud:capacity="{}"
4250 vcloud:busSubType="{}"
4251 vcloud:busType="{}"></rasd:HostResource>
4252 <rasd:InstanceID>{}</rasd:InstanceID>
4253 <rasd:ResourceType>17</rasd:ResourceType>
4254 </Item>""".format(disk_size_mb
, bus_subtype
, bus_type
, instance_id
)
4256 new_data
= response
.content
4257 #Add new item at the bottom
4258 new_data
= new_data
.replace('</Item>\n</RasdItemsList>', '</Item>\n{}\n</RasdItemsList>'.format(new_item
))
4260 # Send PUT request to modify virtual hardware section with new disk
4261 headers
= self
.vca
.vcloud_session
.get_vcloud_headers()
4262 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
4264 response
= Http
.put(url
=disk_href
,
4267 verify
=self
.vca
.verify
, logger
=self
.logger
)
4269 if response
.status_code
== 403:
4270 add_headers
= {'Content-Type': headers
['Content-Type']}
4271 response
= self
.retry_rest('PUT', disk_href
, add_headers
, new_data
)
4273 if response
.status_code
!= 202:
4274 self
.logger
.error("PUT REST API call {} failed. Return status code {}. Response Content:{}"
4275 .format(disk_href
, response
.status_code
, response
.content
))
4277 add_disk_task
= taskType
.parseString(response
.content
, True)
4278 if type(add_disk_task
) is GenericTask
:
4279 status
= self
.vca
.block_until_completed(add_disk_task
)
4281 self
.logger
.error("Add new disk REST task failed to add {} MB disk".format(disk_size_mb
))
4283 except Exception as exp
:
4284 self
.logger
.error("Error occurred calling rest api for creating new disk {}".format(exp
))
4289 def add_existing_disk(self
, catalogs
=None, image_id
=None, size
=None, template_name
=None, vapp_uuid
=None):
4291 Method to add existing disk to vm
4293 catalogs - List of VDC catalogs
4294 image_id - Catalog ID
4295 template_name - Name of template in catalog
4296 vapp_uuid - UUID of vApp
4301 vcenter_conect
, content
= self
.get_vcenter_content()
4302 #find moref-id of vm in image
4303 catalog_vm_info
= self
.get_vapp_template_details(catalogs
=catalogs
,
4307 if catalog_vm_info
and "vm_vcenter_info" in catalog_vm_info
:
4308 if "vm_moref_id" in catalog_vm_info
["vm_vcenter_info"]:
4309 catalog_vm_moref_id
= catalog_vm_info
["vm_vcenter_info"].get("vm_moref_id", None)
4310 if catalog_vm_moref_id
:
4311 self
.logger
.info("Moref_id of VM in catalog : {}" .format(catalog_vm_moref_id
))
4312 host
, catalog_vm_obj
= self
.get_vm_obj(content
, catalog_vm_moref_id
)
4315 disk_info
= self
.find_disk(catalog_vm_obj
)
4317 exp_msg
= "No VM with image id {} found".format(image_id
)
4318 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
4320 exp_msg
= "No Image found with image ID {} ".format(image_id
)
4321 self
.rollback_newvm(vapp_uuid
, exp_msg
, exp_type
="NotFound")
4324 self
.logger
.info("Existing disk_info : {}".format(disk_info
))
4326 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
4327 host
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4329 status
= self
.add_disk(vcenter_conect
=vcenter_conect
,
4331 disk_info
=disk_info
,
4336 self
.logger
.info("Disk from image id {} added to {}".format(image_id
,
4340 msg
= "No disk found with image id {} to add in VM {}".format(
4343 self
.rollback_newvm(vapp_uuid
, msg
, exp_type
="NotFound")
4346 def find_disk(self
, vm_obj
):
4348 Method to find details of existing disk in VM
4350 vm_obj - vCenter object of VM
4351 image_id - Catalog ID
4353 disk_info : dict of disk details
4358 devices
= vm_obj
.config
.hardware
.device
4359 for device
in devices
:
4360 if type(device
) is vim
.vm
.device
.VirtualDisk
:
4361 if isinstance(device
.backing
,vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo
) and hasattr(device
.backing
, 'fileName'):
4362 disk_info
["full_path"] = device
.backing
.fileName
4363 disk_info
["datastore"] = device
.backing
.datastore
4364 disk_info
["capacityKB"] = device
.capacityInKB
4366 except Exception as exp
:
4367 self
.logger
.error("find_disk() : exception occurred while "\
4368 "getting existing disk details :{}".format(exp
))
4372 def add_disk(self
, vcenter_conect
=None, vm
=None, size
=None, vapp_uuid
=None, disk_info
={}):
4374 Method to add existing disk in VM
4376 vcenter_conect - vCenter content object
4377 vm - vCenter vm object
4378 disk_info : dict of disk details
4380 status : status of add disk task
4382 datastore
= disk_info
["datastore"] if "datastore" in disk_info
else None
4383 fullpath
= disk_info
["full_path"] if "full_path" in disk_info
else None
4384 capacityKB
= disk_info
["capacityKB"] if "capacityKB" in disk_info
else None
4385 if size
is not None:
4386 #Convert size from GB to KB
4387 sizeKB
= int(size
) * 1024 * 1024
4388 #compare size of existing disk and user given size.Assign whicherver is greater
4389 self
.logger
.info("Add Existing disk : sizeKB {} , capacityKB {}".format(
4390 sizeKB
, capacityKB
))
4391 if sizeKB
> capacityKB
:
4394 if datastore
and fullpath
and capacityKB
:
4396 spec
= vim
.vm
.ConfigSpec()
4397 # get all disks on a VM, set unit_number to the next available
4399 for dev
in vm
.config
.hardware
.device
:
4400 if hasattr(dev
.backing
, 'fileName'):
4401 unit_number
= int(dev
.unitNumber
) + 1
4402 # unit_number 7 reserved for scsi controller
4403 if unit_number
== 7:
4405 if isinstance(dev
, vim
.vm
.device
.VirtualDisk
):
4406 #vim.vm.device.VirtualSCSIController
4407 controller_key
= dev
.controllerKey
4409 self
.logger
.info("Add Existing disk : unit number {} , controller key {}".format(
4410 unit_number
, controller_key
))
4413 disk_spec
= vim
.vm
.device
.VirtualDeviceSpec()
4414 disk_spec
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
4415 disk_spec
.device
= vim
.vm
.device
.VirtualDisk()
4416 disk_spec
.device
.backing
= \
4417 vim
.vm
.device
.VirtualDisk
.FlatVer2BackingInfo()
4418 disk_spec
.device
.backing
.thinProvisioned
= True
4419 disk_spec
.device
.backing
.diskMode
= 'persistent'
4420 disk_spec
.device
.backing
.datastore
= datastore
4421 disk_spec
.device
.backing
.fileName
= fullpath
4423 disk_spec
.device
.unitNumber
= unit_number
4424 disk_spec
.device
.capacityInKB
= capacityKB
4425 disk_spec
.device
.controllerKey
= controller_key
4426 dev_changes
.append(disk_spec
)
4427 spec
.deviceChange
= dev_changes
4428 task
= vm
.ReconfigVM_Task(spec
=spec
)
4429 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4431 except Exception as exp
:
4432 exp_msg
= "add_disk() : exception {} occurred while adding disk "\
4433 "{} to vm {}".format(exp
,
4436 self
.rollback_newvm(vapp_uuid
, exp_msg
)
4438 msg
= "add_disk() : Can not add disk to VM with disk info {} ".format(disk_info
)
4439 self
.rollback_newvm(vapp_uuid
, msg
)
4442 def get_vcenter_content(self
):
4444 Get the vsphere content object
4447 vm_vcenter_info
= self
.get_vm_vcenter_info()
4448 except Exception as exp
:
4449 self
.logger
.error("Error occurred while getting vCenter infromationn"\
4450 " for VM : {}".format(exp
))
4451 raise vimconn
.vimconnException(message
=exp
)
4454 if hasattr(ssl
, '_create_unverified_context'):
4455 context
= ssl
._create
_unverified
_context
()
4457 vcenter_conect
= SmartConnect(
4458 host
=vm_vcenter_info
["vm_vcenter_ip"],
4459 user
=vm_vcenter_info
["vm_vcenter_user"],
4460 pwd
=vm_vcenter_info
["vm_vcenter_password"],
4461 port
=int(vm_vcenter_info
["vm_vcenter_port"]),
4464 atexit
.register(Disconnect
, vcenter_conect
)
4465 content
= vcenter_conect
.RetrieveContent()
4466 return vcenter_conect
, content
4469 def get_vm_moref_id(self
, vapp_uuid
):
4471 Get the moref_id of given VM
4475 vm_details
= self
.get_vapp_details_rest(vapp_uuid
, need_admin_access
=True)
4476 if vm_details
and "vm_vcenter_info" in vm_details
:
4477 vm_moref_id
= vm_details
["vm_vcenter_info"].get("vm_moref_id", None)
4481 except Exception as exp
:
4482 self
.logger
.error("Error occurred while getting VM moref ID "\
4483 " for VM : {}".format(exp
))
4487 def get_vapp_template_details(self
, catalogs
=None, image_id
=None , template_name
=None):
4489 Method to get vApp template details
4491 catalogs - list of VDC catalogs
4492 image_id - Catalog ID to find
4493 template_name : template name in catalog
4495 parsed_respond : dict of vApp tempalte details
4497 parsed_response
= {}
4499 vca
= self
.connect_as_admin()
4501 raise vimconn
.vimconnConnectionException("self.connect() is failed")
4504 catalog
= self
.get_catalog_obj(image_id
, catalogs
)
4506 template_name
= self
.get_catalogbyid(image_id
, catalogs
)
4507 catalog_items
= filter(lambda catalogItemRef
: catalogItemRef
.get_name() == template_name
, catalog
.get_CatalogItems().get_CatalogItem())
4508 if len(catalog_items
) == 1:
4509 response
= Http
.get(catalog_items
[0].get_href(),
4510 headers
=vca
.vcloud_session
.get_vcloud_headers(),
4513 catalogItem
= XmlElementTree
.fromstring(response
.content
)
4514 entity
= [child
for child
in catalogItem
if child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
4515 vapp_tempalte_href
= entity
.get("href")
4516 #get vapp details and parse moref id
4518 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
4519 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
4520 'vmw': 'http://www.vmware.com/schema/ovf',
4521 'vm': 'http://www.vmware.com/vcloud/v1.5',
4522 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
4523 'vmext':"http://www.vmware.com/vcloud/extension/v1.5",
4524 'xmlns':"http://www.vmware.com/vcloud/v1.5"
4527 if vca
.vcloud_session
and vca
.vcloud_session
.organization
:
4528 response
= Http
.get(url
=vapp_tempalte_href
,
4529 headers
=vca
.vcloud_session
.get_vcloud_headers(),
4534 if response
.status_code
!= requests
.codes
.ok
:
4535 self
.logger
.debug("REST API call {} failed. Return status code {}".format(
4536 vapp_tempalte_href
, response
.status_code
))
4539 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
4540 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
4541 if children_section
is not None:
4542 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
4543 if vCloud_extension_section
is not None:
4544 vm_vcenter_info
= {}
4545 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
4546 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
4547 if vmext
is not None:
4548 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
4549 parsed_response
["vm_vcenter_info"]= vm_vcenter_info
4551 except Exception as exp
:
4552 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
4554 return parsed_response
4557 def rollback_newvm(self
, vapp_uuid
, msg
, exp_type
="Genric"):
4559 Method to delete vApp
4561 vapp_uuid - vApp UUID
4562 msg - Error message to be logged
4563 exp_type : Exception type
4568 status
= self
.delete_vminstance(vapp_uuid
)
4571 self
.logger
.error(msg
)
4572 if exp_type
== "Genric":
4573 raise vimconn
.vimconnException(msg
)
4574 elif exp_type
== "NotFound":
4575 raise vimconn
.vimconnNotFoundException(message
=msg
)
4577 def add_sriov(self
, vapp_uuid
, sriov_nets
, vmname_andid
):
4579 Method to attach SRIOV adapters to VM
4582 vapp_uuid - uuid of vApp/VM
4583 sriov_nets - SRIOV devices infromation as specified in VNFD (flavor)
4584 vmname_andid - vmname
4587 The status of add SRIOV adapter task , vm object and
4588 vcenter_conect object
4591 vcenter_conect
, content
= self
.get_vcenter_content()
4592 vm_moref_id
= self
.get_vm_moref_id(vapp_uuid
)
4596 no_of_sriov_devices
= len(sriov_nets
)
4597 if no_of_sriov_devices
> 0:
4598 #Get VM and its host
4599 host_obj
, vm_obj
= self
.get_vm_obj(content
, vm_moref_id
)
4600 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
4601 if host_obj
and vm_obj
:
4602 #get SRIOV devies from host on which vapp is currently installed
4603 avilable_sriov_devices
= self
.get_sriov_devices(host_obj
,
4604 no_of_sriov_devices
,
4607 if len(avilable_sriov_devices
) == 0:
4608 #find other hosts with active pci devices
4609 new_host_obj
, avilable_sriov_devices
= self
.get_host_and_sriov_devices(
4611 no_of_sriov_devices
,
4614 if new_host_obj
is not None and len(avilable_sriov_devices
)> 0:
4615 #Migrate vm to the host where SRIOV devices are available
4616 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
,
4618 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
4619 if task
is not None:
4620 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4621 self
.logger
.info("Migrate VM status: {}".format(result
))
4622 host_obj
= new_host_obj
4624 self
.logger
.info("Fail to migrate VM : {}".format(result
))
4625 raise vimconn
.vimconnNotFoundException(
4626 "Fail to migrate VM : {} to host {}".format(
4631 if host_obj
is not None and avilable_sriov_devices
is not None and len(avilable_sriov_devices
)> 0:
4632 #Add SRIOV devices one by one
4633 for sriov_net
in sriov_nets
:
4634 network_name
= sriov_net
.get('net_id')
4635 dvs_portgr_name
= self
.create_dvPort_group(network_name
)
4636 if sriov_net
.get('type') == "VF":
4637 #add vlan ID ,Modify portgroup for vlan ID
4638 self
.configure_vlanID(content
, vcenter_conect
, network_name
)
4640 task
= self
.add_sriov_to_vm(content
,
4644 avilable_sriov_devices
[0]
4647 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4649 self
.logger
.info("Added SRIOV {} to VM {}".format(
4650 no_of_sriov_devices
,
4653 self
.logger
.error("Fail to add SRIOV {} to VM {}".format(
4654 no_of_sriov_devices
,
4656 raise vimconn
.vimconnUnexpectedResponse(
4657 "Fail to add SRIOV adapter in VM ".format(str(vm_obj
))
4659 return True, vm_obj
, vcenter_conect
4661 self
.logger
.error("Currently there is no host with"\
4662 " {} number of avaialble SRIOV "\
4663 "VFs required for VM {}".format(
4664 no_of_sriov_devices
,
4667 raise vimconn
.vimconnNotFoundException(
4668 "Currently there is no host with {} "\
4669 "number of avaialble SRIOV devices required for VM {}".format(
4670 no_of_sriov_devices
,
4673 self
.logger
.debug("No infromation about SRIOV devices {} ",sriov_nets
)
4675 except vmodl
.MethodFault
as error
:
4676 self
.logger
.error("Error occurred while adding SRIOV {} ",error
)
4677 return None, vm_obj
, vcenter_conect
4680 def get_sriov_devices(self
,host
, no_of_vfs
):
4682 Method to get the details of SRIOV devices on given host
4684 host - vSphere host object
4685 no_of_vfs - number of VFs needed on host
4688 array of SRIOV devices
4692 for device
in host
.config
.pciPassthruInfo
:
4693 if isinstance(device
,vim
.host
.SriovInfo
) and device
.sriovActive
:
4694 if device
.numVirtualFunction
>= no_of_vfs
:
4695 sriovInfo
.append(device
)
4700 def get_host_and_sriov_devices(self
, content
, no_of_vfs
):
4702 Method to get the details of SRIOV devices infromation on all hosts
4705 content - vSphere host object
4706 no_of_vfs - number of pci VFs needed on host
4709 array of SRIOV devices and host object
4712 sriov_device_objs
= None
4715 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
4716 [vim
.HostSystem
], True)
4717 for host
in container
.view
:
4718 devices
= self
.get_sriov_devices(host
, no_of_vfs
)
4721 sriov_device_objs
= devices
4723 except Exception as exp
:
4724 self
.logger
.error("Error {} occurred while finding SRIOV devices on host: {}".format(exp
, host_obj
))
4726 return host_obj
,sriov_device_objs
4729 def add_sriov_to_vm(self
,content
, vm_obj
, host_obj
, network_name
, sriov_device
):
4731 Method to add SRIOV adapter to vm
4734 host_obj - vSphere host object
4735 vm_obj - vSphere vm object
4736 content - vCenter content object
4737 network_name - name of distributed virtaul portgroup
4738 sriov_device - SRIOV device info
4744 vnic_label
= "sriov nic"
4746 dvs_portgr
= self
.get_dvport_group(network_name
)
4747 network_name
= dvs_portgr
.name
4748 nic
= vim
.vm
.device
.VirtualDeviceSpec()
4750 nic
.operation
= vim
.vm
.device
.VirtualDeviceSpec
.Operation
.add
4751 nic
.device
= vim
.vm
.device
.VirtualSriovEthernetCard()
4752 nic
.device
.addressType
= 'assigned'
4753 #nic.device.key = 13016
4754 nic
.device
.deviceInfo
= vim
.Description()
4755 nic
.device
.deviceInfo
.label
= vnic_label
4756 nic
.device
.deviceInfo
.summary
= network_name
4757 nic
.device
.backing
= vim
.vm
.device
.VirtualEthernetCard
.NetworkBackingInfo()
4759 nic
.device
.backing
.network
= self
.get_obj(content
, [vim
.Network
], network_name
)
4760 nic
.device
.backing
.deviceName
= network_name
4761 nic
.device
.backing
.useAutoDetect
= False
4762 nic
.device
.connectable
= vim
.vm
.device
.VirtualDevice
.ConnectInfo()
4763 nic
.device
.connectable
.startConnected
= True
4764 nic
.device
.connectable
.allowGuestControl
= True
4766 nic
.device
.sriovBacking
= vim
.vm
.device
.VirtualSriovEthernetCard
.SriovBackingInfo()
4767 nic
.device
.sriovBacking
.physicalFunctionBacking
= vim
.vm
.device
.VirtualPCIPassthrough
.DeviceBackingInfo()
4768 nic
.device
.sriovBacking
.physicalFunctionBacking
.id = sriov_device
.id
4771 vmconf
= vim
.vm
.ConfigSpec(deviceChange
=devices
)
4772 task
= vm_obj
.ReconfigVM_Task(vmconf
)
4774 except Exception as exp
:
4775 self
.logger
.error("Error {} occurred while adding SRIOV adapter in VM: {}".format(exp
, vm_obj
))
4779 def create_dvPort_group(self
, network_name
):
4781 Method to create disributed virtual portgroup
4784 network_name - name of network/portgroup
4790 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
4791 network_name
=''.join(new_network_name
)
4792 vcenter_conect
, content
= self
.get_vcenter_content()
4794 dv_switch
= self
.get_obj(content
, [vim
.DistributedVirtualSwitch
], self
.dvs_name
)
4796 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
4797 dv_pg_spec
.name
= network_name
4799 dv_pg_spec
.type = vim
.dvs
.DistributedVirtualPortgroup
.PortgroupType
.earlyBinding
4800 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
4801 dv_pg_spec
.defaultPortConfig
.securityPolicy
= vim
.dvs
.VmwareDistributedVirtualSwitch
.SecurityPolicy()
4802 dv_pg_spec
.defaultPortConfig
.securityPolicy
.allowPromiscuous
= vim
.BoolPolicy(value
=False)
4803 dv_pg_spec
.defaultPortConfig
.securityPolicy
.forgedTransmits
= vim
.BoolPolicy(value
=False)
4804 dv_pg_spec
.defaultPortConfig
.securityPolicy
.macChanges
= vim
.BoolPolicy(value
=False)
4806 task
= dv_switch
.AddDVPortgroup_Task([dv_pg_spec
])
4807 self
.wait_for_vcenter_task(task
, vcenter_conect
)
4809 dvPort_group
= self
.get_obj(content
, [vim
.dvs
.DistributedVirtualPortgroup
], network_name
)
4811 self
.logger
.info("Created disributed virtaul port group: {}".format(dvPort_group
))
4812 return dvPort_group
.key
4814 self
.logger
.debug("No disributed virtual switch found with name {}".format(network_name
))
4816 except Exception as exp
:
4817 self
.logger
.error("Error occurred while creating disributed virtaul port group {}"\
4818 " : {}".format(network_name
, exp
))
4821 def reconfig_portgroup(self
, content
, dvPort_group_name
, config_info
={}):
4823 Method to reconfigure disributed virtual portgroup
4826 dvPort_group_name - name of disributed virtual portgroup
4827 content - vCenter content object
4828 config_info - disributed virtual portgroup configuration
4834 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
4836 dv_pg_spec
= vim
.dvs
.DistributedVirtualPortgroup
.ConfigSpec()
4837 dv_pg_spec
.configVersion
= dvPort_group
.config
.configVersion
4838 dv_pg_spec
.defaultPortConfig
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VmwarePortConfigPolicy()
4839 if "vlanID" in config_info
:
4840 dv_pg_spec
.defaultPortConfig
.vlan
= vim
.dvs
.VmwareDistributedVirtualSwitch
.VlanIdSpec()
4841 dv_pg_spec
.defaultPortConfig
.vlan
.vlanId
= config_info
.get('vlanID')
4843 task
= dvPort_group
.ReconfigureDVPortgroup_Task(spec
=dv_pg_spec
)
4847 except Exception as exp
:
4848 self
.logger
.error("Error occurred while reconfiguraing disributed virtaul port group {}"\
4849 " : {}".format(dvPort_group_name
, exp
))
4853 def destroy_dvport_group(self
, dvPort_group_name
):
4855 Method to destroy disributed virtual portgroup
4858 network_name - name of network/portgroup
4861 True if portgroup successfully got deleted else false
4863 vcenter_conect
, content
= self
.get_vcenter_content()
4866 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
4868 task
= dvPort_group
.Destroy_Task()
4869 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4871 except vmodl
.MethodFault
as exp
:
4872 self
.logger
.error("Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
4873 exp
, dvPort_group_name
))
4877 def get_dvport_group(self
, dvPort_group_name
):
4879 Method to get disributed virtual portgroup
4882 network_name - name of network/portgroup
4887 vcenter_conect
, content
= self
.get_vcenter_content()
4890 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, [vim
.dvs
.DistributedVirtualPortgroup
], True)
4891 for item
in container
.view
:
4892 if item
.key
== dvPort_group_name
:
4896 except vmodl
.MethodFault
as exp
:
4897 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
4898 exp
, dvPort_group_name
))
4901 def get_vlanID_from_dvs_portgr(self
, dvPort_group_name
):
4903 Method to get disributed virtual portgroup vlanID
4906 network_name - name of network/portgroup
4913 dvPort_group
= self
.get_dvport_group(dvPort_group_name
)
4915 vlanId
= dvPort_group
.config
.defaultPortConfig
.vlan
.vlanId
4916 except vmodl
.MethodFault
as exp
:
4917 self
.logger
.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
4918 exp
, dvPort_group_name
))
4922 def configure_vlanID(self
, content
, vcenter_conect
, dvPort_group_name
):
4924 Method to configure vlanID in disributed virtual portgroup vlanID
4927 network_name - name of network/portgroup
4932 vlanID
= self
.get_vlanID_from_dvs_portgr(dvPort_group_name
)
4935 vlanID
= self
.genrate_vlanID(dvPort_group_name
)
4936 config
= {"vlanID":vlanID
}
4937 task
= self
.reconfig_portgroup(content
, dvPort_group_name
,
4940 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
4942 self
.logger
.info("Reconfigured Port group {} for vlan ID {}".format(
4943 dvPort_group_name
,vlanID
))
4945 self
.logger
.error("Fail reconfigure portgroup {} for vlanID{}".format(
4946 dvPort_group_name
, vlanID
))
4949 def genrate_vlanID(self
, network_name
):
4951 Method to get unused vlanID
4953 network_name - name of network/portgroup
4959 if self
.config
.get('vlanID_range') == None:
4960 raise vimconn
.vimconnConflictException("You must provide a 'vlanID_range' "\
4961 "at config value before creating sriov network with vlan tag")
4962 if "used_vlanIDs" not in self
.persistent_info
:
4963 self
.persistent_info
["used_vlanIDs"] = {}
4965 used_ids
= self
.persistent_info
["used_vlanIDs"].values()
4967 for vlanID_range
in self
.config
.get('vlanID_range'):
4968 start_vlanid
, end_vlanid
= vlanID_range
.split("-")
4969 if start_vlanid
> end_vlanid
:
4970 raise vimconn
.vimconnConflictException("Invalid vlan ID range {}".format(
4973 for id in xrange(int(start_vlanid
), int(end_vlanid
) + 1):
4974 if id not in used_ids
:
4976 self
.persistent_info
["used_vlanIDs"][network_name
] = vlan_id
4979 raise vimconn
.vimconnConflictException("All Vlan IDs are in use")
4982 def get_obj(self
, content
, vimtype
, name
):
4984 Get the vsphere object associated with a given text name
4987 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
, vimtype
, True)
4988 for item
in container
.view
:
4989 if item
.name
== name
:
4995 def insert_media_to_vm(self
, vapp
, image_id
):
4997 Method to insert media CD-ROM (ISO image) from catalog to vm.
4998 vapp - vapp object to get vm id
4999 Image_id - image id for cdrom to be inerted to vm
5001 # create connection object
5002 vca
= self
.connect()
5004 # fetching catalog details
5005 rest_url
= "{}/api/catalog/{}".format(vca
.host
,image_id
)
5006 response
= Http
.get(url
=rest_url
,
5007 headers
=vca
.vcloud_session
.get_vcloud_headers(),
5011 if response
.status_code
!= 200:
5012 self
.logger
.error("REST call {} failed reason : {}"\
5013 "status code : {}".format(url_rest_call
,
5015 response
.status_code
))
5016 raise vimconn
.vimconnException("insert_media_to_vm(): Failed to get "\
5018 # searching iso name and id
5019 iso_name
,media_id
= self
.get_media_details(vca
, response
.content
)
5021 if iso_name
and media_id
:
5022 data
="""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
5023 <ns6:MediaInsertOrEjectParams
5024 xmlns="http://www.vmware.com/vcloud/versions" xmlns:ns2="http://schemas.dmtf.org/ovf/envelope/1" xmlns:ns3="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/common" xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" xmlns:ns6="http://www.vmware.com/vcloud/v1.5" xmlns:ns7="http://www.vmware.com/schema/ovf" xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1" xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">
5026 type="application/vnd.vmware.vcloud.media+xml"
5028 id="urn:vcloud:media:{}"
5029 href="https://{}/api/media/{}"/>
5030 </ns6:MediaInsertOrEjectParams>""".format(iso_name
, media_id
,
5033 for vms
in vapp
._get
_vms
():
5034 vm_id
= (vms
.id).split(':')[-1]
5036 headers
= vca
.vcloud_session
.get_vcloud_headers()
5037 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.mediaInsertOrEjectParams+xml'
5038 rest_url
= "{}/api/vApp/vm-{}/media/action/insertMedia".format(vca
.host
,vm_id
)
5040 response
= Http
.post(url
=rest_url
,
5046 if response
.status_code
!= 202:
5047 self
.logger
.error("Failed to insert CD-ROM to vm")
5048 raise vimconn
.vimconnException("insert_media_to_vm() : Failed to insert"\
5051 task
= taskType
.parseString(response
.content
, True)
5052 if isinstance(task
, GenericTask
):
5053 vca
.block_until_completed(task
)
5054 self
.logger
.info("insert_media_to_vm(): Sucessfully inserted media ISO"\
5055 " image to vm {}".format(vm_id
))
5056 except Exception as exp
:
5057 self
.logger
.error("insert_media_to_vm() : exception occurred "\
5058 "while inserting media CD-ROM")
5059 raise vimconn
.vimconnException(message
=exp
)
5062 def get_media_details(self
, vca
, content
):
5064 Method to get catalog item details
5065 vca - connection object
5066 content - Catalog details
5067 Return - Media name, media id
5069 cataloghref_list
= []
5072 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
5073 for child
in vm_list_xmlroot
.iter():
5074 if 'CatalogItem' in child
.tag
:
5075 cataloghref_list
.append(child
.attrib
.get('href'))
5076 if cataloghref_list
is not None:
5077 for href
in cataloghref_list
:
5079 response
= Http
.get(url
=href
,
5080 headers
=vca
.vcloud_session
.get_vcloud_headers(),
5083 if response
.status_code
!= 200:
5084 self
.logger
.error("REST call {} failed reason : {}"\
5085 "status code : {}".format(href
,
5087 response
.status_code
))
5088 raise vimconn
.vimconnException("get_media_details : Failed to get "\
5089 "catalogitem details")
5090 list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
5091 for child
in list_xmlroot
.iter():
5092 if 'Entity' in child
.tag
:
5093 if 'media' in child
.attrib
.get('href'):
5094 name
= child
.attrib
.get('name')
5095 media_id
= child
.attrib
.get('href').split('/').pop()
5096 return name
,media_id
5098 self
.logger
.debug("Media name and id not found")
5100 except Exception as exp
:
5101 self
.logger
.error("get_media_details : exception occurred "\
5102 "getting media details")
5103 raise vimconn
.vimconnException(message
=exp
)
5106 def retry_rest(self
, method
, url
, add_headers
=None, data
=None):
5107 """ Method to get Token & retry respective REST request
5109 api - REST API - Can be one of 'GET' or 'PUT' or 'POST'
5110 url - request url to be used
5111 add_headers - Additional headers (optional)
5112 data - Request payload data to be passed in request
5114 response - Response of request
5121 headers
=self
.vca
.vcloud_session
.get_vcloud_headers()
5124 headers
.update(add_headers
)
5127 response
= Http
.get(url
=url
,
5129 verify
=self
.vca
.verify
,
5130 logger
=self
.vca
.logger
)
5131 elif method
== 'PUT':
5132 response
= Http
.put(url
=url
,
5135 verify
=self
.vca
.verify
,
5137 elif method
== 'POST':
5138 response
= Http
.post(url
=url
,
5141 verify
=self
.vca
.verify
,
5142 logger
=self
.vca
.logger
)
5143 elif method
== 'DELETE':
5144 response
= Http
.delete(url
=url
,
5146 verify
=self
.vca
.verify
,
5147 logger
=self
.vca
.logger
)
5151 def get_token(self
):
5152 """ Generate a new token if expired
5155 The return vca object that letter can be used to connect to vCloud director as admin for VDC
5160 self
.logger
.debug("Generate token for vca {} as {} to datacenter {}.".format(self
.org_name
,
5163 vca
= VCA(host
=self
.url
,
5165 service_type
=STANDALONE
,
5170 result
= vca
.login(password
=self
.passwd
, org
=self
.org_name
)
5172 result
= vca
.login(token
=vca
.token
, org
=self
.org_name
, org_url
=vca
.vcloud_session
.org_url
)
5175 "Successfully generated token for vcloud direct org: {} as user: {}".format(self
.org_name
, self
.user
))
5181 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
5182 "{} as user: {}".format(self
.org_name
, self
.user
))
5184 if not vca
or not result
:
5185 raise vimconn
.vimconnConnectionException("self.connect() is failed while reconnecting")
5188 def get_vdc_details(self
):
5189 """ Get VDC details using pyVcloud Lib
5193 vdc
= self
.vca
.get_vdc(self
.tenant_name
)
5195 #Retry once, if failed by refreshing token
5198 vdc
= self
.vca
.get_vdc(self
.tenant_name
)