1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
5 # This file is part of openmano
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 with: nfvlabs@tid.es
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
67 # global variable for vcd connector type
68 STANDALONE
= 'standalone'
70 # key for flavor dicts
71 FLAVOR_RAM_KEY
= 'ram'
72 FLAVOR_VCPUS_KEY
= 'vcpus'
73 FLAVOR_DISK_KEY
= 'disk'
74 DEFAULT_IP_PROFILE
= {'gateway_address':"192.168.1.1",
76 'subnet_address':"192.168.1.0/24",
78 'dhcp_start_address':"192.168.1.3",
80 'dns_address':"192.168.1.2"
82 # global variable for wait time
88 __author__
= "Mustafa Bayramov, Arpita Kate, Sachin Bhangare"
89 __date__
= "$12-Jan-2017 11:09:29$"
92 # -1: "Could not be created",
98 # 5: "Waiting for user input",
100 # 7: "Unrecognized state",
102 # 9: "Inconsistent state",
103 # 10: "Children do not all have the same status",
104 # 11: "Upload initiated, OVF descriptor pending",
105 # 12: "Upload initiated, copying contents",
106 # 13: "Upload initiated , disk contents pending",
107 # 14: "Upload has been quarantined",
108 # 15: "Upload quarantine period has expired"
110 # mapping vCD status to MANO
111 vcdStatusCode2manoFormat
= {4: 'ACTIVE',
120 netStatus2manoFormat
= {'ACTIVE': 'ACTIVE', 'PAUSED': 'PAUSED', 'INACTIVE': 'INACTIVE', 'BUILD': 'BUILD',
121 'ERROR': 'ERROR', 'DELETED': 'DELETED'
124 # dict used to store flavor in memory
128 class vimconnector(vimconn
.vimconnector
):
129 def __init__(self
, uuid
=None, name
=None, tenant_id
=None, tenant_name
=None,
130 url
=None, url_admin
=None, user
=None, passwd
=None, log_level
=None, config
={}):
132 Constructor create vmware connector to vCloud director.
134 By default construct doesn't validate connection state. So client can create object with None arguments.
135 If client specified username , password and host and VDC name. Connector initialize other missing attributes.
137 a) It initialize organization UUID
138 b) Initialize tenant_id/vdc ID. (This information derived from tenant name)
141 uuid - is organization uuid.
142 name - is organization name that must be presented in vCloud director.
143 tenant_id - is VDC uuid it must be presented in vCloud director
144 tenant_name - is VDC name.
145 url - is hostname or ip address of vCloud director
146 url_admin - same as above.
147 user - is user that administrator for organization. Caller must make sure that
148 username has right privileges.
150 password - is password for a user.
152 VMware connector also requires PVDC administrative privileges and separate account.
153 This variables must be passed via config argument dict contains keys
155 dict['admin_username']
156 dict['admin_password']
162 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
,
163 url_admin
, user
, passwd
, log_level
, config
)
165 self
.logger
= logging
.getLogger('openmano.vim.vmware')
166 self
.logger
.setLevel(10)
171 self
.url_admin
= url_admin
172 self
.tenant_id
= tenant_id
173 self
.tenant_name
= tenant_name
177 self
.admin_password
= None
178 self
.admin_user
= None
180 self
.nsx_manager
= None
182 self
.nsx_password
= None
184 if tenant_name
is not None:
185 orgnameandtenant
= tenant_name
.split(":")
186 if len(orgnameandtenant
) == 2:
187 self
.tenant_name
= orgnameandtenant
[1]
188 self
.org_name
= orgnameandtenant
[0]
190 self
.tenant_name
= tenant_name
191 if "orgname" in config
:
192 self
.org_name
= config
['orgname']
195 self
.logger
.setLevel(getattr(logging
, log_level
))
198 self
.admin_user
= config
['admin_username']
199 self
.admin_password
= config
['admin_password']
201 raise vimconn
.vimconnException(message
="Error admin username or admin password is empty.")
204 self
.nsx_manager
= config
['nsx_manager']
205 self
.nsx_user
= config
['nsx_user']
206 self
.nsx_password
= config
['nsx_password']
208 raise vimconn
.vimconnException(message
="Error: nsx manager or nsx user or nsx password is empty in Config")
214 raise vimconn
.vimconnException('url param can not be NoneType')
216 if not self
.url_admin
: # try to use normal url
217 self
.url_admin
= self
.url
219 logging
.debug("UUID: {} name: {} tenant_id: {} tenant name {}".format(self
.id, self
.org_name
,
220 self
.tenant_id
, self
.tenant_name
))
221 logging
.debug("vcd url {} vcd username: {} vcd password: {}".format(self
.url
, self
.user
, self
.passwd
))
222 logging
.debug("vcd admin username {} vcd admin passowrd {}".format(self
.admin_user
, self
.admin_password
))
224 # initialize organization
225 if self
.user
is not None and self
.passwd
is not None and self
.url
:
226 self
.init_organization()
228 def __getitem__(self
, index
):
231 if index
== 'tenant_id':
232 return self
.tenant_id
233 if index
== 'tenant_name':
234 return self
.tenant_name
237 elif index
== 'org_name':
239 elif index
== 'org_uuid':
241 elif index
== 'user':
243 elif index
== 'passwd':
247 elif index
== 'url_admin':
248 return self
.url_admin
249 elif index
== "config":
252 raise KeyError("Invalid key '%s'" % str(index
))
254 def __setitem__(self
, index
, value
):
257 if index
== 'tenant_id':
258 self
.tenant_id
= value
259 if index
== 'tenant_name':
260 self
.tenant_name
= value
263 elif index
== 'org_name':
264 self
.org_name
= value
265 elif index
== 'org_uuid':
266 self
.org_uuid
= value
267 elif index
== 'user':
269 elif index
== 'passwd':
273 elif index
== 'url_admin':
274 self
.url_admin
= value
276 raise KeyError("Invalid key '%s'" % str(index
))
278 def connect_as_admin(self
):
279 """ Method connect as pvdc admin user to vCloud director.
280 There are certain action that can be done only by provider vdc admin user.
281 Organization creation / provider network creation etc.
284 The return vca object that letter can be used to connect to vcloud direct as admin for provider vdc
287 self
.logger
.debug("Logging in to a vca {} as admin.".format(self
.org_name
))
289 vca_admin
= VCA(host
=self
.url
,
290 username
=self
.admin_user
,
291 service_type
=STANDALONE
,
295 result
= vca_admin
.login(password
=self
.admin_password
, org
='System')
297 raise vimconn
.vimconnConnectionException(
298 "Can't connect to a vCloud director as: {}".format(self
.admin_user
))
299 result
= vca_admin
.login(token
=vca_admin
.token
, org
='System', org_url
=vca_admin
.vcloud_session
.org_url
)
302 "Successfully logged to a vcloud direct org: {} as user: {}".format('System', self
.admin_user
))
307 """ Method connect as normal user to vCloud director.
310 The return vca object that letter can be used to connect to vCloud director as admin for VDC
314 self
.logger
.debug("Logging in to a vca {} as {} to datacenter {}.".format(self
.org_name
,
317 vca
= VCA(host
=self
.url
,
319 service_type
=STANDALONE
,
324 result
= vca
.login(password
=self
.passwd
, org
=self
.org_name
)
326 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director as: {}".format(self
.user
))
327 result
= vca
.login(token
=vca
.token
, org
=self
.org_name
, org_url
=vca
.vcloud_session
.org_url
)
330 "Successfully logged to a vcloud direct org: {} as user: {}".format(self
.org_name
, self
.user
))
333 raise vimconn
.vimconnConnectionException("Can't connect to a vCloud director org: "
334 "{} as user: {}".format(self
.org_name
, self
.user
))
338 def init_organization(self
):
339 """ Method initialize organization UUID and VDC parameters.
341 At bare minimum client must provide organization name that present in vCloud director and VDC.
343 The VDC - UUID ( tenant_id) will be initialized at the run time if client didn't call constructor.
344 The Org - UUID will be initialized at the run time if data center present in vCloud director.
347 The return vca object that letter can be used to connect to vcloud direct as admin
350 if self
.org_uuid
is None:
351 org_dict
= self
.get_org_list()
353 # we set org UUID at the init phase but we can do it only when we have valid credential.
354 if org_dict
[org
] == self
.org_name
:
356 self
.logger
.debug("Setting organization UUID {}".format(self
.org_uuid
))
359 raise vimconn
.vimconnException("Vcloud director organization {} not found".format(self
.org_name
))
361 # if well good we require for org details
362 org_details_dict
= self
.get_org(org_uuid
=self
.org_uuid
)
364 # we have two case if we want to initialize VDC ID or VDC name at run time
365 # tenant_name provided but no tenant id
366 if self
.tenant_id
is None and self
.tenant_name
is not None and 'vdcs' in org_details_dict
:
367 vdcs_dict
= org_details_dict
['vdcs']
368 for vdc
in vdcs_dict
:
369 if vdcs_dict
[vdc
] == self
.tenant_name
:
371 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
375 raise vimconn
.vimconnException("Tenant name indicated but not present in vcloud director.")
376 # case two we have tenant_id but we don't have tenant name so we find and set it.
377 if self
.tenant_id
is not None and self
.tenant_name
is None and 'vdcs' in org_details_dict
:
378 vdcs_dict
= org_details_dict
['vdcs']
379 for vdc
in vdcs_dict
:
380 if vdc
== self
.tenant_id
:
381 self
.tenant_name
= vdcs_dict
[vdc
]
382 self
.logger
.debug("Setting vdc uuid {} for organization UUID {}".format(self
.tenant_id
,
386 raise vimconn
.vimconnException("Tenant id indicated but not present in vcloud director")
387 self
.logger
.debug("Setting organization uuid {}".format(self
.org_uuid
))
389 self
.logger
.debug("Failed initialize organization UUID for org {}".format(self
.org_name
))
390 self
.logger
.debug(traceback
.format_exc())
393 def new_tenant(self
, tenant_name
=None, tenant_description
=None):
394 """ Method adds a new tenant to VIM with this name.
395 This action requires access to create VDC action in vCloud director.
398 tenant_name is tenant_name to be created.
399 tenant_description not used for this call
402 returns the tenant identifier in UUID format.
403 If action is failed method will throw vimconn.vimconnException method
405 vdc_task
= self
.create_vdc(vdc_name
=tenant_name
)
406 if vdc_task
is not None:
407 vdc_uuid
, value
= vdc_task
.popitem()
408 self
.logger
.info("Crated new vdc {} and uuid: {}".format(tenant_name
, vdc_uuid
))
411 raise vimconn
.vimconnException("Failed create tenant {}".format(tenant_name
))
413 def delete_tenant(self
, tenant_id
=None):
414 """Delete a tenant from VIM"""
415 'Returns the tenant identifier'
416 raise vimconn
.vimconnNotImplemented("Should have implemented this")
418 def get_tenant_list(self
, filter_dict
={}):
419 """Obtain tenants of VIM
420 filter_dict can contain the following keys:
421 name: filter by tenant name
422 id: filter by tenant uuid/id
424 Returns the tenant list of dictionaries:
425 [{'name':'<name>, 'id':'<id>, ...}, ...]
428 org_dict
= self
.get_org(self
.org_uuid
)
429 vdcs_dict
= org_dict
['vdcs']
434 entry
= {'name': vdcs_dict
[k
], 'id': k
}
435 # if caller didn't specify dictionary we return all tenants.
436 if filter_dict
is not None and filter_dict
:
437 filtered_entry
= entry
.copy()
438 filtered_dict
= set(entry
.keys()) - set(filter_dict
)
439 for unwanted_key
in filtered_dict
: del entry
[unwanted_key
]
440 if filter_dict
== entry
:
441 vdclist
.append(filtered_entry
)
443 vdclist
.append(entry
)
445 self
.logger
.debug("Error in get_tenant_list()")
446 self
.logger
.debug(traceback
.format_exc())
447 raise vimconn
.vimconnException("Incorrect state. {}")
451 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False):
452 """Adds a tenant network to VIM
454 net_type can be 'bridge','data'.'ptp'.
455 ip_profile is a dict containing the IP parameters of the network
457 Returns the network identifier"""
459 self
.logger
.debug("new_network tenant {} net_type {} ip_profile {} shared {}"
460 .format(net_name
, net_type
, ip_profile
, shared
))
466 network_uuid
= self
.create_network(network_name
=net_name
, net_type
=net_type
,
467 ip_profile
=ip_profile
, isshared
=isshared
)
468 if network_uuid
is not None:
471 raise vimconn
.vimconnUnexpectedResponse("Failed create a new network {}".format(net_name
))
473 def get_vcd_network_list(self
):
474 """ Method available organization for a logged in tenant
477 The return vca object that letter can be used to connect to vcloud direct as admin
480 self
.logger
.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
483 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
485 if not self
.tenant_name
:
486 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
488 vdc
= vca
.get_vdc(self
.tenant_name
)
490 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self
.tenant_name
))
492 vdc_uuid
= vdc
.get_id().split(":")[3]
493 networks
= vca
.get_networks(vdc
.get_name())
496 for network
in networks
:
498 netid
= network
.get_id().split(":")
502 filter_dict
["name"] = network
.get_name()
503 filter_dict
["id"] = netid
[3]
504 filter_dict
["shared"] = network
.get_IsShared()
505 filter_dict
["tenant_id"] = vdc_uuid
506 if network
.get_status() == 1:
507 filter_dict
["admin_state_up"] = True
509 filter_dict
["admin_state_up"] = False
510 filter_dict
["status"] = "ACTIVE"
511 filter_dict
["type"] = "bridge"
512 network_list
.append(filter_dict
)
513 self
.logger
.debug("get_vcd_network_list adding entry {}".format(filter_dict
))
515 self
.logger
.debug("Error in get_vcd_network_list")
516 self
.logger
.debug(traceback
.format_exc())
519 self
.logger
.debug("get_vcd_network_list returning {}".format(network_list
))
522 def get_network_list(self
, filter_dict
={}):
523 """Obtain tenant networks of VIM
525 name: network name OR/AND
526 id: network uuid OR/AND
527 shared: boolean OR/AND
528 tenant_id: tenant OR/AND
529 admin_state_up: boolean
532 [{key : value , key : value}]
534 Returns the network list of dictionaries:
535 [{<the fields at Filter_dict plus some VIM specific>}, ...]
539 self
.logger
.debug("get_vcd_network_list(): retrieving network list for vcd {}".format(self
.tenant_name
))
542 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
544 if not self
.tenant_name
:
545 raise vimconn
.vimconnConnectionException("Tenant name is empty.")
547 vdc
= vca
.get_vdc(self
.tenant_name
)
549 raise vimconn
.vimconnConnectionException("Can't retrieve information for a VDC {}.".format(self
.tenant_name
))
551 vdcid
= vdc
.get_id().split(":")[3]
552 networks
= vca
.get_networks(vdc
.get_name())
556 for network
in networks
:
558 net_uuid
= network
.get_id().split(":")
559 if len(net_uuid
) != 4:
562 net_uuid
= net_uuid
[3]
564 self
.logger
.debug("Adding {} to a list vcd id {} network {}".format(net_uuid
,
567 filter_entry
["name"] = network
.get_name()
568 filter_entry
["id"] = net_uuid
569 filter_entry
["shared"] = network
.get_IsShared()
570 filter_entry
["tenant_id"] = vdcid
571 if network
.get_status() == 1:
572 filter_entry
["admin_state_up"] = True
574 filter_entry
["admin_state_up"] = False
575 filter_entry
["status"] = "ACTIVE"
576 filter_entry
["type"] = "bridge"
577 filtered_entry
= filter_entry
.copy()
579 if filter_dict
is not None and filter_dict
:
580 # we remove all the key : value we don't care and match only
582 filtered_dict
= set(filter_entry
.keys()) - set(filter_dict
)
583 for unwanted_key
in filtered_dict
: del filter_entry
[unwanted_key
]
584 if filter_dict
== filter_entry
:
585 network_list
.append(filtered_entry
)
587 network_list
.append(filtered_entry
)
589 self
.logger
.debug("Error in get_vcd_network_list")
590 self
.logger
.debug(traceback
.format_exc())
592 self
.logger
.debug("Returning {}".format(network_list
))
595 def get_network(self
, net_id
):
596 """Method obtains network details of net_id VIM network
597 Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
601 raise vimconn
.vimconnConnectionException("self.connect() is failed")
603 vdc
= vca
.get_vdc(self
.tenant_name
)
604 vdc_id
= vdc
.get_id().split(":")[3]
606 networks
= vca
.get_networks(vdc
.get_name())
610 for network
in networks
:
611 vdc_network_id
= network
.get_id().split(":")
612 if len(vdc_network_id
) == 4 and vdc_network_id
[3] == net_id
:
613 filter_dict
["name"] = network
.get_name()
614 filter_dict
["id"] = vdc_network_id
[3]
615 filter_dict
["shared"] = network
.get_IsShared()
616 filter_dict
["tenant_id"] = vdc_id
617 if network
.get_status() == 1:
618 filter_dict
["admin_state_up"] = True
620 filter_dict
["admin_state_up"] = False
621 filter_dict
["status"] = "ACTIVE"
622 filter_dict
["type"] = "bridge"
623 self
.logger
.debug("Returning {}".format(filter_dict
))
626 self
.logger
.debug("Error in get_network")
627 self
.logger
.debug(traceback
.format_exc())
631 def delete_network(self
, net_id
):
633 Method Deletes a tenant network from VIM, provide the network id.
635 Returns the network identifier or raise an exception
640 raise vimconn
.vimconnConnectionException("self.connect() for tenant {} is failed.".format(self
.tenant_name
))
642 vcd_network
= self
.get_vcd_network(network_uuid
=net_id
)
643 if vcd_network
is not None and vcd_network
:
644 if self
.delete_network_action(network_uuid
=net_id
):
647 raise vimconn
.vimconnNotFoundException("Network {} not found".format(net_id
))
649 def refresh_nets_status(self
, net_list
):
650 """Get the status of the networks
651 Params: the list of network identifiers
652 Returns a dictionary with:
653 net_id: #VIM id of this network
654 status: #Mandatory. Text with one of:
655 # DELETED (not found at vim)
656 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
657 # OTHER (Vim reported other status not understood)
658 # ERROR (VIM indicates an ERROR status)
659 # ACTIVE, INACTIVE, DOWN (admin down),
660 # BUILD (on building process)
662 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
663 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
669 raise vimconn
.vimconnConnectionException("self.connect() is failed")
675 vcd_network
= self
.get_vcd_network(network_uuid
=net
)
676 if vcd_network
is not None and vcd_network
:
677 if vcd_network
['status'] == '1':
683 errormsg
= 'Network not found.'
685 dict_entry
[net
] = {'status': status
, 'error_msg': errormsg
,
686 'vim_info': yaml
.safe_dump(vcd_network
)}
688 self
.logger
.debug("Error in refresh_nets_status")
689 self
.logger
.debug(traceback
.format_exc())
693 def get_flavor(self
, flavor_id
):
694 """Obtain flavor details from the VIM
695 Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } #TODO to concrete
697 if flavor_id
not in flavorlist
:
698 raise vimconn
.vimconnNotFoundException("Flavor not found.")
699 return flavorlist
[flavor_id
]
701 def new_flavor(self
, flavor_data
):
702 """Adds a tenant flavor to VIM
703 flavor_data contains a dictionary with information, keys:
705 ram: memory (cloud type) in MBytes
706 vpcus: cpus (cloud type)
707 extended: EPA parameters
708 - numas: #items requested in same NUMA
709 memory: number of 1G huge pages memory
710 paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
711 interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
712 - name: interface name
713 dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
714 bandwidth: X Gbps; requested guarantee bandwidth
715 vpci: requested virtual PCI address
719 Returns the flavor identifier"""
721 # generate a new uuid put to internal dict and return it.
722 self
.logger
.debug("Creating new flavor - flavor_data: {}".format(flavor_data
))
723 new_flavor
=flavor_data
724 ram
= flavor_data
.get(FLAVOR_RAM_KEY
, 1024)
725 cpu
= flavor_data
.get(FLAVOR_VCPUS_KEY
, 1)
726 disk
= flavor_data
.get(FLAVOR_DISK_KEY
, 1)
728 extended_flv
= flavor_data
.get("extended")
730 numas
=extended_flv
.get("numas")
733 #overwrite ram and vcpus
734 ram
= numa
['memory']*1024
735 if 'paired-threads' in numa
:
736 cpu
= numa
['paired-threads']*2
737 elif 'cores' in numa
:
739 elif 'threads' in numa
:
740 cpu
= numa
['threads']
742 new_flavor
[FLAVOR_RAM_KEY
] = ram
743 new_flavor
[FLAVOR_VCPUS_KEY
] = cpu
744 new_flavor
[FLAVOR_DISK_KEY
] = disk
745 # generate a new uuid put to internal dict and return it.
746 flavor_id
= uuid
.uuid4()
747 flavorlist
[str(flavor_id
)] = new_flavor
748 self
.logger
.debug("Created flavor - {} : {}".format(flavor_id
, new_flavor
))
750 return str(flavor_id
)
752 def delete_flavor(self
, flavor_id
):
753 """Deletes a tenant flavor from VIM identify by its id
755 Returns the used id or raise an exception
757 if flavor_id
not in flavorlist
:
758 raise vimconn
.vimconnNotFoundException("Flavor not found.")
760 flavorlist
.pop(flavor_id
, None)
763 def new_image(self
, image_dict
):
765 Adds a tenant image to VIM
767 200, image-id if the image is created
768 <0, message if there is an error
771 return self
.get_image_id_from_path(image_dict
['location'])
773 def delete_image(self
, image_id
):
780 raise vimconn
.vimconnNotImplemented("Should have implemented this")
782 def catalog_exists(self
, catalog_name
, catalogs
):
789 for catalog
in catalogs
:
790 if catalog
.name
== catalog_name
:
794 def create_vimcatalog(self
, vca
=None, catalog_name
=None):
795 """ Create new catalog entry in vCloud director.
798 vca: vCloud director.
799 catalog_name catalog that client wish to create. Note no validation done for a name.
800 Client must make sure that provide valid string representation.
802 Return (bool) True if catalog created.
806 task
= vca
.create_catalog(catalog_name
, catalog_name
)
807 result
= vca
.block_until_completed(task
)
810 catalogs
= vca
.get_catalogs()
813 return self
.catalog_exists(catalog_name
, catalogs
)
815 # noinspection PyIncorrectDocstring
816 def upload_ovf(self
, vca
=None, catalog_name
=None, image_name
=None, media_file_name
=None,
817 description
='', progress
=False, chunk_bytes
=128 * 1024):
819 Uploads a OVF file to a vCloud catalog
826 :param catalog_name: (str): The name of the catalog to upload the media.
827 :param media_file_name: (str): The name of the local media file to upload.
828 :return: (bool) True if the media file was successfully uploaded, false otherwise.
830 os
.path
.isfile(media_file_name
)
831 statinfo
= os
.stat(media_file_name
)
833 # find a catalog entry where we upload OVF.
834 # create vApp Template and check the status if vCD able to read OVF it will respond with appropirate
836 # if VCD can parse OVF we upload VMDK file
837 for catalog
in vca
.get_catalogs():
838 if catalog_name
!= catalog
.name
:
840 link
= filter(lambda link
: link
.get_type() == "application/vnd.vmware.vcloud.media+xml" and
841 link
.get_rel() == 'add', catalog
.get_Link())
842 assert len(link
) == 1
844 <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>
845 """ % (escape(catalog_name
), escape(description
))
846 headers
= vca
.vcloud_session
.get_vcloud_headers()
847 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
848 response
= Http
.post(link
[0].get_href(), headers
=headers
, data
=data
, verify
=vca
.verify
, logger
=self
.logger
)
849 if response
.status_code
== requests
.codes
.created
:
850 catalogItem
= XmlElementTree
.fromstring(response
.content
)
851 entity
= [child
for child
in catalogItem
if
852 child
.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
853 href
= entity
.get('href')
855 response
= Http
.get(href
, headers
=vca
.vcloud_session
.get_vcloud_headers(),
856 verify
=vca
.verify
, logger
=self
.logger
)
858 if response
.status_code
== requests
.codes
.ok
:
859 media
= mediaType
.parseString(response
.content
, True)
860 link
= filter(lambda link
: link
.get_rel() == 'upload:default',
861 media
.get_Files().get_File()[0].get_Link())[0]
862 headers
= vca
.vcloud_session
.get_vcloud_headers()
863 headers
['Content-Type'] = 'Content-Type text/xml'
864 response
= Http
.put(link
.get_href(),
865 data
=open(media_file_name
, 'rb'),
867 verify
=vca
.verify
, logger
=self
.logger
)
868 if response
.status_code
!= requests
.codes
.ok
:
870 "Failed create vApp template for catalog name {} and image {}".format(catalog_name
,
874 # TODO fix this with aync block
877 self
.logger
.debug("vApp template for catalog name {} and image {}".format(catalog_name
, media_file_name
))
879 # uploading VMDK file
880 # check status of OVF upload and upload remaining files.
881 response
= Http
.get(template
,
882 headers
=vca
.vcloud_session
.get_vcloud_headers(),
886 if response
.status_code
== requests
.codes
.ok
:
887 media
= mediaType
.parseString(response
.content
, True)
888 number_of_files
= len(media
.get_Files().get_File())
889 for index
in xrange(0, number_of_files
):
890 links_list
= filter(lambda link
: link
.get_rel() == 'upload:default',
891 media
.get_Files().get_File()[index
].get_Link())
892 for link
in links_list
:
893 # we skip ovf since it already uploaded.
894 if 'ovf' in link
.get_href():
896 # The OVF file and VMDK must be in a same directory
897 head
, tail
= os
.path
.split(media_file_name
)
898 file_vmdk
= head
+ '/' + link
.get_href().split("/")[-1]
899 if not os
.path
.isfile(file_vmdk
):
901 statinfo
= os
.stat(file_vmdk
)
902 if statinfo
.st_size
== 0:
904 hrefvmdk
= link
.get_href()
907 print("Uploading file: {}".format(file_vmdk
))
909 widgets
= ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
911 progress_bar
= ProgressBar(widgets
=widgets
, maxval
=statinfo
.st_size
).start()
913 bytes_transferred
= 0
914 f
= open(file_vmdk
, 'rb')
915 while bytes_transferred
< statinfo
.st_size
:
916 my_bytes
= f
.read(chunk_bytes
)
917 if len(my_bytes
) <= chunk_bytes
:
918 headers
= vca
.vcloud_session
.get_vcloud_headers()
919 headers
['Content-Range'] = 'bytes %s-%s/%s' % (
920 bytes_transferred
, len(my_bytes
) - 1, statinfo
.st_size
)
921 headers
['Content-Length'] = str(len(my_bytes
))
922 response
= Http
.put(hrefvmdk
,
928 if response
.status_code
== requests
.codes
.ok
:
929 bytes_transferred
+= len(my_bytes
)
931 progress_bar
.update(bytes_transferred
)
934 'file upload failed with error: [%s] %s' % (response
.status_code
,
941 progress_bar
.finish()
945 self
.logger
.debug("Failed retrieve vApp template for catalog name {} for OVF {}".
946 format(catalog_name
, media_file_name
))
949 self
.logger
.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name
, media_file_name
))
952 def upload_vimimage(self
, vca
=None, catalog_name
=None, media_name
=None, medial_file_name
=None, progress
=False):
953 """Upload media file"""
954 # TODO add named parameters for readability
956 return self
.upload_ovf(vca
=vca
, catalog_name
=catalog_name
, image_name
=media_name
.split(".")[0],
957 media_file_name
=medial_file_name
, description
='medial_file_name', progress
=progress
)
959 def validate_uuid4(self
, uuid_string
=None):
960 """ Method validate correct format of UUID.
962 Return: true if string represent valid uuid
965 val
= uuid
.UUID(uuid_string
, version
=4)
970 def get_catalogid(self
, catalog_name
=None, catalogs
=None):
971 """ Method check catalog and return catalog ID in UUID format.
974 catalog_name: catalog name as string
975 catalogs: list of catalogs.
977 Return: catalogs uuid
980 for catalog
in catalogs
:
981 if catalog
.name
== catalog_name
:
982 catalog_id
= catalog
.get_id().split(":")
986 def get_catalogbyid(self
, catalog_uuid
=None, catalogs
=None):
987 """ Method check catalog and return catalog name lookup done by catalog UUID.
990 catalog_name: catalog name as string
991 catalogs: list of catalogs.
993 Return: catalogs name or None
996 if not self
.validate_uuid4(uuid_string
=catalog_uuid
):
999 for catalog
in catalogs
:
1000 catalog_id
= catalog
.get_id().split(":")[3]
1001 if catalog_id
== catalog_uuid
:
1005 def get_image_id_from_path(self
, path
=None, progress
=False):
1006 """ Method upload OVF image to vCloud director.
1008 Each OVF image represented as single catalog entry in vcloud director.
1009 The method check for existing catalog entry. The check done by file name without file extension.
1011 if given catalog name already present method will respond with existing catalog uuid otherwise
1012 it will create new catalog entry and upload OVF file to newly created catalog.
1014 If method can't create catalog entry or upload a file it will throw exception.
1016 Method accept boolean flag progress that will output progress bar. It useful method
1017 for standalone upload use case. In case to test large file upload.
1020 path: - valid path to OVF file.
1021 progress - boolean progress bar show progress bar.
1023 Return: if image uploaded correct method will provide image catalog UUID.
1025 vca
= self
.connect()
1027 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1030 raise vimconn
.vimconnException("Image path can't be None.")
1032 if not os
.path
.isfile(path
):
1033 raise vimconn
.vimconnException("Can't read file. File not found.")
1035 if not os
.access(path
, os
.R_OK
):
1036 raise vimconn
.vimconnException("Can't read file. Check file permission to read.")
1038 self
.logger
.debug("get_image_id_from_path() client requesting {} ".format(path
))
1040 dirpath
, filename
= os
.path
.split(path
)
1041 flname
, file_extension
= os
.path
.splitext(path
)
1042 if file_extension
!= '.ovf':
1043 self
.logger
.debug("Wrong file extension {} connector support only OVF container.".format(file_extension
))
1044 raise vimconn
.vimconnException("Wrong container. vCloud director supports only OVF.")
1046 catalog_name
= os
.path
.splitext(filename
)[0]
1047 catalog_md5_name
= hashlib
.md5(path
).hexdigest()
1048 self
.logger
.debug("File name {} Catalog Name {} file path {} "
1049 "vdc catalog name {}".format(filename
, catalog_name
, path
, catalog_md5_name
))
1051 catalogs
= vca
.get_catalogs()
1052 if len(catalogs
) == 0:
1053 self
.logger
.info("Creating a new catalog entry {} in vcloud director".format(catalog_name
))
1054 result
= self
.create_vimcatalog(vca
, catalog_md5_name
)
1056 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1057 result
= self
.upload_vimimage(vca
=vca
, catalog_name
=catalog_md5_name
,
1058 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1060 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_name
))
1061 return self
.get_catalogid(catalog_name
, vca
.get_catalogs())
1063 for catalog
in catalogs
:
1064 # search for existing catalog if we find same name we return ID
1065 # TODO optimize this
1066 if catalog
.name
== catalog_md5_name
:
1067 self
.logger
.debug("Found existing catalog entry for {} "
1068 "catalog id {}".format(catalog_name
,
1069 self
.get_catalogid(catalog_md5_name
, catalogs
)))
1070 return self
.get_catalogid(catalog_md5_name
, vca
.get_catalogs())
1072 # if we didn't find existing catalog we create a new one and upload image.
1073 self
.logger
.debug("Creating new catalog entry {} - {}".format(catalog_name
, catalog_md5_name
))
1074 result
= self
.create_vimcatalog(vca
, catalog_md5_name
)
1076 raise vimconn
.vimconnException("Failed create new catalog {} ".format(catalog_md5_name
))
1078 result
= self
.upload_vimimage(vca
=vca
, catalog_name
=catalog_md5_name
,
1079 media_name
=filename
, medial_file_name
=path
, progress
=progress
)
1081 raise vimconn
.vimconnException("Failed create vApp template for catalog {} ".format(catalog_md5_name
))
1083 return self
.get_catalogid(catalog_md5_name
, vca
.get_catalogs())
1085 def get_image_list(self
, filter_dict
={}):
1086 '''Obtain tenant images from VIM
1090 checksum: image checksum
1091 location: image path
1092 Returns the image list of dictionaries:
1093 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1096 vca
= self
.connect()
1098 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1101 catalogs
= vca
.get_catalogs()
1102 if len(catalogs
) == 0:
1105 for catalog
in catalogs
:
1106 catalog_uuid
= catalog
.get_id().split(":")[3]
1109 if filter_dict
.get("name") and filter_dict
["name"] != name
:
1111 if filter_dict
.get("id") and filter_dict
["id"] != catalog_uuid
:
1113 filtered_dict
["name"] = name
1114 filtered_dict
["id"] = catalog_uuid
1115 image_list
.append(filtered_dict
)
1117 self
.logger
.debug("List of already created catalog items: {}".format(image_list
))
1119 except Exception as exp
:
1120 raise vimconn
.vimconnException("Exception occured while retriving catalog items {}".format(exp
))
1122 def get_vappid(self
, vdc
=None, vapp_name
=None):
1123 """ Method takes vdc object and vApp name and returns vapp uuid or None
1126 vdc: The VDC object.
1127 vapp_name: is application vappp name identifier
1130 The return vApp name otherwise None
1132 if vdc
is None or vapp_name
is None:
1134 # UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
1136 refs
= filter(lambda ref
: ref
.name
== vapp_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1137 vdc
.ResourceEntities
.ResourceEntity
)
1139 return refs
[0].href
.split("vapp")[1][1:]
1140 except Exception as e
:
1141 self
.logger
.exception(e
)
1145 def check_vapp(self
, vdc
=None, vapp_uuid
=None):
1146 """ Method Method returns True or False if vapp deployed in vCloud director
1149 vca: Connector to VCA
1150 vdc: The VDC object.
1151 vappid: vappid is application identifier
1154 The return True if vApp deployed
1159 refs
= filter(lambda ref
:
1160 ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1161 vdc
.ResourceEntities
.ResourceEntity
)
1163 vappid
= ref
.href
.split("vapp")[1][1:]
1164 # find vapp with respected vapp uuid
1165 if vappid
== vapp_uuid
:
1167 except Exception as e
:
1168 self
.logger
.exception(e
)
1172 def get_namebyvappid(self
, vca
=None, vdc
=None, vapp_uuid
=None):
1173 """Method returns vApp name from vCD and lookup done by vapp_id.
1176 vca: Connector to VCA
1177 vdc: The VDC object.
1178 vapp_uuid: vappid is application identifier
1181 The return vApp name otherwise None
1185 refs
= filter(lambda ref
: ref
.type_
== 'application/vnd.vmware.vcloud.vApp+xml',
1186 vdc
.ResourceEntities
.ResourceEntity
)
1188 # we care only about UUID the rest doesn't matter
1189 vappid
= ref
.href
.split("vapp")[1][1:]
1190 if vappid
== vapp_uuid
:
1191 response
= Http
.get(ref
.href
, headers
=vca
.vcloud_session
.get_vcloud_headers(), verify
=vca
.verify
,
1193 tree
= XmlElementTree
.fromstring(response
.content
)
1194 return tree
.attrib
['name']
1195 except Exception as e
:
1196 self
.logger
.exception(e
)
1200 def new_vminstance(self
, name
=None, description
="", start
=False, image_id
=None, flavor_id
=None, net_list
={},
1201 cloud_config
=None, disk_list
=None):
1202 """Adds a VM instance to VIM
1204 start: indicates if VM must start or boot in pause mode. Ignored
1205 image_id,flavor_id: image and flavor uuid
1206 net_list: list of interfaces, each one is a dictionary with:
1208 net_id: network uuid to connect
1209 vpci: virtual vcpi to assign
1210 model: interface model, virtio, e2000, ...
1212 use: 'data', 'bridge', 'mgmt'
1213 type: 'virtual', 'PF', 'VF', 'VFnotShared'
1214 vim_id: filled/added by this function
1215 cloud_config: can be a text script to be passed directly to cloud-init,
1216 or an object to inject users and ssh keys with format:
1217 key-pairs: [] list of keys to install to the default user
1218 users: [{ name, key-pairs: []}] list of users to add with their key-pair
1219 #TODO ip, security groups
1220 Returns >=0, the instance identifier
1224 self
.logger
.info("Creating new instance for entry {}".format(name
))
1225 self
.logger
.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {}".
1226 format(description
, start
, image_id
, flavor_id
, net_list
, cloud_config
))
1227 vca
= self
.connect()
1229 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1231 #new vm name = vmname + tenant_id + uuid
1232 new_vm_name
= [name
, '-', str(uuid
.uuid4())]
1233 vmname_andid
= ''.join(new_vm_name
)
1235 # if vm already deployed we return existing uuid
1236 # vapp_uuid = self.get_vappid(vca.get_vdc(self.tenant_name), name)
1237 # if vapp_uuid is not None:
1240 # we check for presence of VDC, Catalog entry and Flavor.
1241 vdc
= vca
.get_vdc(self
.tenant_name
)
1243 raise vimconn
.vimconnNotFoundException(
1244 "new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name
))
1245 catalogs
= vca
.get_catalogs()
1246 if catalogs
is None:
1247 raise vimconn
.vimconnNotFoundException(
1248 "new_vminstance(): Failed create vApp {}: (Failed retrieve catalogs list)".format(name
))
1250 catalog_hash_name
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1251 if catalog_hash_name
:
1252 self
.logger
.info("Found catalog entry {} for image id {}".format(catalog_hash_name
, image_id
))
1254 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1255 "(Failed retrieve catalog information {})".format(name
, image_id
))
1258 # Set vCPU and Memory based on flavor.
1263 pci_devices_info
= []
1264 if flavor_id
is not None:
1265 if flavor_id
not in flavorlist
:
1266 raise vimconn
.vimconnNotFoundException("new_vminstance(): Failed create vApp {}: "
1267 "Failed retrieve flavor information "
1268 "flavor id {}".format(name
, flavor_id
))
1271 flavor
= flavorlist
[flavor_id
]
1272 vm_cpus
= flavor
[FLAVOR_VCPUS_KEY
]
1273 vm_memory
= flavor
[FLAVOR_RAM_KEY
]
1274 vm_disk
= flavor
[FLAVOR_DISK_KEY
]
1275 extended
= flavor
.get("extended", None)
1277 numas
=extended
.get("numas", None)
1280 for interface
in numa
.get("interfaces",() ):
1281 if interface
["dedicated"].strip()=="yes":
1282 pci_devices_info
.append(interface
)
1284 raise vimconn
.vimconnException("Corrupted flavor. {}".format(flavor_id
))
1286 # image upload creates template name as catalog name space Template.
1287 templateName
= self
.get_catalogbyid(catalog_uuid
=image_id
, catalogs
=catalogs
)
1292 # client must provide at least one entry in net_list if not we report error
1293 #If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
1294 #If no mgmt, then the 1st NN in netlist is considered as primary net.
1296 primary_netname
= None
1297 network_mode
= 'bridged'
1298 if net_list
is not None and len(net_list
) > 0:
1299 for net
in net_list
:
1300 if 'use' in net
and net
['use'] == 'mgmt':
1302 if primary_net
is None:
1303 primary_net
= net_list
[0]
1306 primary_net_id
= primary_net
['net_id']
1307 network_dict
= self
.get_vcd_network(network_uuid
=primary_net_id
)
1308 if 'name' in network_dict
:
1309 primary_netname
= network_dict
['name']
1312 raise vimconn
.vimconnException("Corrupted flavor. {}".format(primary_net
))
1314 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed network list is empty.".format(name
))
1316 # use: 'data', 'bridge', 'mgmt'
1317 # create vApp. Set vcpu and ram based on flavor id.
1318 vapptask
= vca
.create_vapp(self
.tenant_name
, vmname_andid
, templateName
,
1319 self
.get_catalogbyid(image_id
, catalogs
),
1320 network_name
=None, # None while creating vapp
1321 network_mode
=network_mode
,
1322 vm_name
=vmname_andid
,
1323 vm_cpus
=vm_cpus
, # can be None if flavor is None
1324 vm_memory
=vm_memory
) # can be None if flavor is None
1326 if vapptask
is None or vapptask
is False:
1327 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): failed deploy vApp {}".format(vmname_andid
))
1328 if type(vapptask
) is VappTask
:
1329 vca
.block_until_completed(vapptask
)
1331 # we should have now vapp in undeployed state.
1332 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vmname_andid
)
1333 vapp_uuid
= self
.get_vappid(vca
.get_vdc(self
.tenant_name
), vmname_andid
)
1335 raise vimconn
.vimconnUnexpectedResponse(
1336 "new_vminstance(): Failed failed retrieve vApp {} after we deployed".format(
1339 #Add PCI passthrough configrations
1340 PCI_devices_status
= False
1343 if len(pci_devices_info
) > 0:
1344 self
.logger
.info("Need to add PCI devices {} into VM {}".format(pci_devices_info
,
1346 PCI_devices_status
, vm_obj
, vcenter_conect
= self
.add_pci_devices(vapp_uuid
,
1349 if PCI_devices_status
:
1350 self
.logger
.info("Added PCI devives {} to VM {}".format(
1355 self
.logger
.info("Fail to add PCI devives {} to VM {}".format(
1361 #Assuming there is only one disk in ovf and fast provisioning in organization vDC is disabled
1362 result
= self
.modify_vm_disk(vapp_uuid
, vm_disk
)
1364 self
.logger
.debug("Modified Disk size of VM {} ".format(vmname_andid
))
1366 # add NICs & connect to networks in netlist
1368 self
.logger
.info("Request to connect VM to a network: {}".format(net_list
))
1370 primary_nic_index
= 0
1371 for net
in net_list
:
1372 # openmano uses network id in UUID format.
1373 # vCloud Director need a name so we do reverse operation from provided UUID we lookup a name
1374 # [{'use': 'bridge', 'net_id': '527d4bf7-566a-41e7-a9e7-ca3cdd9cef4f', 'type': 'virtual',
1375 # 'vpci': '0000:00:11.0', 'name': 'eth0'}]
1377 if 'net_id' not in net
:
1380 interface_net_id
= net
['net_id']
1381 interface_net_name
= self
.get_network_name_by_id(network_uuid
=interface_net_id
)
1382 interface_network_mode
= net
['use']
1384 if interface_network_mode
== 'mgmt':
1385 primary_nic_index
= nicIndex
1387 """- POOL (A static IP address is allocated automatically from a pool of addresses.)
1388 - DHCP (The IP address is obtained from a DHCP service.)
1389 - MANUAL (The IP address is assigned manually in the IpAddress element.)
1390 - NONE (No IP addressing mode specified.)"""
1392 if primary_netname
is not None:
1393 nets
= filter(lambda n
: n
.name
== interface_net_name
, vca
.get_networks(self
.tenant_name
))
1395 self
.logger
.info("new_vminstance(): Found requested network: {}".format(nets
[0].name
))
1396 task
= vapp
.connect_to_network(nets
[0].name
, nets
[0].href
)
1397 if type(task
) is GenericTask
:
1398 vca
.block_until_completed(task
)
1399 # connect network to VM - with all DHCP by default
1400 self
.logger
.info("new_vminstance(): Connecting VM to a network {}".format(nets
[0].name
))
1401 task
= vapp
.connect_vms(nets
[0].name
,
1402 connection_index
=nicIndex
,
1403 connections_primary_index
=primary_nic_index
,
1404 ip_allocation_mode
='DHCP')
1405 if type(task
) is GenericTask
:
1406 vca
.block_until_completed(task
)
1409 # it might be a case if specific mandatory entry in dict is empty
1410 self
.logger
.debug("Key error {}".format(KeyError.message
))
1411 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name
))
1413 # deploy and power on vm
1414 self
.logger
.debug("new_vminstance(): Deploying vApp {} ".format(name
))
1415 deploytask
= vapp
.deploy(powerOn
=False)
1416 if type(deploytask
) is GenericTask
:
1417 vca
.block_until_completed(deploytask
)
1419 # If VM has PCI devices reserve memory for VM
1420 if PCI_devices_status
and vm_obj
and vcenter_conect
:
1421 memReserve
= vm_obj
.config
.hardware
.memoryMB
1422 spec
= vim
.vm
.ConfigSpec()
1423 spec
.memoryAllocation
= vim
.ResourceAllocationInfo(reservation
=memReserve
)
1424 task
= vm_obj
.ReconfigVM_Task(spec
=spec
)
1426 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
1427 self
.logger
.info("Reserved memmoery {} MB for "\
1428 "VM VM status: {}".format(str(memReserve
),result
))
1430 self
.logger
.info("Fail to reserved memmoery {} to VM {}".format(
1431 str(memReserve
),str(vm_obj
)))
1433 self
.logger
.debug("new_vminstance(): power on vApp {} ".format(name
))
1434 poweron_task
= vapp
.poweron()
1435 if type(poweron_task
) is GenericTask
:
1436 vca
.block_until_completed(poweron_task
)
1438 # check if vApp deployed and if that the case return vApp UUID otherwise -1
1441 while wait_time
<= MAX_WAIT_TIME
:
1442 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vmname_andid
)
1443 if vapp
and vapp
.me
.deployed
:
1444 vapp_uuid
= self
.get_vappid(vca
.get_vdc(self
.tenant_name
), vmname_andid
)
1447 self
.logger
.debug("new_vminstance(): Wait for vApp {} to deploy".format(name
))
1448 time
.sleep(INTERVAL_TIME
)
1450 wait_time
+=INTERVAL_TIME
1452 if vapp_uuid
is not None:
1455 raise vimconn
.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name
))
1459 ## based on current discussion
1463 # created: '2016-09-08T11:51:58'
1464 # description: simple-instance.linux1.1
1465 # flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
1466 # hostId: e836c036-74e7-11e6-b249-0800273e724c
1467 # image: dde30fe6-75a9-11e6-ad5f-0800273e724c
1472 def get_vminstance(self
, vim_vm_uuid
=None):
1473 """Returns the VM instance information from VIM"""
1475 self
.logger
.debug("Client requesting vm instance {} ".format(vim_vm_uuid
))
1476 vca
= self
.connect()
1478 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1480 vdc
= vca
.get_vdc(self
.tenant_name
)
1482 raise vimconn
.vimconnConnectionException(
1483 "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
1485 vm_info_dict
= self
.get_vapp_details_rest(vapp_uuid
=vim_vm_uuid
)
1486 if not vm_info_dict
:
1487 self
.logger
.debug("get_vminstance(): Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
1488 raise vimconn
.vimconnNotFoundException("Failed to get vApp name by UUID {}".format(vim_vm_uuid
))
1490 status_key
= vm_info_dict
['status']
1493 vm_dict
= {'created': vm_info_dict
['created'],
1494 'description': vm_info_dict
['name'],
1495 'status': vcdStatusCode2manoFormat
[int(status_key
)],
1496 'hostId': vm_info_dict
['vmuuid'],
1498 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
1500 if 'interfaces' in vm_info_dict
:
1501 vm_dict
['interfaces'] = vm_info_dict
['interfaces']
1503 vm_dict
['interfaces'] = []
1505 vm_dict
= {'created': '',
1507 'status': vcdStatusCode2manoFormat
[int(-1)],
1508 'hostId': vm_info_dict
['vmuuid'],
1509 'error_msg': "Inconsistency state",
1510 'vim_info': yaml
.safe_dump(vm_info_dict
), 'interfaces': []}
1514 def delete_vminstance(self
, vm__vim_uuid
):
1515 """Method poweroff and remove VM instance from vcloud director network.
1518 vm__vim_uuid: VM UUID
1521 Returns the instance identifier
1524 self
.logger
.debug("Client requesting delete vm instance {} ".format(vm__vim_uuid
))
1525 vca
= self
.connect()
1527 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1529 vdc
= vca
.get_vdc(self
.tenant_name
)
1531 self
.logger
.debug("delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(
1533 raise vimconn
.vimconnException(
1534 "delete_vminstance(): Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
1537 vapp_name
= self
.get_namebyvappid(vca
, vdc
, vm__vim_uuid
)
1538 if vapp_name
is None:
1539 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1540 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1542 self
.logger
.info("Deleting vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
1544 # Delete vApp and wait for status change if task executed and vApp is None.
1545 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vapp_name
)
1548 if vapp
.me
.deployed
:
1549 self
.logger
.info("Powering off vApp {}".format(vapp_name
))
1553 while wait_time
<= MAX_WAIT_TIME
:
1554 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vapp_name
)
1556 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1557 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1559 power_off_task
= vapp
.poweroff()
1560 if type(power_off_task
) is GenericTask
:
1561 result
= vca
.block_until_completed(power_off_task
)
1566 self
.logger
.info("Wait for vApp {} to power off".format(vapp_name
))
1567 time
.sleep(INTERVAL_TIME
)
1569 wait_time
+=INTERVAL_TIME
1571 self
.logger
.debug("delete_vminstance(): Failed to power off VM instance {} ".format(vm__vim_uuid
))
1573 self
.logger
.info("delete_vminstance(): Powered off VM instance {} ".format(vm__vim_uuid
))
1576 self
.logger
.info("Undeploy vApp {}".format(vapp_name
))
1579 while wait_time
<= MAX_WAIT_TIME
:
1580 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vapp_name
)
1582 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1583 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1584 undeploy_task
= vapp
.undeploy(action
='powerOff')
1586 if type(undeploy_task
) is GenericTask
:
1587 result
= vca
.block_until_completed(undeploy_task
)
1592 self
.logger
.debug("Wait for vApp {} to undeploy".format(vapp_name
))
1593 time
.sleep(INTERVAL_TIME
)
1595 wait_time
+=INTERVAL_TIME
1598 self
.logger
.debug("delete_vminstance(): Failed to undeploy vApp {} ".format(vm__vim_uuid
))
1601 self
.logger
.info("Start deletion of vApp {} ".format(vapp_name
))
1602 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vapp_name
)
1604 if vapp
is not None:
1608 while wait_time
<= MAX_WAIT_TIME
:
1609 vapp
= vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vapp_name
)
1611 self
.logger
.debug("delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1612 return -1, "delete_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
)
1614 delete_task
= vapp
.delete()
1616 if type(delete_task
) is GenericTask
:
1617 vca
.block_until_completed(delete_task
)
1618 result
= vca
.block_until_completed(delete_task
)
1622 self
.logger
.debug("Wait for vApp {} to delete".format(vapp_name
))
1623 time
.sleep(INTERVAL_TIME
)
1625 wait_time
+=INTERVAL_TIME
1628 self
.logger
.debug("delete_vminstance(): Failed delete uuid {} ".format(vm__vim_uuid
))
1631 self
.logger
.debug(traceback
.format_exc())
1632 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
1634 if vca
.get_vapp(vca
.get_vdc(self
.tenant_name
), vapp_name
) is None:
1635 self
.logger
.info("Deleted vm instance {} sccessfully".format(vm__vim_uuid
))
1638 raise vimconn
.vimconnException("delete_vminstance(): Failed delete vm instance {}".format(vm__vim_uuid
))
1640 def refresh_vms_status(self
, vm_list
):
1641 """Get the status of the virtual machines and their interfaces/ports
1642 Params: the list of VM identifiers
1643 Returns a dictionary with:
1644 vm_id: #VIM id of this Virtual Machine
1645 status: #Mandatory. Text with one of:
1646 # DELETED (not found at vim)
1647 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1648 # OTHER (Vim reported other status not understood)
1649 # ERROR (VIM indicates an ERROR status)
1650 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1651 # CREATING (on building process), ERROR
1652 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1654 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1655 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1657 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1658 mac_address: #Text format XX:XX:XX:XX:XX:XX
1659 vim_net_id: #network id where this interface is connected
1660 vim_interface_id: #interface/port VIM id
1661 ip_address: #null, or text with IPv4, IPv6 address
1664 self
.logger
.debug("Client requesting refresh vm status for {} ".format(vm_list
))
1667 rheaders
= {'Content-Type': 'application/xml'}
1668 iso_edges
= ['edge-2','edge-3','edge-6','edge-7','edge-8','edge-9','edge-10']
1671 for edge
in iso_edges
:
1672 nsx_api_url
= '/api/4.0/edges/'+ edge
+'/dhcp/leaseInfo'
1673 self
.logger
.debug("refresh_vms_status: NSX Manager url: {}".format(nsx_api_url
))
1675 resp
= requests
.get(self
.nsx_manager
+ nsx_api_url
,
1676 auth
= (self
.nsx_user
, self
.nsx_password
),
1677 verify
= False, headers
= rheaders
)
1679 if resp
.status_code
== requests
.codes
.ok
:
1680 dhcp_leases
= XmlElementTree
.fromstring(resp
.text
)
1681 for child
in dhcp_leases
:
1682 if child
.tag
== 'dhcpLeaseInfo':
1683 dhcpLeaseInfo
= child
1684 for leaseInfo
in dhcpLeaseInfo
:
1685 for elem
in leaseInfo
:
1686 if (elem
.tag
)=='macAddress':
1687 mac_addr
= elem
.text
1688 if (elem
.tag
)=='ipAddress':
1690 if (mac_addr
) is not None:
1691 mac_ip_addr
[mac_addr
]= ip_addr
1692 self
.logger
.debug("NSX Manager DHCP Lease info: mac_ip_addr : {}".format(mac_ip_addr
))
1694 self
.logger
.debug("Error occurred while getting DHCP lease info from NSX Manager: {}".format(resp
.content
))
1696 self
.logger
.debug("Error in response from NSX Manager {}".format(KeyError.message
))
1697 self
.logger
.debug(traceback
.format_exc())
1699 vca
= self
.connect()
1701 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1703 vdc
= vca
.get_vdc(self
.tenant_name
)
1705 raise vimconn
.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
))
1708 for vmuuid
in vm_list
:
1709 vmname
= self
.get_namebyvappid(vca
, vdc
, vmuuid
)
1710 if vmname
is not None:
1712 the_vapp
= vca
.get_vapp(vdc
, vmname
)
1713 vm_info
= the_vapp
.get_vms_details()
1714 vm_status
= vm_info
[0]['status']
1715 vm_pci_details
= self
.get_vm_pci_details(vmuuid
)
1716 vm_info
[0].update(vm_pci_details
)
1718 vm_dict
= {'status': vcdStatusCode2manoFormat
[the_vapp
.me
.get_status()],
1719 'error_msg': vcdStatusCode2manoFormat
[the_vapp
.me
.get_status()],
1720 'vim_info': yaml
.safe_dump(vm_info
), 'interfaces': []}
1724 vm_app_networks
= the_vapp
.get_vms_network_info()
1725 for vapp_network
in vm_app_networks
:
1726 for vm_network
in vapp_network
:
1727 if vm_network
['name'] == vmname
:
1728 #Assign IP Address based on MAC Address in NSX DHCP lease info
1729 for mac_adres
,ip_adres
in mac_ip_addr
.iteritems():
1730 if mac_adres
== vm_network
['mac']:
1731 vm_network
['ip']=ip_adres
1732 interface
= {"mac_address": vm_network
['mac'],
1733 "vim_net_id": self
.get_network_id_by_name(vm_network
['network_name']),
1734 "vim_interface_id": self
.get_network_id_by_name(vm_network
['network_name']),
1735 'ip_address': vm_network
['ip']}
1736 # interface['vim_info'] = yaml.safe_dump(vm_network)
1737 vm_dict
["interfaces"].append(interface
)
1738 # add a vm to vm dict
1739 vms_dict
.setdefault(vmuuid
, vm_dict
)
1741 self
.logger
.debug("Error in respond {}".format(KeyError.message
))
1742 self
.logger
.debug(traceback
.format_exc())
1746 def action_vminstance(self
, vm__vim_uuid
=None, action_dict
=None):
1747 """Send and action over a VM instance from VIM
1748 Returns the vm_id if the action was successfully sent to the VIM"""
1750 self
.logger
.debug("Received action for vm {} and action dict {}".format(vm__vim_uuid
, action_dict
))
1751 if vm__vim_uuid
is None or action_dict
is None:
1752 raise vimconn
.vimconnException("Invalid request. VM id or action is None.")
1754 vca
= self
.connect()
1756 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1758 vdc
= vca
.get_vdc(self
.tenant_name
)
1760 return -1, "Failed to get a reference of VDC for a tenant {}".format(self
.tenant_name
)
1762 vapp_name
= self
.get_namebyvappid(vca
, vdc
, vm__vim_uuid
)
1763 if vapp_name
is None:
1764 self
.logger
.debug("action_vminstance(): Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1765 raise vimconn
.vimconnException("Failed to get vm by given {} vm uuid".format(vm__vim_uuid
))
1767 self
.logger
.info("Action_vminstance vApp {} and UUID {}".format(vapp_name
, vm__vim_uuid
))
1770 the_vapp
= vca
.get_vapp(vdc
, vapp_name
)
1771 # TODO fix all status
1772 if "start" in action_dict
:
1773 vm_info
= the_vapp
.get_vms_details()
1774 vm_status
= vm_info
[0]['status']
1775 self
.logger
.info("Power on vApp: vm_status:{} {}".format(type(vm_status
),vm_status
))
1776 if vm_status
== "Suspended" or vm_status
== "Powered off":
1777 power_on_task
= the_vapp
.poweron()
1778 if power_on_task
is not None and type(power_on_task
) is GenericTask
:
1779 result
= vca
.block_until_completed(power_on_task
)
1781 self
.logger
.info("action_vminstance: Powered on vApp: {}".format(vapp_name
))
1783 self
.logger
.info("action_vminstance: Failed to power on vApp: {}".format(vapp_name
))
1785 self
.logger
.info("action_vminstance: Wait for vApp {} to power on".format(vapp_name
))
1786 elif "rebuild" in action_dict
:
1787 self
.logger
.info("action_vminstance: Rebuilding vApp: {}".format(vapp_name
))
1788 power_on_task
= the_vapp
.deploy(powerOn
=True)
1789 if type(power_on_task
) is GenericTask
:
1790 result
= vca
.block_until_completed(power_on_task
)
1792 self
.logger
.info("action_vminstance: Rebuilt vApp: {}".format(vapp_name
))
1794 self
.logger
.info("action_vminstance: Failed to rebuild vApp: {}".format(vapp_name
))
1796 self
.logger
.info("action_vminstance: Wait for vApp rebuild {} to power on".format(vapp_name
))
1797 elif "pause" in action_dict
:
1800 elif "resume" in action_dict
:
1803 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1804 power_off_task
= the_vapp
.undeploy(action
='powerOff')
1805 if type(power_off_task
) is GenericTask
:
1806 result
= vca
.block_until_completed(power_off_task
)
1808 self
.logger
.info("action_vminstance: Powered off vApp: {}".format(vapp_name
))
1810 self
.logger
.info("action_vminstance: Failed to power off vApp: {}".format(vapp_name
))
1812 self
.logger
.info("action_vminstance: Wait for vApp {} to power off".format(vapp_name
))
1813 elif "forceOff" in action_dict
:
1815 elif "terminate" in action_dict
:
1817 # elif "createImage" in action_dict:
1818 # server.create_image()
1824 def get_vminstance_console(self
, vm_id
, console_type
="vnc"):
1826 Get a console for the virtual machine
1828 vm_id: uuid of the VM
1829 console_type, can be:
1830 "novnc" (by default), "xvpvnc" for VNC types,
1831 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1832 Returns dict with the console parameters:
1833 protocol: ssh, ftp, http, https, ...
1834 server: usually ip address
1835 port: the http, ssh, ... port
1836 suffix: extra text, e.g. the http path and query string
1838 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1840 # NOT USED METHODS in current version
1842 def host_vim2gui(self
, host
, server_dict
):
1843 """Transform host dictionary from VIM format to GUI format,
1844 and append to the server_dict
1846 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1848 def get_hosts_info(self
):
1849 """Get the information of deployed hosts
1850 Returns the hosts content"""
1851 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1853 def get_hosts(self
, vim_tenant
):
1854 """Get the hosts and deployed instances
1855 Returns the hosts content"""
1856 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1858 def get_processor_rankings(self
):
1859 """Get the processor rankings in the VIM database"""
1860 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1862 def new_host(self
, host_data
):
1863 """Adds a new host to VIM"""
1864 '''Returns status code of the VIM response'''
1865 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1867 def new_external_port(self
, port_data
):
1868 """Adds a external port to VIM"""
1869 '''Returns the port identifier'''
1870 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1872 def new_external_network(self
, net_name
, net_type
):
1873 """Adds a external network to VIM (shared)"""
1874 '''Returns the network identifier'''
1875 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1877 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1878 """Connects a external port to a network"""
1879 '''Returns status code of the VIM response'''
1880 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1882 def new_vminstancefromJSON(self
, vm_data
):
1883 """Adds a VM instance to VIM"""
1884 '''Returns the instance identifier'''
1885 raise vimconn
.vimconnNotImplemented("Should have implemented this")
1887 def get_network_name_by_id(self
, network_uuid
=None):
1888 """Method gets vcloud director network named based on supplied uuid.
1891 network_uuid: network_id
1894 The return network name.
1897 vca
= self
.connect()
1899 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1901 if not network_uuid
:
1905 org_dict
= self
.get_org(self
.org_uuid
)
1906 if 'networks' in org_dict
:
1907 org_network_dict
= org_dict
['networks']
1908 for net_uuid
in org_network_dict
:
1909 if net_uuid
== network_uuid
:
1910 return org_network_dict
[net_uuid
]
1912 self
.logger
.debug("Exception in get_network_name_by_id")
1913 self
.logger
.debug(traceback
.format_exc())
1917 def get_network_id_by_name(self
, network_name
=None):
1918 """Method gets vcloud director network uuid based on supplied name.
1921 network_name: network_name
1923 The return network uuid.
1924 network_uuid: network_id
1927 vca
= self
.connect()
1929 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
1931 if not network_name
:
1932 self
.logger
.debug("get_network_id_by_name() : Network name is empty")
1936 org_dict
= self
.get_org(self
.org_uuid
)
1937 if org_dict
and 'networks' in org_dict
:
1938 org_network_dict
= org_dict
['networks']
1939 for net_uuid
,net_name
in org_network_dict
.iteritems():
1940 if net_name
== network_name
:
1943 except KeyError as exp
:
1944 self
.logger
.debug("get_network_id_by_name() : KeyError- {} ".format(exp
))
1948 def list_org_action(self
):
1950 Method leverages vCloud director and query for available organization for particular user
1953 vca - is active VCA connection.
1954 vdc_name - is a vdc name that will be used to query vms action
1957 The return XML respond
1960 vca
= self
.connect()
1962 raise vimconn
.vimconnConnectionException("self.connect() is failed")
1964 url_list
= [vca
.host
, '/api/org']
1965 vm_list_rest_call
= ''.join(url_list
)
1967 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
1968 response
= Http
.get(url
=vm_list_rest_call
,
1969 headers
=vca
.vcloud_session
.get_vcloud_headers(),
1972 if response
.status_code
== requests
.codes
.ok
:
1973 return response
.content
1977 def get_org_action(self
, org_uuid
=None):
1979 Method leverages vCloud director and retrieve available object fdr organization.
1982 vca - is active VCA connection.
1983 vdc_name - is a vdc name that will be used to query vms action
1986 The return XML respond
1989 vca
= self
.connect()
1991 raise vimconn
.vimconnConnectionException("self.connect() is failed")
1993 if org_uuid
is None:
1996 url_list
= [vca
.host
, '/api/org/', org_uuid
]
1997 vm_list_rest_call
= ''.join(url_list
)
1999 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2000 response
= Http
.get(url
=vm_list_rest_call
,
2001 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2004 if response
.status_code
== requests
.codes
.ok
:
2005 return response
.content
2009 def get_org(self
, org_uuid
=None):
2011 Method retrieves available organization in vCloud Director
2014 org_uuid - is a organization uuid.
2017 The return dictionary with following key
2018 "network" - for network list under the org
2019 "catalogs" - for network list under the org
2020 "vdcs" - for vdc list under org
2024 vca
= self
.connect()
2026 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2028 if org_uuid
is None:
2031 content
= self
.get_org_action(org_uuid
=org_uuid
)
2036 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2037 for child
in vm_list_xmlroot
:
2038 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.vdc+xml':
2039 vdc_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2040 org_dict
['vdcs'] = vdc_list
2041 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.orgNetwork+xml':
2042 network_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2043 org_dict
['networks'] = network_list
2044 if child
.attrib
['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
2045 catalog_list
[child
.attrib
['href'].split("/")[-1:][0]] = child
.attrib
['name']
2046 org_dict
['catalogs'] = catalog_list
2052 def get_org_list(self
):
2054 Method retrieves available organization in vCloud Director
2057 vca - is active VCA connection.
2060 The return dictionary and key for each entry VDC UUID
2064 vca
= self
.connect()
2066 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2068 content
= self
.list_org_action()
2070 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2071 for vm_xml
in vm_list_xmlroot
:
2072 if vm_xml
.tag
.split("}")[1] == 'Org':
2073 org_uuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2074 org_dict
[org_uuid
[0]] = vm_xml
.attrib
['name']
2080 def vms_view_action(self
, vdc_name
=None):
2081 """ Method leverages vCloud director vms query call
2084 vca - is active VCA connection.
2085 vdc_name - is a vdc name that will be used to query vms action
2088 The return XML respond
2090 vca
= self
.connect()
2091 if vdc_name
is None:
2094 url_list
= [vca
.host
, '/api/vms/query']
2095 vm_list_rest_call
= ''.join(url_list
)
2097 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2098 refs
= filter(lambda ref
: ref
.name
== vdc_name
and ref
.type_
== 'application/vnd.vmware.vcloud.vdc+xml',
2099 vca
.vcloud_session
.organization
.Link
)
2101 response
= Http
.get(url
=vm_list_rest_call
,
2102 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2105 if response
.status_code
== requests
.codes
.ok
:
2106 return response
.content
2110 def get_vapp_list(self
, vdc_name
=None):
2112 Method retrieves vApp list deployed vCloud director and returns a dictionary
2113 contains a list of all vapp deployed for queried VDC.
2114 The key for a dictionary is vApp UUID
2118 vca - is active VCA connection.
2119 vdc_name - is a vdc name that will be used to query vms action
2122 The return dictionary and key for each entry vapp UUID
2126 if vdc_name
is None:
2129 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2131 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2132 for vm_xml
in vm_list_xmlroot
:
2133 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
2134 if vm_xml
.attrib
['isVAppTemplate'] == 'true':
2135 rawuuid
= vm_xml
.attrib
['container'].split('/')[-1:]
2136 if 'vappTemplate-' in rawuuid
[0]:
2137 # vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
2138 # vm and use raw UUID as key
2139 vapp_dict
[rawuuid
[0][13:]] = vm_xml
.attrib
2145 def get_vm_list(self
, vdc_name
=None):
2147 Method retrieves VM's list deployed vCloud director. It returns a dictionary
2148 contains a list of all VM's deployed for queried VDC.
2149 The key for a dictionary is VM UUID
2153 vca - is active VCA connection.
2154 vdc_name - is a vdc name that will be used to query vms action
2157 The return dictionary and key for each entry vapp UUID
2161 if vdc_name
is None:
2164 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2166 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2167 for vm_xml
in vm_list_xmlroot
:
2168 if vm_xml
.tag
.split("}")[1] == 'VMRecord':
2169 if vm_xml
.attrib
['isVAppTemplate'] == 'false':
2170 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2171 if 'vm-' in rawuuid
[0]:
2172 # vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
2173 # vm and use raw UUID as key
2174 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2180 def get_vapp(self
, vdc_name
=None, vapp_name
=None, isuuid
=False):
2182 Method retrieves VM deployed vCloud director. It returns VM attribute as dictionary
2183 contains a list of all VM's deployed for queried VDC.
2184 The key for a dictionary is VM UUID
2188 vca - is active VCA connection.
2189 vdc_name - is a vdc name that will be used to query vms action
2192 The return dictionary and key for each entry vapp UUID
2195 vca
= self
.connect()
2197 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2199 if vdc_name
is None:
2202 content
= self
.vms_view_action(vdc_name
=vdc_name
)
2204 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2205 for vm_xml
in vm_list_xmlroot
:
2206 if vm_xml
.tag
.split("}")[1] == 'VMRecord' and vm_xml
.attrib
['isVAppTemplate'] == 'false':
2207 # lookup done by UUID
2209 if vapp_name
in vm_xml
.attrib
['container']:
2210 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2211 if 'vm-' in rawuuid
[0]:
2212 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2214 # lookup done by Name
2216 if vapp_name
in vm_xml
.attrib
['name']:
2217 rawuuid
= vm_xml
.attrib
['href'].split('/')[-1:]
2218 if 'vm-' in rawuuid
[0]:
2219 vm_dict
[rawuuid
[0][3:]] = vm_xml
.attrib
2226 def get_network_action(self
, network_uuid
=None):
2228 Method leverages vCloud director and query network based on network uuid
2231 vca - is active VCA connection.
2232 network_uuid - is a network uuid
2235 The return XML respond
2238 vca
= self
.connect()
2240 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2242 if network_uuid
is None:
2245 url_list
= [vca
.host
, '/api/network/', network_uuid
]
2246 vm_list_rest_call
= ''.join(url_list
)
2248 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2249 response
= Http
.get(url
=vm_list_rest_call
,
2250 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2253 if response
.status_code
== requests
.codes
.ok
:
2254 return response
.content
2258 def get_vcd_network(self
, network_uuid
=None):
2260 Method retrieves available network from vCloud Director
2263 network_uuid - is VCD network UUID
2265 Each element serialized as key : value pair
2267 Following keys available for access. network_configuration['Gateway'}
2271 <IsInherited>true</IsInherited>
2272 <Gateway>172.16.252.100</Gateway>
2273 <Netmask>255.255.255.0</Netmask>
2274 <Dns1>172.16.254.201</Dns1>
2275 <Dns2>172.16.254.202</Dns2>
2276 <DnsSuffix>vmwarelab.edu</DnsSuffix>
2277 <IsEnabled>true</IsEnabled>
2280 <StartAddress>172.16.252.1</StartAddress>
2281 <EndAddress>172.16.252.99</EndAddress>
2286 <FenceMode>bridged</FenceMode>
2289 The return dictionary and key for each entry vapp UUID
2292 network_configuration
= {}
2293 if network_uuid
is None:
2296 content
= self
.get_network_action(network_uuid
=network_uuid
)
2298 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2300 network_configuration
['status'] = vm_list_xmlroot
.get("status")
2301 network_configuration
['name'] = vm_list_xmlroot
.get("name")
2302 network_configuration
['uuid'] = vm_list_xmlroot
.get("id").split(":")[3]
2304 for child
in vm_list_xmlroot
:
2305 if child
.tag
.split("}")[1] == 'IsShared':
2306 network_configuration
['isShared'] = child
.text
.strip()
2307 if child
.tag
.split("}")[1] == 'Configuration':
2308 for configuration
in child
.iter():
2309 tagKey
= configuration
.tag
.split("}")[1].strip()
2311 network_configuration
[tagKey
] = configuration
.text
.strip()
2312 return network_configuration
2316 return network_configuration
2318 def delete_network_action(self
, network_uuid
=None):
2320 Method delete given network from vCloud director
2323 network_uuid - is a network uuid that client wish to delete
2326 The return None or XML respond or false
2329 vca
= self
.connect_as_admin()
2331 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2332 if network_uuid
is None:
2335 url_list
= [vca
.host
, '/api/admin/network/', network_uuid
]
2336 vm_list_rest_call
= ''.join(url_list
)
2338 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2339 response
= Http
.delete(url
=vm_list_rest_call
,
2340 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2344 if response
.status_code
== 202:
2349 def create_network(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
2350 ip_profile
=None, isshared
='true'):
2352 Method create network in vCloud director
2355 network_name - is network name to be created.
2356 net_type - can be 'bridge','data','ptp','mgmt'.
2357 ip_profile is a dict containing the IP parameters of the network
2358 isshared - is a boolean
2359 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2360 It optional attribute. by default if no parent network indicate the first available will be used.
2363 The return network uuid or return None
2366 new_network_name
= [network_name
, '-', str(uuid
.uuid4())]
2367 content
= self
.create_network_rest(network_name
=''.join(new_network_name
),
2368 ip_profile
=ip_profile
,
2370 parent_network_uuid
=parent_network_uuid
,
2373 self
.logger
.debug("Failed create network {}.".format(network_name
))
2377 vm_list_xmlroot
= XmlElementTree
.fromstring(content
)
2378 vcd_uuid
= vm_list_xmlroot
.get('id').split(":")
2379 if len(vcd_uuid
) == 4:
2380 self
.logger
.info("Create new network name: {} uuid: {}".format(network_name
, vcd_uuid
[3]))
2383 self
.logger
.debug("Failed create network {}".format(network_name
))
2386 def create_network_rest(self
, network_name
=None, net_type
='bridge', parent_network_uuid
=None,
2387 ip_profile
=None, isshared
='true'):
2389 Method create network in vCloud director
2392 network_name - is network name to be created.
2393 net_type - can be 'bridge','data','ptp','mgmt'.
2394 ip_profile is a dict containing the IP parameters of the network
2395 isshared - is a boolean
2396 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2397 It optional attribute. by default if no parent network indicate the first available will be used.
2400 The return network uuid or return None
2403 vca
= self
.connect_as_admin()
2405 raise vimconn
.vimconnConnectionException("self.connect() is failed.")
2406 if network_name
is None:
2409 url_list
= [vca
.host
, '/api/admin/vdc/', self
.tenant_id
]
2410 vm_list_rest_call
= ''.join(url_list
)
2411 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2412 response
= Http
.get(url
=vm_list_rest_call
,
2413 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2417 provider_network
= None
2418 available_networks
= None
2419 add_vdc_rest_url
= None
2421 if response
.status_code
!= requests
.codes
.ok
:
2422 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
2423 response
.status_code
))
2427 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
2428 for child
in vm_list_xmlroot
:
2429 if child
.tag
.split("}")[1] == 'ProviderVdcReference':
2430 provider_network
= child
.attrib
.get('href')
2431 # application/vnd.vmware.admin.providervdc+xml
2432 if child
.tag
.split("}")[1] == 'Link':
2433 if child
.attrib
.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
2434 and child
.attrib
.get('rel') == 'add':
2435 add_vdc_rest_url
= child
.attrib
.get('href')
2437 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
2438 self
.logger
.debug("Respond body {}".format(response
.content
))
2441 # find pvdc provided available network
2442 response
= Http
.get(url
=provider_network
,
2443 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2446 if response
.status_code
!= requests
.codes
.ok
:
2447 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
2448 response
.status_code
))
2451 # available_networks.split("/")[-1]
2453 if parent_network_uuid
is None:
2455 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
2456 for child
in vm_list_xmlroot
.iter():
2457 if child
.tag
.split("}")[1] == 'AvailableNetworks':
2458 for networks
in child
.iter():
2459 # application/vnd.vmware.admin.network+xml
2460 if networks
.attrib
.get('href') is not None:
2461 available_networks
= networks
.attrib
.get('href')
2466 #Configure IP profile of the network
2467 ip_profile
= ip_profile
if ip_profile
is not None else DEFAULT_IP_PROFILE
2469 gateway_address
=ip_profile
['gateway_address']
2470 dhcp_count
=int(ip_profile
['dhcp_count'])
2471 subnet_address
=self
.convert_cidr_to_netmask(ip_profile
['subnet_address'])
2473 if ip_profile
['dhcp_enabled']==True:
2476 dhcp_enabled
='false'
2477 dhcp_start_address
=ip_profile
['dhcp_start_address']
2479 #derive dhcp_end_address from dhcp_start_address & dhcp_count
2480 end_ip_int
= int(netaddr
.IPAddress(dhcp_start_address
))
2481 end_ip_int
+= dhcp_count
- 1
2482 dhcp_end_address
= str(netaddr
.IPAddress(end_ip_int
))
2484 ip_version
=ip_profile
['ip_version']
2485 dns_address
=ip_profile
['dns_address']
2487 # either use client provided UUID or search for a first available
2488 # if both are not defined we return none
2489 if parent_network_uuid
is not None:
2490 url_list
= [vca
.host
, '/api/admin/network/', parent_network_uuid
]
2491 add_vdc_rest_url
= ''.join(url_list
)
2494 fence_mode
="isolated"
2496 is_inherited
='false'
2497 data
= """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
2498 <Description>Openmano created</Description>
2502 <IsInherited>{1:s}</IsInherited>
2503 <Gateway>{2:s}</Gateway>
2504 <Netmask>{3:s}</Netmask>
2506 <IsEnabled>{5:s}</IsEnabled>
2509 <StartAddress>{6:s}</StartAddress>
2510 <EndAddress>{7:s}</EndAddress>
2515 <FenceMode>{8:s}</FenceMode>
2517 <IsShared>{9:s}</IsShared>
2518 </OrgVdcNetwork> """.format(escape(network_name
), is_inherited
, gateway_address
,
2519 subnet_address
, dns_address
, dhcp_enabled
,
2520 dhcp_start_address
, dhcp_end_address
, fence_mode
, isshared
)
2523 fence_mode
="bridged"
2524 is_inherited
='false'
2525 data
= """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
2526 <Description>Openmano created</Description>
2530 <IsInherited>{1:s}</IsInherited>
2531 <Gateway>{2:s}</Gateway>
2532 <Netmask>{3:s}</Netmask>
2534 <IsEnabled>{5:s}</IsEnabled>
2537 <StartAddress>{6:s}</StartAddress>
2538 <EndAddress>{7:s}</EndAddress>
2543 <ParentNetwork href="{8:s}"/>
2544 <FenceMode>{9:s}</FenceMode>
2546 <IsShared>{10:s}</IsShared>
2547 </OrgVdcNetwork> """.format(escape(network_name
), is_inherited
, gateway_address
,
2548 subnet_address
, dns_address
, dhcp_enabled
,
2549 dhcp_start_address
, dhcp_end_address
, available_networks
,
2550 fence_mode
, isshared
)
2552 headers
= vca
.vcloud_session
.get_vcloud_headers()
2553 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
2555 response
= Http
.post(url
=add_vdc_rest_url
,
2561 if response
.status_code
!= 201:
2562 self
.logger
.debug("Create Network POST REST API call failed. Return status code {}"
2563 .format(response
.status_code
))
2565 network
= networkType
.parseString(response
.content
, True)
2566 create_nw_task
= network
.get_Tasks().get_Task()[0]
2568 # if we all ok we respond with content after network creation completes
2569 # otherwise by default return None
2570 if create_nw_task
is not None:
2571 self
.logger
.debug("Create Network REST : Waiting for Nw creation complete")
2572 status
= vca
.block_until_completed(create_nw_task
)
2574 return response
.content
2576 self
.logger
.debug("create_network_rest task failed. Network Create response : {}"
2577 .format(response
.content
))
2578 except Exception as exp
:
2579 self
.logger
.debug("create_network_rest : Exception : {} ".format(exp
))
2583 def convert_cidr_to_netmask(self
, cidr_ip
=None):
2585 Method sets convert CIDR netmask address to normal IP format
2587 cidr_ip : CIDR IP address
2589 netmask : Converted netmask
2591 if cidr_ip
is not None:
2593 network
, net_bits
= cidr_ip
.split('/')
2594 netmask
= socket
.inet_ntoa(struct
.pack(">I", (0xffffffff << (32 - int(net_bits
))) & 0xffffffff))
2600 def get_provider_rest(self
, vca
=None):
2602 Method gets provider vdc view from vcloud director
2605 network_name - is network name to be created.
2606 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2607 It optional attribute. by default if no parent network indicate the first available will be used.
2610 The return xml content of respond or None
2613 url_list
= [vca
.host
, '/api/admin']
2614 response
= Http
.get(url
=''.join(url_list
),
2615 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2619 if response
.status_code
== requests
.codes
.ok
:
2620 return response
.content
2623 def create_vdc(self
, vdc_name
=None):
2627 xml_content
= self
.create_vdc_from_tmpl_rest(vdc_name
=vdc_name
)
2628 if xml_content
is not None:
2630 task_resp_xmlroot
= XmlElementTree
.fromstring(xml_content
)
2631 for child
in task_resp_xmlroot
:
2632 if child
.tag
.split("}")[1] == 'Owner':
2633 vdc_id
= child
.attrib
.get('href').split("/")[-1]
2634 vdc_dict
[vdc_id
] = task_resp_xmlroot
.get('href')
2637 self
.logger
.debug("Respond body {}".format(xml_content
))
2641 def create_vdc_from_tmpl_rest(self
, vdc_name
=None):
2643 Method create vdc in vCloud director based on VDC template.
2644 it uses pre-defined template that must be named openmano
2647 vdc_name - name of a new vdc.
2650 The return xml content of respond or None
2653 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
2654 vca
= self
.connect()
2656 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2657 if vdc_name
is None:
2660 url_list
= [vca
.host
, '/api/vdcTemplates']
2661 vm_list_rest_call
= ''.join(url_list
)
2662 response
= Http
.get(url
=vm_list_rest_call
,
2663 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2667 # container url to a template
2668 vdc_template_ref
= None
2670 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
2671 for child
in vm_list_xmlroot
:
2672 # application/vnd.vmware.admin.providervdc+xml
2673 # we need find a template from witch we instantiate VDC
2674 if child
.tag
.split("}")[1] == 'VdcTemplate':
2675 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml' and child
.attrib
.get(
2676 'name') == 'openmano':
2677 vdc_template_ref
= child
.attrib
.get('href')
2679 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
2680 self
.logger
.debug("Respond body {}".format(response
.content
))
2683 # if we didn't found required pre defined template we return None
2684 if vdc_template_ref
is None:
2689 url_list
= [vca
.host
, '/api/org/', self
.org_uuid
, '/action/instantiate']
2690 vm_list_rest_call
= ''.join(url_list
)
2691 data
= """<InstantiateVdcTemplateParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
2692 <Source href="{1:s}"></Source>
2693 <Description>opnemano</Description>
2694 </InstantiateVdcTemplateParams>""".format(vdc_name
, vdc_template_ref
)
2695 headers
= vca
.vcloud_session
.get_vcloud_headers()
2696 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVdcTemplateParams+xml'
2697 response
= Http
.post(url
=vm_list_rest_call
, headers
=headers
, data
=data
, verify
=vca
.verify
,
2699 # if we all ok we respond with content otherwise by default None
2700 if response
.status_code
>= 200 and response
.status_code
< 300:
2701 return response
.content
2704 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
2705 self
.logger
.debug("Respond body {}".format(response
.content
))
2709 def create_vdc_rest(self
, vdc_name
=None):
2711 Method create network in vCloud director
2714 network_name - is network name to be created.
2715 parent_network_uuid - is parent provider vdc network that will be used for mapping.
2716 It optional attribute. by default if no parent network indicate the first available will be used.
2719 The return network uuid or return None
2722 self
.logger
.info("Creating new vdc {}".format(vdc_name
))
2724 vca
= self
.connect_as_admin()
2726 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2727 if vdc_name
is None:
2730 url_list
= [vca
.host
, '/api/admin/org/', self
.org_uuid
]
2731 vm_list_rest_call
= ''.join(url_list
)
2732 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2733 response
= Http
.get(url
=vm_list_rest_call
,
2734 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2738 provider_vdc_ref
= None
2739 add_vdc_rest_url
= None
2740 available_networks
= None
2742 if response
.status_code
!= requests
.codes
.ok
:
2743 self
.logger
.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call
,
2744 response
.status_code
))
2748 vm_list_xmlroot
= XmlElementTree
.fromstring(response
.content
)
2749 for child
in vm_list_xmlroot
:
2750 # application/vnd.vmware.admin.providervdc+xml
2751 if child
.tag
.split("}")[1] == 'Link':
2752 if child
.attrib
.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
2753 and child
.attrib
.get('rel') == 'add':
2754 add_vdc_rest_url
= child
.attrib
.get('href')
2756 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
2757 self
.logger
.debug("Respond body {}".format(response
.content
))
2760 response
= self
.get_provider_rest(vca
=vca
)
2762 vm_list_xmlroot
= XmlElementTree
.fromstring(response
)
2763 for child
in vm_list_xmlroot
:
2764 if child
.tag
.split("}")[1] == 'ProviderVdcReferences':
2765 for sub_child
in child
:
2766 provider_vdc_ref
= sub_child
.attrib
.get('href')
2768 self
.logger
.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call
))
2769 self
.logger
.debug("Respond body {}".format(response
))
2772 if add_vdc_rest_url
is not None and provider_vdc_ref
is not None:
2773 data
= """ <CreateVdcParams name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5"><Description>{1:s}</Description>
2774 <AllocationModel>ReservationPool</AllocationModel>
2775 <ComputeCapacity><Cpu><Units>MHz</Units><Allocated>2048</Allocated><Limit>2048</Limit></Cpu>
2776 <Memory><Units>MB</Units><Allocated>2048</Allocated><Limit>2048</Limit></Memory>
2777 </ComputeCapacity><NicQuota>0</NicQuota><NetworkQuota>100</NetworkQuota>
2778 <VdcStorageProfile><Enabled>true</Enabled><Units>MB</Units><Limit>20480</Limit><Default>true</Default></VdcStorageProfile>
2779 <ProviderVdcReference
2780 name="Main Provider"
2782 <UsesFastProvisioning>true</UsesFastProvisioning></CreateVdcParams>""".format(escape(vdc_name
),
2786 headers
= vca
.vcloud_session
.get_vcloud_headers()
2787 headers
['Content-Type'] = 'application/vnd.vmware.admin.createVdcParams+xml'
2788 response
= Http
.post(url
=add_vdc_rest_url
, headers
=headers
, data
=data
, verify
=vca
.verify
,
2791 # if we all ok we respond with content otherwise by default None
2792 if response
.status_code
== 201:
2793 return response
.content
2796 def get_vapp_details_rest(self
, vapp_uuid
=None, need_admin_access
=False):
2798 Method retrieve vapp detail from vCloud director
2801 vapp_uuid - is vapp identifier.
2804 The return network uuid or return None
2810 if need_admin_access
:
2811 vca
= self
.connect_as_admin()
2813 vca
= self
.connect()
2816 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2817 if vapp_uuid
is None:
2820 url_list
= [vca
.host
, '/api/vApp/vapp-', vapp_uuid
]
2821 get_vapp_restcall
= ''.join(url_list
)
2823 if vca
.vcloud_session
and vca
.vcloud_session
.organization
:
2824 response
= Http
.get(url
=get_vapp_restcall
,
2825 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2829 if response
.status_code
!= requests
.codes
.ok
:
2830 self
.logger
.debug("REST API call {} failed. Return status code {}".format(get_vapp_restcall
,
2831 response
.status_code
))
2832 return parsed_respond
2835 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
2836 parsed_respond
['ovfDescriptorUploaded'] = xmlroot_respond
.attrib
['ovfDescriptorUploaded']
2838 namespaces
= {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
2839 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
2840 'vmw': 'http://www.vmware.com/schema/ovf',
2841 'vm': 'http://www.vmware.com/vcloud/v1.5',
2842 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
2843 "vmext":"http://www.vmware.com/vcloud/extension/v1.5",
2844 "xmlns":"http://www.vmware.com/vcloud/v1.5"
2847 created_section
= xmlroot_respond
.find('vm:DateCreated', namespaces
)
2848 if created_section
is not None:
2849 parsed_respond
['created'] = created_section
.text
2851 network_section
= xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig', namespaces
)
2852 if network_section
is not None and 'networkName' in network_section
.attrib
:
2853 parsed_respond
['networkname'] = network_section
.attrib
['networkName']
2855 ipscopes_section
= \
2856 xmlroot_respond
.find('vm:NetworkConfigSection/vm:NetworkConfig/vm:Configuration/vm:IpScopes',
2858 if ipscopes_section
is not None:
2859 for ipscope
in ipscopes_section
:
2860 for scope
in ipscope
:
2861 tag_key
= scope
.tag
.split("}")[1]
2862 if tag_key
== 'IpRanges':
2863 ip_ranges
= scope
.getchildren()
2864 for ipblock
in ip_ranges
:
2865 for block
in ipblock
:
2866 parsed_respond
[block
.tag
.split("}")[1]] = block
.text
2868 parsed_respond
[tag_key
] = scope
.text
2870 # parse children section for other attrib
2871 children_section
= xmlroot_respond
.find('vm:Children/', namespaces
)
2872 if children_section
is not None:
2873 parsed_respond
['name'] = children_section
.attrib
['name']
2874 parsed_respond
['nestedHypervisorEnabled'] = children_section
.attrib
['nestedHypervisorEnabled'] \
2875 if "nestedHypervisorEnabled" in children_section
.attrib
else None
2876 parsed_respond
['deployed'] = children_section
.attrib
['deployed']
2877 parsed_respond
['status'] = children_section
.attrib
['status']
2878 parsed_respond
['vmuuid'] = children_section
.attrib
['id'].split(":")[-1]
2879 network_adapter
= children_section
.find('vm:NetworkConnectionSection', namespaces
)
2881 for adapters
in network_adapter
:
2882 adapter_key
= adapters
.tag
.split("}")[1]
2883 if adapter_key
== 'PrimaryNetworkConnectionIndex':
2884 parsed_respond
['primarynetwork'] = adapters
.text
2885 if adapter_key
== 'NetworkConnection':
2887 if 'network' in adapters
.attrib
:
2888 vnic
['network'] = adapters
.attrib
['network']
2889 for adapter
in adapters
:
2890 setting_key
= adapter
.tag
.split("}")[1]
2891 vnic
[setting_key
] = adapter
.text
2892 nic_list
.append(vnic
)
2894 for link
in children_section
:
2895 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
2896 if link
.attrib
['rel'] == 'screen:acquireTicket':
2897 parsed_respond
['acquireTicket'] = link
.attrib
2898 if link
.attrib
['rel'] == 'screen:acquireMksTicket':
2899 parsed_respond
['acquireMksTicket'] = link
.attrib
2901 parsed_respond
['interfaces'] = nic_list
2902 vCloud_extension_section
= children_section
.find('xmlns:VCloudExtension', namespaces
)
2903 if vCloud_extension_section
is not None:
2904 vm_vcenter_info
= {}
2905 vim_info
= vCloud_extension_section
.find('vmext:VmVimInfo', namespaces
)
2906 vmext
= vim_info
.find('vmext:VmVimObjectRef', namespaces
)
2907 if vmext
is not None:
2908 vm_vcenter_info
["vm_moref_id"] = vmext
.find('vmext:MoRef', namespaces
).text
2909 vm_vcenter_info
["vim_server_href"] = vmext
.find('vmext:VimServerRef', namespaces
).attrib
['href']
2910 parsed_respond
["vm_vcenter_info"]= vm_vcenter_info
2912 virtual_hardware_section
= children_section
.find('ovf:VirtualHardwareSection', namespaces
)
2913 vm_virtual_hardware_info
= {}
2914 if virtual_hardware_section
is not None:
2915 for item
in virtual_hardware_section
.iterfind('ovf:Item',namespaces
):
2916 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
2917 disk_size
= item
.find("rasd:HostResource" ,namespaces
2918 ).attrib
["{"+namespaces
['vm']+"}capacity"]
2920 vm_virtual_hardware_info
["disk_size"]= disk_size
2923 for link
in virtual_hardware_section
:
2924 if link
.tag
.split("}")[1] == 'Link' and 'rel' in link
.attrib
:
2925 if link
.attrib
['rel'] == 'edit' and link
.attrib
['href'].endswith("/disks"):
2926 vm_virtual_hardware_info
["disk_edit_href"] = link
.attrib
['href']
2929 parsed_respond
["vm_virtual_hardware"]= vm_virtual_hardware_info
2930 except Exception as exp
:
2931 self
.logger
.info("Error occurred calling rest api for getting vApp details {}".format(exp
))
2932 return parsed_respond
2934 def acuire_console(self
, vm_uuid
=None):
2936 vca
= self
.connect()
2938 raise vimconn
.vimconnConnectionException("self.connect() is failed")
2942 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
2943 vm_dict
= self
.get_vapp_details_rest(self
, vapp_uuid
=vm_uuid
)
2944 console_dict
= vm_dict
['acquireTicket']
2945 console_rest_call
= console_dict
['href']
2947 response
= Http
.post(url
=console_rest_call
,
2948 headers
=vca
.vcloud_session
.get_vcloud_headers(),
2952 if response
.status_code
== requests
.codes
.ok
:
2953 return response
.content
2957 def modify_vm_disk(self
, vapp_uuid
, flavor_disk
):
2959 Method retrieve vm disk details
2962 vapp_uuid - is vapp identifier.
2963 flavor_disk - disk size as specified in VNFD (flavor)
2966 The return network uuid or return None
2970 #Flavor disk is in GB convert it into MB
2971 flavor_disk
= int(flavor_disk
) * 1024
2972 vm_details
= self
.get_vapp_details_rest(vapp_uuid
)
2974 vm_name
= vm_details
["name"]
2975 self
.logger
.info("VM: {} flavor_disk :{}".format(vm_name
, flavor_disk
))
2977 if vm_details
and "vm_virtual_hardware" in vm_details
:
2978 vm_disk
= int(vm_details
["vm_virtual_hardware"]["disk_size"])
2979 disk_edit_href
= vm_details
["vm_virtual_hardware"]["disk_edit_href"]
2981 self
.logger
.info("VM: {} VM_disk :{}".format(vm_name
, vm_disk
))
2983 if flavor_disk
> vm_disk
:
2984 status
= self
.modify_vm_disk_rest(disk_edit_href
,flavor_disk
)
2985 self
.logger
.info("Modify disk of VM {} from {} to {} MB".format(vm_name
,
2986 vm_disk
, flavor_disk
))
2989 self
.logger
.info("No need to modify disk of VM {}".format(vm_name
))
2992 except Exception as exp
:
2993 self
.logger
.info("Error occurred while modifing disk size {}".format(exp
))
2996 def modify_vm_disk_rest(self
, disk_href
, disk_size
):
2998 Method retrieve modify vm disk size
3001 disk_href - vCD API URL to GET and PUT disk data
3002 disk_size - disk size as specified in VNFD (flavor)
3005 The return network uuid or return None
3007 vca
= self
.connect()
3009 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3010 if disk_href
is None or disk_size
is None:
3013 if vca
.vcloud_session
and vca
.vcloud_session
.organization
:
3014 response
= Http
.get(url
=disk_href
,
3015 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3019 if response
.status_code
!= requests
.codes
.ok
:
3020 self
.logger
.debug("GET REST API call {} failed. Return status code {}".format(disk_href
,
3021 response
.status_code
))
3024 lxmlroot_respond
= lxmlElementTree
.fromstring(response
.content
)
3025 namespaces
= {prefix
:uri
for prefix
,uri
in lxmlroot_respond
.nsmap
.iteritems() if prefix
}
3026 namespaces
["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
3028 for item
in lxmlroot_respond
.iterfind('xmlns:Item',namespaces
):
3029 if item
.find("rasd:Description",namespaces
).text
== "Hard disk":
3030 disk_item
= item
.find("rasd:HostResource" ,namespaces
)
3031 if disk_item
is not None:
3032 disk_item
.attrib
["{"+namespaces
['xmlns']+"}capacity"] = str(disk_size
)
3035 data
= lxmlElementTree
.tostring(lxmlroot_respond
, encoding
='utf8', method
='xml',
3036 xml_declaration
=True)
3038 #Send PUT request to modify disk size
3039 headers
= vca
.vcloud_session
.get_vcloud_headers()
3040 headers
['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
3042 response
= Http
.put(url
=disk_href
,
3045 verify
=vca
.verify
, logger
=self
.logger
)
3047 if response
.status_code
!= 202:
3048 self
.logger
.debug("PUT REST API call {} failed. Return status code {}".format(disk_href
,
3049 response
.status_code
))
3051 modify_disk_task
= taskType
.parseString(response
.content
, True)
3052 if type(modify_disk_task
) is GenericTask
:
3053 status
= vca
.block_until_completed(modify_disk_task
)
3058 except Exception as exp
:
3059 self
.logger
.info("Error occurred calling rest api for modifing disk size {}".format(exp
))
3062 def add_pci_devices(self
, vapp_uuid
, pci_devices
, vmname_andid
):
3064 Method to attach pci devices to VM
3067 vapp_uuid - uuid of vApp/VM
3068 pci_devices - pci devices infromation as specified in VNFD (flavor)
3071 The status of add pci device task , vm object and
3072 vcenter_conect object
3075 vcenter_conect
= None
3076 self
.logger
.info("Add pci devices {} into vApp {}".format(pci_devices
, vapp_uuid
))
3077 #Assuming password of vCenter user is same as password of vCloud user
3078 vm_moref_id
, vm_vcenter_host
, vm_vcenter_username
, vm_vcenter_port
= self
.get_vcenter_info_rest(vapp_uuid
)
3079 self
.logger
.info("vm_moref_id, {} vm_vcenter_host {} vm_vcenter_username{} "\
3080 "vm_vcenter_port{}".format(
3081 vm_moref_id
, vm_vcenter_host
,
3082 vm_vcenter_username
, vm_vcenter_port
))
3083 if vm_moref_id
and vm_vcenter_host
and vm_vcenter_username
:
3085 if hasattr(ssl
, '_create_unverified_context'):
3086 context
= ssl
._create
_unverified
_context
()
3088 no_of_pci_devices
= len(pci_devices
)
3089 if no_of_pci_devices
> 0:
3090 vcenter_conect
= SmartConnect(host
=vm_vcenter_host
, user
=vm_vcenter_username
,
3091 pwd
=self
.passwd
, port
=int(vm_vcenter_port
) ,
3093 atexit
.register(Disconnect
, vcenter_conect
)
3094 content
= vcenter_conect
.RetrieveContent()
3096 #Get VM and its host
3097 host_obj
, vm_obj
= self
.get_vm_obj(content
,vm_moref_id
)
3098 self
.logger
.info("VM {} is currently on host {}".format(vm_obj
, host_obj
))
3099 if host_obj
and vm_obj
:
3100 #get PCI devies from host on which vapp is currently installed
3101 avilable_pci_devices
= self
.get_pci_devices(host_obj
, no_of_pci_devices
)
3103 if avilable_pci_devices
is None:
3104 #find other hosts with active pci devices
3105 new_host_obj
, avilable_pci_devices
= self
.get_host_and_PCIdevices(
3110 if new_host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
3111 #Migrate vm to the host where PCI devices are availble
3112 self
.logger
.info("Relocate VM {} on new host {}".format(vm_obj
, new_host_obj
))
3113 task
= self
.relocate_vm(new_host_obj
, vm_obj
)
3114 if task
is not None:
3115 result
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
3116 self
.logger
.info("Migrate VM status: {}".format(result
))
3117 host_obj
= new_host_obj
3119 self
.logger
.info("Fail to migrate VM : {}".format(result
))
3120 raise vimconn
.vimconnNotFoundException(
3121 "Fail to migrate VM : {} to host {}".format(
3126 if host_obj
is not None and avilable_pci_devices
is not None and len(avilable_pci_devices
)> 0:
3127 #Add PCI devices one by one
3128 for pci_device
in avilable_pci_devices
:
3129 task
= self
.add_pci_to_vm(host_obj
, vm_obj
, pci_device
)
3131 status
= self
.wait_for_vcenter_task(task
, vcenter_conect
)
3133 self
.logger
.info("Added PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
3135 self
.logger
.info("Fail to add PCI device {} to VM {}".format(pci_device
,str(vm_obj
)))
3136 return True, vm_obj
, vcenter_conect
3138 self
.logger
.error("Currently there is no host with"\
3139 " {} number of avaialble PCI devices required for VM {}".format(
3143 raise vimconn
.vimconnNotFoundException(
3144 "Currently there is no host with {} "\
3145 "number of avaialble PCI devices required for VM {}".format(
3149 self
.logger
.debug("No infromation about PCI devices {} ",pci_devices
)
3151 except vmodl
.MethodFault
as error
:
3152 self
.logger
.error("Error occurred while adding PCI devices {} ",error
)
3153 return None, vm_obj
, vcenter_conect
3155 def get_vm_obj(self
, content
, mob_id
):
3157 Method to get the vsphere VM object associated with a given morf ID
3159 vapp_uuid - uuid of vApp/VM
3160 content - vCenter content object
3161 mob_id - mob_id of VM
3169 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
3170 [vim
.VirtualMachine
], True
3172 for vm
in container
.view
:
3173 mobID
= vm
._GetMoId
()
3176 host_obj
= vm_obj
.runtime
.host
3178 except Exception as exp
:
3179 self
.logger
.error("Error occurred while finding VM object : {}".format(exp
))
3180 return host_obj
, vm_obj
3182 def get_pci_devices(self
, host
, need_devices
):
3184 Method to get the details of pci devices on given host
3186 host - vSphere host object
3187 need_devices - number of pci devices needed on host
3190 array of pci devices
3194 used_devices_ids
= []
3198 pciPassthruInfo
= host
.config
.pciPassthruInfo
3199 pciDevies
= host
.hardware
.pciDevice
3201 for pci_status
in pciPassthruInfo
:
3202 if pci_status
.passthruActive
:
3203 for device
in pciDevies
:
3204 if device
.id == pci_status
.id:
3205 all_device_ids
.append(device
.id)
3206 all_devices
.append(device
)
3208 #check if devices are in use
3209 avalible_devices
= all_devices
3211 if vm
.runtime
.powerState
== vim
.VirtualMachinePowerState
.poweredOn
:
3212 vm_devices
= vm
.config
.hardware
.device
3213 for device
in vm_devices
:
3214 if type(device
) is vim
.vm
.device
.VirtualPCIPassthrough
:
3215 if device
.backing
.id in all_device_ids
:
3216 for use_device
in avalible_devices
:
3217 if use_device
.id == device
.backing
.id:
3218 avalible_devices
.remove(use_device
)
3219 used_devices_ids
.append(device
.backing
.id)
3220 self
.logger
.debug("Device {} from devices {}"\
3221 "is in use".format(device
.backing
.id,
3224 if len(avalible_devices
) < need_devices
:
3225 self
.logger
.debug("Host {} don't have {} number of active devices".format(host
,
3227 self
.logger
.debug("found only {} devives {}".format(len(avalible_devices
),
3231 required_devices
= avalible_devices
[:need_devices
]
3232 self
.logger
.info("Found {} PCI devivces on host {} but required only {}".format(
3233 len(avalible_devices
),
3236 self
.logger
.info("Retruning {} devices as {}".format(need_devices
,
3238 return required_devices
3240 except Exception as exp
:
3241 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host
))
3245 def get_host_and_PCIdevices(self
, content
, need_devices
):
3247 Method to get the details of pci devices infromation on all hosts
3250 content - vSphere host object
3251 need_devices - number of pci devices needed on host
3254 array of pci devices and host object
3257 pci_device_objs
= None
3260 container
= content
.viewManager
.CreateContainerView(content
.rootFolder
,
3261 [vim
.HostSystem
], True)
3262 for host
in container
.view
:
3263 devices
= self
.get_pci_devices(host
, need_devices
)
3266 pci_device_objs
= devices
3268 except Exception as exp
:
3269 self
.logger
.error("Error {} occurred while finding pci devices on host: {}".format(exp
, host_obj
))
3271 return host_obj
,pci_device_objs
3273 def relocate_vm(self
, dest_host
, vm
) :
3275 Method to get the relocate VM to new host
3278 dest_host - vSphere host object
3279 vm - vSphere VM object
3286 relocate_spec
= vim
.vm
.RelocateSpec(host
=dest_host
)
3287 task
= vm
.Relocate(relocate_spec
)
3288 self
.logger
.info("Migrating {} to destination host {}".format(vm
, dest_host
))
3289 except Exception as exp
:
3290 self
.logger
.error("Error occurred while relocate VM {} to new host {}: {}".format(
3291 dest_host
, vm
, exp
))
3294 def wait_for_vcenter_task(self
, task
, actionName
='job', hideResult
=False):
3296 Waits and provides updates on a vSphere task
3298 while task
.info
.state
== vim
.TaskInfo
.State
.running
:
3301 if task
.info
.state
== vim
.TaskInfo
.State
.success
:
3302 if task
.info
.result
is not None and not hideResult
:
3303 self
.logger
.info('{} completed successfully, result: {}'.format(
3307 self
.logger
.info('Task {} completed successfully.'.format(actionName
))
3309 self
.logger
.error('{} did not complete successfully: {} '.format(
3314 return task
.info
.result
3316 def add_pci_to_vm(self
,host_object
, vm_object
, host_pci_dev
):
3318 Method to add pci device in given VM
3321 host_object - vSphere host object
3322 vm_object - vSphere VM object
3323 host_pci_dev - host_pci_dev must be one of the devices from the
3324 host_object.hardware.pciDevice list
3325 which is configured as a PCI passthrough device
3331 if vm_object
and host_object
and host_pci_dev
:
3333 #Add PCI device to VM
3334 pci_passthroughs
= vm_object
.environmentBrowser
.QueryConfigTarget(host
=None).pciPassthrough
3335 systemid_by_pciid
= {item
.pciDevice
.id: item
.systemId
for item
in pci_passthroughs
}
3337 if host_pci_dev
.id not in systemid_by_pciid
:
3338 self
.logger
.error("Device {} is not a passthrough device ".format(host_pci_dev
))
3341 deviceId
= hex(host_pci_dev
.deviceId
% 2**16).lstrip('0x')
3342 backing
= vim
.VirtualPCIPassthroughDeviceBackingInfo(deviceId
=deviceId
,
3344 systemId
=systemid_by_pciid
[host_pci_dev
.id],
3345 vendorId
=host_pci_dev
.vendorId
,
3346 deviceName
=host_pci_dev
.deviceName
)
3348 hba_object
= vim
.VirtualPCIPassthrough(key
=-100, backing
=backing
)
3350 new_device_config
= vim
.VirtualDeviceConfigSpec(device
=hba_object
)
3351 new_device_config
.operation
= "add"
3352 vmConfigSpec
= vim
.vm
.ConfigSpec()
3353 vmConfigSpec
.deviceChange
= [new_device_config
]
3355 task
= vm_object
.ReconfigVM_Task(spec
=vmConfigSpec
)
3356 self
.logger
.info("Adding PCI device {} into VM {} from host {} ".format(
3357 host_pci_dev
, vm_object
, host_object
)
3359 except Exception as exp
:
3360 self
.logger
.error("Error occurred while adding pci devive {} to VM {}: {}".format(
3366 def get_vcenter_info_rest(self
, vapp_uuid
):
3368 https://192.169.241.105/api/admin/extension/vimServer/cc82baf9-9f80-4468-bfe9-ce42b3f9dde5
3369 Method to get details of vCenter
3372 vapp_uuid - uuid of vApp or VM
3375 Moref Id of VM and deails of vCenter
3379 vm_vcenter_username
= None
3380 vm_vcenter_port
= None
3382 vm_details
= self
.get_vapp_details_rest(vapp_uuid
, need_admin_access
=True)
3383 if vm_details
and "vm_vcenter_info" in vm_details
:
3384 vm_moref_id
= vm_details
["vm_vcenter_info"]["vm_moref_id"]
3385 vim_server_href
= vm_details
["vm_vcenter_info"]["vim_server_href"]
3388 vca
= self
.connect_as_admin()
3390 raise vimconn
.vimconnConnectionException("self.connect() is failed")
3391 if vim_server_href
is None:
3392 self
.logger
.error("No url to get vcenter details")
3394 if vca
.vcloud_session
and vca
.vcloud_session
.organization
:
3395 response
= Http
.get(url
=vim_server_href
,
3396 headers
=vca
.vcloud_session
.get_vcloud_headers(),
3400 if response
.status_code
!= requests
.codes
.ok
:
3401 self
.logger
.debug("GET REST API call {} failed. Return status code {}".format(vim_server_href
,
3402 response
.status_code
))
3404 namespaces
={"vmext":"http://www.vmware.com/vcloud/extension/v1.5",
3405 "vcloud":"http://www.vmware.com/vcloud/v1.5"
3407 xmlroot_respond
= XmlElementTree
.fromstring(response
.content
)
3408 vm_vcenter_username
= xmlroot_respond
.find('vmext:Username', namespaces
).text
3409 vcenter_url
= xmlroot_respond
.find('vmext:Url', namespaces
).text
3410 vm_vcenter_port
= vcenter_url
.split(":")[2]
3411 vm_vcenter
= vcenter_url
.split(":")[1].split("//")[1]
3413 except Exception as exp
:
3414 self
.logger
.info("Error occurred calling rest api for vcenter information {}".format(exp
))
3416 return vm_moref_id
, vm_vcenter
, vm_vcenter_username
, vm_vcenter_port
3419 def get_vm_pci_details(self
, vmuuid
):
3421 Method to get VM PCI device details from vCenter
3424 vm_obj - vSphere VM object
3427 dict of PCI devives attached to VM
3430 vm_pci_devices_info
= {}
3432 vm_moref_id
, vm_vcenter_host
, vm_vcenter_username
, vm_vcenter_port
= self
.get_vcenter_info_rest(vmuuid
)
3433 if vm_moref_id
and vm_vcenter_host
and vm_vcenter_username
:
3435 if hasattr(ssl
, '_create_unverified_context'):
3436 context
= ssl
._create
_unverified
_context
()
3437 vcenter_conect
= SmartConnect(host
=vm_vcenter_host
, user
=vm_vcenter_username
,
3438 pwd
=self
.passwd
, port
=int(vm_vcenter_port
),
3440 atexit
.register(Disconnect
, vcenter_conect
)
3441 content
= vcenter_conect
.RetrieveContent()
3443 #Get VM and its host
3444 host_obj
, vm_obj
= self
.get_vm_obj(content
,vm_moref_id
)
3445 for device
in vm_obj
.config
.hardware
.device
:
3446 if type(device
) == vim
.vm
.device
.VirtualPCIPassthrough
:
3447 device_details
={'devide_id':device
.backing
.id,
3448 'pciSlotNumber':device
.slotInfo
.pciSlotNumber
3450 vm_pci_devices_info
[device
.deviceInfo
.label
] = device_details
3451 except Exception as exp
:
3452 self
.logger
.info("Error occurred while getting PCI devices infromationn"\
3453 " for VM {} : {}".format(vm_obj
,exp
))
3454 return vm_pci_devices_info