Purely whitespace changes to clean up PEP-8 compliance
for this file.
Change-Id: I210e833b688e8b5a9d74a8ce27aef74edad3bb66
Signed-off-by: beierl <mbeierl@vmware.com>
# Copyright 2016-2019 VMware Inc.
# This file is part of ETSI OSM
# All Rights Reserved.
# Copyright 2016-2019 VMware Inc.
# This file is part of ETSI OSM
# All Rights Reserved.
#
# For those usages not covered by the Apache License, Version 2.0 please
# contact: osslegalrouting@vmware.com
#
# For those usages not covered by the Apache License, Version 2.0 please
# contact: osslegalrouting@vmware.com
"""
vimconn_vmware implementation an Abstract class in order to interact with VMware vCloud Director.
"""
vimconn_vmware implementation an Abstract class in order to interact with VMware vCloud Director.
-from progressbar import Percentage, Bar, ETA, FileTransferSpeed, ProgressBar
+from lxml import etree as lxmlElementTree
from osm_ro import vimconn
from osm_ro import vimconn
-import os
-import shutil
-import subprocess
-import tempfile
-import traceback
-import requests
-import ssl
-import atexit
-
-from pyVmomi import vim, vmodl
+from progressbar import Percentage, Bar, ETA, FileTransferSpeed, ProgressBar
from pyVim.connect import SmartConnect, Disconnect
from pyVim.connect import SmartConnect, Disconnect
-
-from xml.etree import ElementTree as XmlElementTree
-from lxml import etree as lxmlElementTree
-
-import yaml
-from pyvcloud.vcd.client import BasicLoginCredentials,Client,VcdTaskException
-from pyvcloud.vcd.vdc import VDC
+from pyVmomi import vim, vmodl # @UnresolvedImport
+from pyvcloud.vcd.client import BasicLoginCredentials, Client
from pyvcloud.vcd.org import Org
from pyvcloud.vcd.org import Org
from pyvcloud.vcd.vapp import VApp
from pyvcloud.vcd.vapp import VApp
+from pyvcloud.vcd.vdc import VDC
+from xml.etree import ElementTree as XmlElementTree
from xml.sax.saxutils import escape
from xml.sax.saxutils import escape
-import logging
-import json
-import time
-import uuid
-# import httplib
-#For python3
-#import http.client # TODO py3 check
-import socket
-import struct
+import json
+import logging
+import re
+import requests
+import shutil
+import socket
+import ssl
+import struct
+import subprocess
+import tempfile
+import time
+import traceback
+import uuid
+import yaml
# global variable for vcd connector type
STANDALONE = 'standalone'
# global variable for vcd connector type
STANDALONE = 'standalone'
FLAVOR_RAM_KEY = 'ram'
FLAVOR_VCPUS_KEY = 'vcpus'
FLAVOR_DISK_KEY = 'disk'
FLAVOR_RAM_KEY = 'ram'
FLAVOR_VCPUS_KEY = 'vcpus'
FLAVOR_DISK_KEY = 'disk'
-DEFAULT_IP_PROFILE = {'dhcp_count':50,
- 'dhcp_enabled':True,
- 'ip_version':"IPv4"
+DEFAULT_IP_PROFILE = {'dhcp_count': 50,
+ 'dhcp_enabled': True,
+ 'ip_version': "IPv4"
}
# global variable for wait time
INTERVAL_TIME = 5
}
# global variable for wait time
INTERVAL_TIME = 5
-__author__ = "Mustafa Bayramov, Arpita Kate, Sachin Bhangare, Prakash Kasar"
-__date__ = "$09-Mar-2018 11:09:29$"
-__version__ = '0.2'
-
# -1: "Could not be created",
# 0: "Unresolved",
# 1: "Resolved",
# -1: "Could not be created",
# 0: "Unresolved",
# 1: "Resolved",
-netStatus2manoFormat = {'ACTIVE': 'ACTIVE', 'PAUSED': 'PAUSED', 'INACTIVE': 'INACTIVE', 'BUILD': 'BUILD',
- 'ERROR': 'ERROR', 'DELETED': 'DELETED'
+netStatus2manoFormat = {'ACTIVE': 'ACTIVE',
+ 'PAUSED': 'PAUSED',
+ 'INACTIVE': 'INACTIVE',
+ 'BUILD': 'BUILD',
+ 'ERROR': 'ERROR',
+ 'DELETED': 'DELETED'
self.vcenter_user = config.get("vcenter_user", None)
self.vcenter_password = config.get("vcenter_password", None)
self.vcenter_user = config.get("vcenter_user", None)
self.vcenter_password = config.get("vcenter_password", None)
- #Set availability zone for Affinity rules
+ # Set availability zone for Affinity rules
self.availability_zone = self.set_availability_zones()
# ############# Stub code for SRIOV #################
self.availability_zone = self.set_availability_zones()
# ############# Stub code for SRIOV #################
"""
vdc_task = self.create_vdc(vdc_name=tenant_name)
if vdc_task is not None:
"""
vdc_task = self.create_vdc(vdc_name=tenant_name)
if vdc_task is not None:
- vdc_uuid, value = vdc_task.popitem()
+ vdc_uuid, _ = vdc_task.popitem()
self.logger.info("Created new vdc {} and uuid: {}".format(tenant_name, vdc_uuid))
return vdc_uuid
else:
self.logger.info("Created new vdc {} and uuid: {}".format(tenant_name, vdc_uuid))
return vdc_uuid
else:
if tenant_id is not None:
if vca._session:
if tenant_id is not None:
if vca._session:
url_list = [self.url, '/api/vdc/', tenant_id]
orgvdc_herf = ''.join(url_list)
url_list = [self.url, '/api/vdc/', tenant_id]
orgvdc_herf = ''.join(url_list)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=orgvdc_herf,
headers=headers)
if response.status_code != requests.codes.ok:
'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=orgvdc_herf,
headers=headers)
if response.status_code != requests.codes.ok:
- self.logger.debug("delete_tenant():GET REST API call {} failed. "\
+ self.logger.debug("delete_tenant():GET REST API call {} failed. "
"Return status code {}".format(orgvdc_herf,
response.status_code))
raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
"Return status code {}".format(orgvdc_herf,
response.status_code))
raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
- namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
- vdc_remove_href = lxmlroot_respond.find("xmlns:Link[@rel='remove']",namespaces).attrib['href']
+ namespaces["xmlns"] = "http://www.vmware.com/vcloud/v1.5"
+ vdc_remove_href = lxmlroot_respond.find("xmlns:Link[@rel='remove']", namespaces).attrib['href']
vdc_remove_href = vdc_remove_href + '?recursive=true&force=true'
response = self.perform_request(req_type='DELETE',
vdc_remove_href = vdc_remove_href + '?recursive=true&force=true'
response = self.perform_request(req_type='DELETE',
time.sleep(5)
return tenant_id
else:
time.sleep(5)
return tenant_id
else:
- self.logger.debug("delete_tenant(): DELETE REST API call {} failed. "\
+ self.logger.debug("delete_tenant(): DELETE REST API call {} failed. "
"Return status code {}".format(vdc_remove_href,
response.status_code))
raise vimconn.vimconnException("Fail to delete tenant with ID {}".format(tenant_id))
"Return status code {}".format(vdc_remove_href,
response.status_code))
raise vimconn.vimconnException("Fail to delete tenant with ID {}".format(tenant_id))
self.logger.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id))
raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
self.logger.debug("delete_tenant():Incorrect tenant ID {}".format(tenant_id))
raise vimconn.vimconnNotFoundException("Fail to get tenant {}".format(tenant_id))
def get_tenant_list(self, filter_dict={}):
"""Obtain tenants of VIM
filter_dict can contain the following keys:
def get_tenant_list(self, filter_dict={}):
"""Obtain tenants of VIM
filter_dict can contain the following keys:
if filter_dict is not None and filter_dict:
filtered_entry = entry.copy()
filtered_dict = set(entry.keys()) - set(filter_dict)
if filter_dict is not None and filter_dict:
filtered_entry = entry.copy()
filtered_dict = set(entry.keys()) - set(filter_dict)
- for unwanted_key in filtered_dict: del entry[unwanted_key]
+ for unwanted_key in filtered_dict:
+ del entry[unwanted_key]
if filter_dict == entry:
vdclist.append(filtered_entry)
else:
vdclist.append(entry)
if filter_dict == entry:
vdclist.append(filtered_entry)
else:
vdclist.append(entry)
self.logger.debug("Error in get_tenant_list()")
self.logger.debug(traceback.format_exc())
raise vimconn.vimconnException("Incorrect state. {}")
self.logger.debug("Error in get_tenant_list()")
self.logger.debug(traceback.format_exc())
raise vimconn.vimconnException("Incorrect state. {}")
self.logger.debug("new_network tenant {} net_type {} ip_profile {} shared {} provider_network_profile {}"
.format(net_name, net_type, ip_profile, shared, provider_network_profile))
self.logger.debug("new_network tenant {} net_type {} ip_profile {} shared {} provider_network_profile {}"
.format(net_name, net_type, ip_profile, shared, provider_network_profile))
- vlan = None
- if provider_network_profile:
- vlan = provider_network_profile.get("segmentation-id")
+# vlan = None
+# if provider_network_profile:
+# vlan = provider_network_profile.get("segmentation-id")
created_items = {}
isshared = 'false'
created_items = {}
isshared = 'false'
if not self.tenant_name:
raise vimconn.vimconnConnectionException("Tenant name is empty.")
if not self.tenant_name:
raise vimconn.vimconnConnectionException("Tenant name is empty.")
- org, vdc = self.get_vdc_details()
+ _, vdc = self.get_vdc_details()
if vdc is None:
raise vimconn.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self.tenant_name))
vdc_uuid = vdc.get('id').split(":")[3]
if self.client._session:
if vdc is None:
raise vimconn.vimconnConnectionException("Can't retrieve information for a VDC {}".format(self.tenant_name))
vdc_uuid = vdc.get('id').split(":")[3]
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
- url=vdc.get('href'),
- headers=headers)
+ url=vdc.get('href'),
+ headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
raise vimconn.vimconnNotFoundException("Failed to get vdc content")
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
raise vimconn.vimconnNotFoundException("Failed to get vdc content")
if item.tag.split('}')[-1] == 'AvailableNetworks':
for net in item:
response = self.perform_request(req_type='GET',
if item.tag.split('}')[-1] == 'AvailableNetworks':
for net in item:
response = self.perform_request(req_type='GET',
- url=net.get('href'),
- headers=headers)
+ url=net.get('href'),
+ headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get network content")
if response.status_code != 200:
self.logger.error("Failed to get network content")
filter_dict["type"] = "bridge"
network_list.append(filter_dict)
self.logger.debug("get_vcd_network_list adding entry {}".format(filter_dict))
filter_dict["type"] = "bridge"
network_list.append(filter_dict)
self.logger.debug("get_vcd_network_list adding entry {}".format(filter_dict))
self.logger.debug("Error in get_vcd_network_list", exc_info=True)
pass
self.logger.debug("Error in get_vcd_network_list", exc_info=True)
pass
if not self.tenant_name:
raise vimconn.vimconnConnectionException("Tenant name is empty.")
if not self.tenant_name:
raise vimconn.vimconnConnectionException("Tenant name is empty.")
- org, vdc = self.get_vdc_details()
+ _, vdc = self.get_vdc_details()
- raise vimconn.vimconnConnectionException("Can't retrieve information for a VDC {}.".format(self.tenant_name))
+ raise vimconn.vimconnConnectionException(
+ "Can't retrieve information for a VDC {}.".format(self.tenant_name))
try:
vdcid = vdc.get('id').split(":")[3]
if self.client._session:
try:
vdcid = vdc.get('id').split(":")[3]
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
- url=vdc.get('href'),
- headers=headers)
+ url=vdc.get('href'),
+ headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
raise vimconn.vimconnNotFoundException("Failed to get vdc content")
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
raise vimconn.vimconnNotFoundException("Failed to get vdc content")
if item.tag.split('}')[-1] == 'AvailableNetworks':
for net in item:
response = self.perform_request(req_type='GET',
if item.tag.split('}')[-1] == 'AvailableNetworks':
for net in item:
response = self.perform_request(req_type='GET',
- url=net.get('href'),
- headers=headers)
+ url=net.get('href'),
+ headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get network content")
if response.status_code != 200:
self.logger.error("Failed to get network content")
# we remove all the key : value we don't care and match only
# respected field
filtered_dict = set(filter_entry.keys()) - set(filter_dict)
# we remove all the key : value we don't care and match only
# respected field
filtered_dict = set(filter_entry.keys()) - set(filter_dict)
- for unwanted_key in filtered_dict: del filter_entry[unwanted_key]
+ for unwanted_key in filtered_dict:
+ del filter_entry[unwanted_key]
if filter_dict == filter_entry:
network_list.append(filtered_entry)
else:
network_list.append(filtered_entry)
except Exception as e:
if filter_dict == filter_entry:
network_list.append(filtered_entry)
else:
network_list.append(filtered_entry)
except Exception as e:
- self.logger.debug("Error in get_network_list",exc_info=True)
+ self.logger.debug("Error in get_network_list", exc_info=True)
if isinstance(e, vimconn.vimconnException):
raise
else:
if isinstance(e, vimconn.vimconnException):
raise
else:
Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
try:
Return a dict with the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]"""
try:
- org, vdc = self.get_vdc_details()
+ _, vdc = self.get_vdc_details()
vdc_id = vdc.get('id').split(":")[3]
if self.client._session:
vdc_id = vdc.get('id').split(":")[3]
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
- url=vdc.get('href'),
- headers=headers)
+ url=vdc.get('href'),
+ headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
raise vimconn.vimconnNotFoundException("Failed to get vdc content")
if response.status_code != 200:
self.logger.error("Failed to get vdc content")
raise vimconn.vimconnNotFoundException("Failed to get vdc content")
if item.tag.split('}')[-1] == 'AvailableNetworks':
for net in item:
response = self.perform_request(req_type='GET',
if item.tag.split('}')[-1] == 'AvailableNetworks':
for net in item:
response = self.perform_request(req_type='GET',
- url=net.get('href'),
- headers=headers)
+ url=net.get('href'),
+ headers=headers)
if response.status_code != 200:
self.logger.error("Failed to get network content")
if response.status_code != 200:
self.logger.error("Failed to get network content")
dict_entry[net] = {'status': status, 'error_msg': errormsg,
'vim_info': yaml.safe_dump(vcd_network)}
dict_entry[net] = {'status': status, 'error_msg': errormsg,
'vim_info': yaml.safe_dump(vcd_network)}
self.logger.debug("Error in refresh_nets_status")
self.logger.debug(traceback.format_exc())
self.logger.debug("Error in refresh_nets_status")
self.logger.debug(traceback.format_exc())
extended: EPA parameters
- numas: #items requested in same NUMA
memory: number of 1G huge pages memory
extended: EPA parameters
- numas: #items requested in same NUMA
memory: number of 1G huge pages memory
- paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
+ paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual
+ threads
interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
- name: interface name
dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
- name: interface name
dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
# generate a new uuid put to internal dict and return it.
self.logger.debug("Creating new flavor - flavor_data: {}".format(flavor_data))
# generate a new uuid put to internal dict and return it.
self.logger.debug("Creating new flavor - flavor_data: {}".format(flavor_data))
+ new_flavor = flavor_data
ram = flavor_data.get(FLAVOR_RAM_KEY, 1024)
cpu = flavor_data.get(FLAVOR_VCPUS_KEY, 1)
disk = flavor_data.get(FLAVOR_DISK_KEY, 0)
ram = flavor_data.get(FLAVOR_RAM_KEY, 1024)
cpu = flavor_data.get(FLAVOR_VCPUS_KEY, 1)
disk = flavor_data.get(FLAVOR_DISK_KEY, 0)
extended_flv = flavor_data.get("extended")
if extended_flv:
extended_flv = flavor_data.get("extended")
if extended_flv:
- numas=extended_flv.get("numas")
+ numas = extended_flv.get("numas")
if numas:
for numa in numas:
if numas:
for numa in numas:
- #overwrite ram and vcpus
+ # overwrite ram and vcpus
- ram = numa['memory']*1024
+ ram = numa['memory'] * 1024
if 'paired-threads' in numa:
if 'paired-threads' in numa:
- cpu = numa['paired-threads']*2
+ cpu = numa['paired-threads'] * 2
elif 'cores' in numa:
cpu = numa['cores']
elif 'threads' in numa:
elif 'cores' in numa:
cpu = numa['cores']
elif 'threads' in numa:
try:
lxml_catalog_element = vca.create_catalog(catalog_name, catalog_name)
if lxml_catalog_element:
try:
lxml_catalog_element = vca.create_catalog(catalog_name, catalog_name)
if lxml_catalog_element:
- id_attr_value = lxml_catalog_element.get('id') # 'urn:vcloud:catalog:7490d561-d384-4dac-8229-3575fd1fc7b4'
+ id_attr_value = lxml_catalog_element.get('id')
return id_attr_value.split(':')[-1]
catalogs = vca.list_catalogs()
except Exception as ex:
return id_attr_value.split(':')[-1]
catalogs = vca.list_catalogs()
except Exception as ex:
continue
catalog_href = "{}/api/catalog/{}/action/upload".format(self.url, catalog['id'])
data = """
continue
catalog_href = "{}/api/catalog/{}/action/upload".format(self.url, catalog['id'])
data = """
- <UploadVAppTemplateParams name="{}" xmlns="http://www.vmware.com/vcloud/v1.5" xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"><Description>{} vApp Template</Description></UploadVAppTemplateParams>
+ <UploadVAppTemplateParams name="{}"
+ xmlns="http://www.vmware.com/vcloud/v1.5"
+ xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1">
+ <Description>{} vApp Template</Description>
+ </UploadVAppTemplateParams>
""".format(catalog_name, description)
if self.client:
""".format(catalog_name, description)
if self.client:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
headers['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
response = self.perform_request(req_type='POST',
headers['Content-Type'] = 'application/vnd.vmware.vcloud.uploadVAppTemplateParams+xml'
response = self.perform_request(req_type='POST',
transfer_href = result.group(1)
response = self.perform_request(req_type='PUT',
transfer_href = result.group(1)
response = self.perform_request(req_type='PUT',
- url=transfer_href,
- headers=headers,
- data=open(media_file_name, 'rb'))
+ url=transfer_href,
+ headers=headers,
+ data=open(media_file_name, 'rb'))
if response.status_code != requests.codes.ok:
self.logger.debug(
"Failed create vApp template for catalog name {} and image {}".format(catalog_name,
if response.status_code != requests.codes.ok:
self.logger.debug(
"Failed create vApp template for catalog name {} and image {}".format(catalog_name,
# TODO fix this with aync block
time.sleep(5)
# TODO fix this with aync block
time.sleep(5)
- self.logger.debug("vApp template for catalog name {} and image {}".format(catalog_name, media_file_name))
+ self.logger.debug("vApp template for catalog name {} and image {}".format(catalog_name,
+ media_file_name))
# uploading VMDK file
# check status of OVF upload and upload remaining files.
# uploading VMDK file
# check status of OVF upload and upload remaining files.
if 'ovf' in link_href:
continue
# The OVF file and VMDK must be in a same directory
if 'ovf' in link_href:
continue
# The OVF file and VMDK must be in a same directory
- head, tail = os.path.split(media_file_name)
+ head, _ = os.path.split(media_file_name)
file_vmdk = head + '/' + link_href.split("/")[-1]
if not os.path.isfile(file_vmdk):
return False
file_vmdk = head + '/' + link_href.split("/")[-1]
if not os.path.isfile(file_vmdk):
return False
if progress:
widgets = ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
if progress:
widgets = ['Uploading file: ', Percentage(), ' ', Bar(), ' ', ETA(), ' ',
progress_bar = ProgressBar(widgets=widgets, maxval=statinfo.st_size).start()
bytes_transferred = 0
progress_bar = ProgressBar(widgets=widgets, maxval=statinfo.st_size).start()
bytes_transferred = 0
bytes_transferred, len(my_bytes) - 1, statinfo.st_size)
headers['Content-Length'] = str(len(my_bytes))
response = requests.put(url=hrefvmdk,
bytes_transferred, len(my_bytes) - 1, statinfo.st_size)
headers['Content-Length'] = str(len(my_bytes))
response = requests.put(url=hrefvmdk,
- headers=headers,
- data=my_bytes,
- verify=False)
+ headers=headers,
+ data=my_bytes,
+ verify=False)
if response.status_code == requests.codes.ok:
bytes_transferred += len(my_bytes)
if progress:
if response.status_code == requests.codes.ok:
bytes_transferred += len(my_bytes)
if progress:
return False
except Exception as exp:
self.logger.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
return False
except Exception as exp:
self.logger.debug("Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
- .format(catalog_name,media_file_name, exp))
+ .format(catalog_name, media_file_name, exp))
raise vimconn.vimconnException(
"Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
raise vimconn.vimconnException(
"Failed while uploading OVF to catalog {} for OVF file {} with Exception {}"
- .format(catalog_name,media_file_name, exp))
+ .format(catalog_name, media_file_name, exp))
self.logger.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name, media_file_name))
return False
self.logger.debug("Failed retrieve catalog name {} for OVF file {}".format(catalog_name, media_file_name))
return False
Return: true if string represent valid uuid
"""
try:
Return: true if string represent valid uuid
"""
try:
- val = uuid.UUID(uuid_string, version=4)
+ uuid.UUID(uuid_string, version=4)
except ValueError:
return False
return True
except ValueError:
return False
return True
self.logger.debug("get_image_id_from_path() client requesting {} ".format(path))
self.logger.debug("get_image_id_from_path() client requesting {} ".format(path))
- dirpath, filename = os.path.split(path)
- flname, file_extension = os.path.splitext(path)
+ _, filename = os.path.split(path)
+ _, file_extension = os.path.splitext(path)
if file_extension != '.ovf':
self.logger.debug("Wrong file extension {} connector support only OVF container.".format(file_extension))
raise vimconn.vimconnException("Wrong container. vCloud director supports only OVF.")
if file_extension != '.ovf':
self.logger.debug("Wrong file extension {} connector support only OVF container.".format(file_extension))
raise vimconn.vimconnException("Wrong container. vCloud director supports only OVF.")
"vdc catalog name {}".format(filename, catalog_name, path, catalog_md5_name))
try:
"vdc catalog name {}".format(filename, catalog_name, path, catalog_md5_name))
try:
- org,vdc = self.get_vdc_details()
+ org, _ = self.get_vdc_details()
catalogs = org.list_catalogs()
except Exception as exp:
self.logger.debug("Failed get catalogs() with Exception {} ".format(exp))
catalogs = org.list_catalogs()
except Exception as exp:
self.logger.debug("Failed get catalogs() with Exception {} ".format(exp))
- org, vdc = self.get_vdc_details()
+ org, _ = self.get_vdc_details()
image_list = []
catalogs = org.list_catalogs()
if len(catalogs) == 0:
image_list = []
catalogs = org.list_catalogs()
if len(catalogs) == 0:
continue
if filter_dict.get("id") and filter_dict["id"] != catalog_uuid:
continue
continue
if filter_dict.get("id") and filter_dict["id"] != catalog_uuid:
continue
- filtered_dict ["name"] = name
- filtered_dict ["id"] = catalog_uuid
+ filtered_dict["name"] = name
+ filtered_dict["id"] = catalog_uuid
image_list.append(filtered_dict)
self.logger.debug("List of already created catalog items: {}".format(image_list))
image_list.append(filtered_dict)
self.logger.debug("List of already created catalog items: {}".format(image_list))
return None
# UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
try:
return None
# UUID has following format https://host/api/vApp/vapp-30da58a3-e7c7-4d09-8f68-d4c8201169cf
try:
- refs = [ref for ref in vdc.ResourceEntities.ResourceEntity \
+ refs = [ref for ref in vdc.ResourceEntities.ResourceEntity
if ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
if len(refs) == 1:
return refs[0].href.split("vapp")[1][1:]
if ref.name == vapp_name and ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
if len(refs) == 1:
return refs[0].href.split("vapp")[1][1:]
:param vapp_uuid:
"""
try:
:param vapp_uuid:
"""
try:
- refs = [ref for ref in vdc.ResourceEntities.ResourceEntity\
- if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
+ refs = [ref for ref in vdc.ResourceEntities.ResourceEntity
+ if ref.type_ == 'application/vnd.vmware.vcloud.vApp+xml']
for ref in refs:
vappid = ref.href.split("vapp")[1][1:]
# find vapp with respected vapp uuid
for ref in refs:
vappid = ref.href.split("vapp")[1][1:]
# find vapp with respected vapp uuid
try:
if self.client and vapp_uuid:
vapp_call = "{}/api/vApp/vapp-{}".format(self.url, vapp_uuid)
try:
if self.client and vapp_uuid:
vapp_call = "{}/api/vApp/vapp-{}".format(self.url, vapp_uuid)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vapp_call,
headers=headers)
response = self.perform_request(req_type='GET',
url=vapp_call,
headers=headers)
- #Retry login if session expired & retry sending request
+ # Retry login if session expired & retry sending request
if response.status_code == 403:
response = self.retry_rest('GET', vapp_call)
if response.status_code == 403:
response = self.retry_rest('GET', vapp_call)
'net_list': list of interfaces, each one is a dictionary with:
'name': (optional) name for the interface.
'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
'net_list': list of interfaces, each one is a dictionary with:
'name': (optional) name for the interface.
'net_id': VIM network id where this interface must be connect to. Mandatory for type==virtual
- 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM capabilities
+ 'vpci': (optional) virtual vPCI address to assign at the VM. Can be ignored depending on VIM
+ capabilities
'model': (optional and only have sense for type==virtual) interface model: virtio, e1000, ...
'mac_address': (optional) mac address to assign to this interface
'model': (optional and only have sense for type==virtual) interface model: virtio, e1000, ...
'mac_address': (optional) mac address to assign to this interface
- #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not provided,
- the VLAN tag to be used. In case net_id is provided, the internal network vlan is used for tagging VF
+ #TODO: CHECK if an optional 'vlan' parameter is needed for VIMs when type if VF and net_id is not
+ provided, the VLAN tag to be used. In case net_id is provided, the internal network vlan is used
+ for tagging VF
'type': (mandatory) can be one of:
'virtual', in this case always connected to a network of type 'net_type=bridge'
'type': (mandatory) can be one of:
'virtual', in this case always connected to a network of type 'net_type=bridge'
- 'PCI-PASSTHROUGH' or 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it
- can created unconnected
+ 'PCI-PASSTHROUGH' or 'PF' (passthrough): depending on VIM capabilities it can be connected to a
+ data/ptp network or it can created unconnected
'SR-IOV' or 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
are allocated on the same physical NIC
'SR-IOV' or 'VF' (SRIOV with VLAN tag): same as PF for network connectivity.
'VFnotShared'(SRIOV without VLAN tag) same as PF for network connectivity. VF where no other VFs
are allocated on the same physical NIC
as not present.
"""
self.logger.info("Creating new instance for entry {}".format(name))
as not present.
"""
self.logger.info("Creating new instance for entry {}".format(name))
- self.logger.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {} disk_list {} "\
- "availability_zone_index {} availability_zone_list {}"\
- .format(description, start, image_id, flavor_id, net_list, cloud_config, disk_list,\
+ self.logger.debug("desc {} boot {} image_id: {} flavor_id: {} net_list: {} cloud_config {} disk_list {} "
+ "availability_zone_index {} availability_zone_list {}"
+ .format(description, start, image_id, flavor_id, net_list, cloud_config, disk_list,
availability_zone_index, availability_zone_list))
availability_zone_index, availability_zone_list))
- #new vm name = vmname + tenant_id + uuid
+ # new vm name = vmname + tenant_id + uuid
new_vm_name = [name, '-', str(uuid.uuid4())]
vmname_andid = ''.join(new_vm_name)
for net in net_list:
if net['type'] == "PCI-PASSTHROUGH":
raise vimconn.vimconnNotSupportedException(
new_vm_name = [name, '-', str(uuid.uuid4())]
vmname_andid = ''.join(new_vm_name)
for net in net_list:
if net['type'] == "PCI-PASSTHROUGH":
raise vimconn.vimconnNotSupportedException(
- "Current vCD version does not support type : {}".format(net['type']))
+ "Current vCD version does not support type : {}".format(net['type']))
if len(net_list) > 10:
raise vimconn.vimconnNotSupportedException(
if len(net_list) > 10:
raise vimconn.vimconnNotSupportedException(
- "The VM hardware versions 7 and above support upto 10 NICs only")
+ "The VM hardware versions 7 and above support upto 10 NICs only")
# if vm already deployed we return existing uuid
# we check for presence of VDC, Catalog entry and Flavor.
# if vm already deployed we return existing uuid
# we check for presence of VDC, Catalog entry and Flavor.
"new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name))
catalogs = org.list_catalogs()
if catalogs is None:
"new_vminstance(): Failed create vApp {}: (Failed retrieve VDC information)".format(name))
catalogs = org.list_catalogs()
if catalogs is None:
- #Retry once, if failed by refreshing token
+ # Retry once, if failed by refreshing token
self.get_token()
org = Org(self.client, resource=self.client.get_org())
catalogs = org.list_catalogs()
self.get_token()
org = Org(self.client, resource=self.client.get_org())
catalogs = org.list_catalogs()
vm_disk = flavor[FLAVOR_DISK_KEY]
extended = flavor.get("extended", None)
if extended:
vm_disk = flavor[FLAVOR_DISK_KEY]
extended = flavor.get("extended", None)
if extended:
- numas=extended.get("numas", None)
+ numas = extended.get("numas", None)
except Exception as exp:
raise vimconn.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id, exp))
# image upload creates template name as catalog name space Template.
templateName = self.get_catalogbyid(catalog_uuid=image_id, catalogs=catalogs)
except Exception as exp:
raise vimconn.vimconnException("Corrupted flavor. {}.Exception: {}".format(flavor_id, exp))
# image upload creates template name as catalog name space Template.
templateName = self.get_catalogbyid(catalog_uuid=image_id, catalogs=catalogs)
- power_on = 'false'
- if start:
- power_on = 'true'
+ # power_on = 'false'
+ # if start:
+ # power_on = 'true'
# client must provide at least one entry in net_list if not we report error
# client must provide at least one entry in net_list if not we report error
- #If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
+ # If net type is mgmt, then configure it as primary net & use its NIC index as primary NIC
# If no mgmt, then the 1st NN in netlist is considered as primary net.
primary_net = None
primary_netname = None
primary_net_href = None
# If no mgmt, then the 1st NN in netlist is considered as primary net.
primary_net = None
primary_netname = None
primary_net_href = None
- network_mode = 'bridged'
+ # network_mode = 'bridged'
if net_list is not None and len(net_list) > 0:
for net in net_list:
if 'use' in net and net['use'] == 'mgmt' and not primary_net:
if net_list is not None and len(net_list) > 0:
for net in net_list:
if 'use' in net and net['use'] == 'mgmt' and not primary_net:
if len(catalog_items) == 1:
if self.client:
if len(catalog_items) == 1:
if self.client:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
response = self.perform_request(req_type='GET',
- url=catalog_items[0].get('href'),
- headers=headers)
+ url=catalog_items[0].get('href'),
+ headers=headers)
catalogItem = XmlElementTree.fromstring(response.text)
entity = [child for child in catalogItem if child.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
vapp_tempalte_href = entity.get("href")
response = self.perform_request(req_type='GET',
catalogItem = XmlElementTree.fromstring(response.text)
entity = [child for child in catalogItem if child.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
vapp_tempalte_href = entity.get("href")
response = self.perform_request(req_type='GET',
- url=vapp_tempalte_href,
- headers=headers)
+ url=vapp_tempalte_href,
+ headers=headers)
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vapp_tempalte_href,
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vapp_tempalte_href,
else:
result = (response.text).replace("\n", " ")
else:
result = (response.text).replace("\n", " ")
vm_id = vm_element.get('id')
vm_href = vm_element.get('href')
vm_id = vm_element.get('id')
vm_href = vm_element.get('href')
- cpus = re.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result).group(1)
- memory_mb = re.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result).group(1)
- cores = re.search('<vmw:CoresPerSocket ovf:required.*?>(\d+)</vmw:CoresPerSocket>',result).group(1)
+ # cpus = re.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',
+ # result).group(1)
+ memory_mb = re.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',
+ result).group(1)
+ # cores = re.search('<vmw:CoresPerSocket ovf:required.*?>(\d+)</vmw:CoresPerSocket>', result).group(1)
headers['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'
vdc_id = vdc.get('id').split(':')[-1]
instantiate_vapp_href = "{}/api/vdc/{}/action/instantiateVAppTemplate".format(self.url,
headers['Content-Type'] = 'application/vnd.vmware.vcloud.instantiateVAppTemplateParams+xml'
vdc_id = vdc.get('id').split(':')[-1]
instantiate_vapp_href = "{}/api/vdc/{}/action/instantiateVAppTemplate".format(self.url,
with open(os.path.join(os.path.dirname(__file__), 'InstantiateVAppTemplateParams.xml'), 'r') as f:
template = f.read()
with open(os.path.join(os.path.dirname(__file__), 'InstantiateVAppTemplateParams.xml'), 'r') as f:
template = f.read()
data=data)
if response.status_code != 201:
data=data)
if response.status_code != 201:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {}".format(instantiate_vapp_href,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("new_vminstance(): Failed to create"\
- "vAapp {}".format(vmname_andid))
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {}".format(instantiate_vapp_href,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("new_vminstance(): Failed to create"
+ "vAapp {}".format(vmname_andid))
else:
vapptask = self.get_task_from_response(response.text)
else:
vapptask = self.get_task_from_response(response.text)
- if vapptask is None and retry==1:
- self.get_token() # Retry getting token
+ if vapptask is None and retry == 1:
+ self.get_token() # Retry getting token
if result:
self.logger.debug("Modified Disk size of VM {} ".format(vmname_andid))
if result:
self.logger.debug("Modified Disk size of VM {} ".format(vmname_andid))
- #Add new or existing disks to vApp
+ # Add new or existing disks to vApp
if disk_list:
added_existing_disk = False
for disk in disk_list:
if disk_list:
added_existing_disk = False
for disk in disk_list:
self.insert_media_to_vm(vapp, image_id)
elif "image_id" in disk and disk["image_id"] is not None:
self.logger.debug("Adding existing disk from image {} to vm {} ".format(
self.insert_media_to_vm(vapp, image_id)
elif "image_id" in disk and disk["image_id"] is not None:
self.logger.debug("Adding existing disk from image {} to vm {} ".format(
- disk["image_id"] , vapp_uuid))
+ disk["image_id"], vapp_uuid))
self.add_existing_disk(catalogs=catalogs,
image_id=disk["image_id"],
self.add_existing_disk(catalogs=catalogs,
image_id=disk["image_id"],
template_name=templateName,
vapp_uuid=vapp_uuid
)
added_existing_disk = True
else:
template_name=templateName,
vapp_uuid=vapp_uuid
)
added_existing_disk = True
else:
- #Wait till added existing disk gets reflected into vCD database/API
+ # Wait till added existing disk gets reflected into vCD database/API
if added_existing_disk:
time.sleep(5)
added_existing_disk = False
if added_existing_disk:
time.sleep(5)
added_existing_disk = False
if 'net_id' not in net:
continue
if 'net_id' not in net:
continue
- #Using net_id as a vim_id i.e. vim interface id, as do not have saperate vim interface id
- #Same will be returned in refresh_vms_status() as vim_interface_id
+ # Using net_id as a vim_id i.e. vim interface id, as do not have saperate vim interface id
+ # Same will be returned in refresh_vms_status() as vim_interface_id
net['vim_id'] = net['net_id'] # Provide the same VIM identifier as the VIM network
interface_net_id = net['net_id']
net['vim_id'] = net['net_id'] # Provide the same VIM identifier as the VIM network
interface_net_id = net['net_id']
else:
nic_type = net['model']
else:
nic_type = net['model']
- self.logger.info("new_vminstance(): adding network adapter "\
- "to a network {}".format(nets[0].get('name')))
+ self.logger.info("new_vminstance(): adding network adapter "
+ "to a network {}".format(nets[0].get('name')))
self.add_network_adapter_to_vms(vapp, nets[0].get('name'),
primary_nic_index,
nicIndex,
net,
nic_type=nic_type)
else:
self.add_network_adapter_to_vms(vapp, nets[0].get('name'),
primary_nic_index,
nicIndex,
net,
nic_type=nic_type)
else:
- self.logger.info("new_vminstance(): adding network adapter "\
- "to a network {}".format(nets[0].get('name')))
+ self.logger.info("new_vminstance(): adding network adapter "
+ "to a network {}".format(nets[0].get('name')))
if net['type'] in ['SR-IOV', 'VF']:
nic_type = net['type']
self.add_network_adapter_to_vms(vapp, nets[0].get('name'),
if net['type'] in ['SR-IOV', 'VF']:
nic_type = net['type']
self.add_network_adapter_to_vms(vapp, nets[0].get('name'),
poweron_task = self.power_on_vapp(vapp_id, vmname_andid)
result = self.client.get_task_monitor().wait_for_success(task=poweron_task)
if result.get('status') == 'success':
poweron_task = self.power_on_vapp(vapp_id, vmname_andid)
result = self.client.get_task_monitor().wait_for_success(task=poweron_task)
if result.get('status') == 'success':
- self.logger.info("new_vminstance(): Successfully power on "\
- "vApp {}".format(vmname_andid))
+ self.logger.info("new_vminstance(): Successfully power on "
+ "vApp {}".format(vmname_andid))
- self.logger.error("new_vminstance(): failed to power on vApp "\
- "{}".format(vmname_andid))
+ self.logger.error("new_vminstance(): failed to power on vApp "
+ "{}".format(vmname_andid))
except Exception as exp:
try:
except Exception as exp:
try:
vapp = VApp(self.client, resource=vapp_resource)
except Exception as exp:
raise vimconn.vimconnUnexpectedResponse(
vapp = VApp(self.client, resource=vapp_resource)
except Exception as exp:
raise vimconn.vimconnUnexpectedResponse(
- "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
- .format(vmname_andid, exp))
+ "new_vminstance(): Failed to retrieve vApp {} after creation: Exception:{}"
+ .format(vmname_andid, exp))
- #if vapp and vapp.me.deployed:
+ # if vapp and vapp.me.deployed:
if vapp and vapp_resource.get('deployed') == 'true':
vapp_uuid = vapp_resource.get('id').split(':')[-1]
break
if vapp and vapp_resource.get('deployed') == 'true':
vapp_uuid = vapp_resource.get('id').split(':')[-1]
break
self.logger.debug("new_vminstance(): Wait for vApp {} to deploy".format(name))
time.sleep(INTERVAL_TIME)
self.logger.debug("new_vminstance(): Wait for vApp {} to deploy".format(name))
time.sleep(INTERVAL_TIME)
- wait_time +=INTERVAL_TIME
+ wait_time += INTERVAL_TIME
- #SET Affinity Rule for VM
- #Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used
- #While creating VIM account user has to pass the Host Group names in availability_zone list
- #"availability_zone" is a part of VIM "config" parameters
- #For example, in VIM config: "availability_zone":["HG_170","HG_174","HG_175"]
- #Host groups are referred as availability zones
- #With following procedure, deployed VM will be added into a VM group.
- #Then A VM to Host Affinity rule will be created using the VM group & Host group.
+ # SET Affinity Rule for VM
+ # Pre-requisites: User has created Hosh Groups in vCenter with respective Hosts to be used
+ # While creating VIM account user has to pass the Host Group names in availability_zone list
+ # "availability_zone" is a part of VIM "config" parameters
+ # For example, in VIM config: "availability_zone":["HG_170","HG_174","HG_175"]
+ # Host groups are referred as availability zones
+ # With following procedure, deployed VM will be added into a VM group.
+ # Then A VM to Host Affinity rule will be created using the VM group & Host group.
if(availability_zone_list):
self.logger.debug("Existing Host Groups in VIM {}".format(self.config.get('availability_zone')))
if(availability_zone_list):
self.logger.debug("Existing Host Groups in VIM {}".format(self.config.get('availability_zone')))
- #Admin access required for creating Affinity rules
+ # Admin access required for creating Affinity rules
client = self.connect_as_admin()
if not client:
raise vimconn.vimconnConnectionException("Failed to connect vCD as admin")
else:
self.client = client
if self.client:
client = self.connect_as_admin()
if not client:
raise vimconn.vimconnConnectionException("Failed to connect vCD as admin")
else:
self.client = client
if self.client:
- headers = {'Accept':'application/*+xml;version=27.0',
+ headers = {'Accept': 'application/*+xml;version=27.0',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
- #Step1: Get provider vdc details from organization
+ # Step1: Get provider vdc details from organization
pvdc_href = self.get_pvdc_for_org(self.tenant_name, headers)
if pvdc_href is not None:
pvdc_href = self.get_pvdc_for_org(self.tenant_name, headers)
if pvdc_href is not None:
- #Step2: Found required pvdc, now get resource pool information
+ # Step2: Found required pvdc, now get resource pool information
respool_href = self.get_resource_pool_details(pvdc_href, headers)
if respool_href is None:
respool_href = self.get_resource_pool_details(pvdc_href, headers)
if respool_href is None:
- #Raise error if respool_href not found
- msg = "new_vminstance():Error in finding resource pool details in pvdc {}"\
- .format(pvdc_href)
+ # Raise error if respool_href not found
+ msg = "new_vminstance():Error in finding resource pool details in pvdc {}".format(pvdc_href)
- #Step3: Verify requested availability zone(hostGroup) is present in vCD
+ # Step3: Verify requested availability zone(hostGroup) is present in vCD
# get availability Zone
vm_az = self.get_vm_availability_zone(availability_zone_index, availability_zone_list)
# check if provided av zone(hostGroup) is present in vCD VIM
status = self.check_availibility_zone(vm_az, respool_href, headers)
if status is False:
# get availability Zone
vm_az = self.get_vm_availability_zone(availability_zone_index, availability_zone_list)
# check if provided av zone(hostGroup) is present in vCD VIM
status = self.check_availibility_zone(vm_az, respool_href, headers)
if status is False:
- msg = "new_vminstance(): Error in finding availability zone(Host Group): {} in "\
- "resource pool {} status: {}".format(vm_az,respool_href,status)
+ msg = "new_vminstance(): Error in finding availability zone(Host Group): {} in "
+ "resource pool {} status: {}".format(vm_az, respool_href, status)
self.log_message(msg)
else:
self.log_message(msg)
else:
- self.logger.debug ("new_vminstance(): Availability zone {} found in VIM".format(vm_az))
+ self.logger.debug("new_vminstance(): Availability zone {} found in VIM".format(vm_az))
- #Step4: Find VM group references to create vm group
+ # Step4: Find VM group references to create vm group
vmgrp_href = self.find_vmgroup_reference(respool_href, headers)
vmgrp_href = self.find_vmgroup_reference(respool_href, headers)
msg = "new_vminstance(): No reference to VmGroup found in resource pool"
self.log_message(msg)
msg = "new_vminstance(): No reference to VmGroup found in resource pool"
self.log_message(msg)
- #Step5: Create a VmGroup with name az_VmGroup
- vmgrp_name = vm_az + "_" + name #Formed VM Group name = Host Group name + VM name
+ # Step5: Create a VmGroup with name az_VmGroup
+ vmgrp_name = vm_az + "_" + name # Formed VM Group name = Host Group name + VM name
status = self.create_vmgroup(vmgrp_name, vmgrp_href, headers)
if status is not True:
msg = "new_vminstance(): Error in creating VM group {}".format(vmgrp_name)
self.log_message(msg)
status = self.create_vmgroup(vmgrp_name, vmgrp_href, headers)
if status is not True:
msg = "new_vminstance(): Error in creating VM group {}".format(vmgrp_name)
self.log_message(msg)
- #VM Group url to add vms to vm group
- vmgrpname_url = self.url + "/api/admin/extension/vmGroup/name/"+ vmgrp_name
+ # VM Group url to add vms to vm group
+ vmgrpname_url = self.url + "/api/admin/extension/vmGroup/name/" + vmgrp_name
- #Step6: Add VM to VM Group
- #Find VM uuid from vapp_uuid
+ # Step6: Add VM to VM Group
+ # Find VM uuid from vapp_uuid
vm_details = self.get_vapp_details_rest(vapp_uuid)
vm_uuid = vm_details['vmuuid']
vm_details = self.get_vapp_details_rest(vapp_uuid)
vm_uuid = vm_details['vmuuid']
msg = "new_vminstance(): Error in adding VM to VM group {}".format(vmgrp_name)
self.log_message(msg)
msg = "new_vminstance(): Error in adding VM to VM group {}".format(vmgrp_name)
self.log_message(msg)
- #Step7: Create VM to Host affinity rule
- addrule_href = self.get_add_rule_reference (respool_href, headers)
+ # Step7: Create VM to Host affinity rule
+ addrule_href = self.get_add_rule_reference(respool_href, headers)
if addrule_href is None:
msg = "new_vminstance(): Error in finding href to add rule in resource pool: {}"\
.format(respool_href)
self.log_message(msg)
if addrule_href is None:
msg = "new_vminstance(): Error in finding href to add rule in resource pool: {}"\
.format(respool_href)
self.log_message(msg)
- status = self.create_vm_to_host_affinity_rule(addrule_href, vmgrp_name, vm_az, "Affinity", headers)
+ status = self.create_vm_to_host_affinity_rule(addrule_href, vmgrp_name, vm_az, "Affinity", headers)
if status is False:
msg = "new_vminstance(): Error in creating affinity rule for VM {} in Host group {}"\
.format(name, vm_az)
self.log_message(msg)
else:
if status is False:
msg = "new_vminstance(): Error in creating affinity rule for VM {} in Host group {}"\
.format(name, vm_az)
self.log_message(msg)
else:
- self.logger.debug("new_vminstance(): Affinity rule created successfully. Added {} in Host group {}"\
- .format(name, vm_az))
- #Reset token to a normal user to perform other operations
+ self.logger.debug("new_vminstance(): Affinity rule created successfully. Added {} in Host group {}"
+ .format(name, vm_az))
+ # Reset token to a normal user to perform other operations
self.get_token()
if vapp_uuid is not None:
self.get_token()
if vapp_uuid is not None:
imageType="iso">
<Description>ISO image for config-drive</Description>
</Media>'''.format(iso_name=os.path.basename(iso_file_path), iso_size=iso_file_stat.st_size)
imageType="iso">
<Description>ISO image for config-drive</Description>
</Media>'''.format(iso_name=os.path.basename(iso_file_path), iso_size=iso_file_stat.st_size)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
headers['Content-Type'] = 'application/vnd.vmware.vcloud.media+xml'
catalog_href = self.url + '/api/catalog/' + catalog_id + '/action/upload'
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
headers['Content-Type'] = 'application/vnd.vmware.vcloud.media+xml'
catalog_href = self.url + '/api/catalog/' + catalog_id + '/action/upload'
if result.get('status') != 'success':
raise Exception('The upload iso task failed with status {}'.format(result.get('status')))
if result.get('status') != 'success':
raise Exception('The upload iso task failed with status {}'.format(result.get('status')))
- def get_vcd_availibility_zones(self,respool_href, headers):
+ def get_vcd_availibility_zones(self, respool_href, headers):
""" Method to find presence of av zone is VIM resource pool
Args:
""" Method to find presence of av zone is VIM resource pool
Args:
vcd_az - list of azone present in vCD
"""
vcd_az = []
vcd_az - list of azone present in vCD
"""
vcd_az = []
- url=respool_href
- resp = self.perform_request(req_type='GET',url=respool_href, headers=headers)
+ url = respool_href
+ resp = self.perform_request(req_type='GET', url=respool_href, headers=headers)
if resp.status_code != requests.codes.ok:
if resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(url, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(url, resp.status_code))
- #Get the href to hostGroups and find provided hostGroup is present in it
+ # Get the href to hostGroups and find provided hostGroup is present in it
resp_xml = XmlElementTree.fromstring(resp.content)
for child in resp_xml:
if 'VMWProviderVdcResourcePool' in child.tag:
resp_xml = XmlElementTree.fromstring(resp.content)
for child in resp_xml:
if 'VMWProviderVdcResourcePool' in child.tag:
if 'Link' in schild.tag:
if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
hostGroup = schild.attrib.get('href')
if 'Link' in schild.tag:
if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
hostGroup = schild.attrib.get('href')
- hg_resp = self.perform_request(req_type='GET',url=hostGroup, headers=headers)
+ hg_resp = self.perform_request(req_type='GET', url=hostGroup, headers=headers)
if hg_resp.status_code != requests.codes.ok:
if hg_resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(hostGroup, hg_resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(
+ hostGroup, hg_resp.status_code))
- hg_resp_xml = XmlElementTree.fromstring(hg_resp.content)
+ hg_resp_xml = XmlElementTree.fromstring(hg_resp.content)
for hostGroup in hg_resp_xml:
if 'HostGroup' in hostGroup.tag:
for hostGroup in hg_resp_xml:
if 'HostGroup' in hostGroup.tag:
- #append host group name to the list
+ # append host group name to the list
vcd_az.append(hostGroup.attrib.get("name"))
return vcd_az
vcd_az.append(hostGroup.attrib.get("name"))
return vcd_az
def set_availability_zones(self):
"""
Set vim availability zone
def set_availability_zones(self):
"""
Set vim availability zone
def get_vm_availability_zone(self, availability_zone_index, availability_zone_list):
"""
Return the availability zone to be used by the created VM.
def get_vm_availability_zone(self, availability_zone_index, availability_zone_list):
"""
Return the availability zone to be used by the created VM.
else:
raise vimconn.vimconnConflictException("No enough availability zones at VIM for this deployment")
else:
raise vimconn.vimconnConflictException("No enough availability zones at VIM for this deployment")
def create_vm_to_host_affinity_rule(self, addrule_href, vmgrpname, hostgrpname, polarity, headers):
""" Method to create VM to Host Affinity rule in vCD
def create_vm_to_host_affinity_rule(self, addrule_href, vmgrpname, hostgrpname, polarity, headers):
""" Method to create VM to Host Affinity rule in vCD
<vmext:VmGroupName>{}</vmext:VmGroupName>
</vmext:VMWVmHostAffinityRule>""".format(rule_name, polarity, hostgrpname, vmgrpname)
<vmext:VmGroupName>{}</vmext:VmGroupName>
</vmext:VMWVmHostAffinityRule>""".format(rule_name, polarity, hostgrpname, vmgrpname)
- resp = self.perform_request(req_type='POST',url=addrule_href, headers=headers, data=payload)
+ resp = self.perform_request(req_type='POST', url=addrule_href, headers=headers, data=payload)
if resp.status_code != requests.codes.accepted:
if resp.status_code != requests.codes.accepted:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(addrule_href, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(addrule_href, resp.status_code))
task_status = False
return task_status
else:
affinity_task = self.get_task_from_response(resp.content)
task_status = False
return task_status
else:
affinity_task = self.get_task_from_response(resp.content)
- self.logger.debug ("affinity_task: {}".format(affinity_task))
+ self.logger.debug("affinity_task: {}".format(affinity_task))
if affinity_task is None or affinity_task is False:
raise vimconn.vimconnUnexpectedResponse("failed to find affinity task")
# wait for task to complete
if affinity_task is None or affinity_task is False:
raise vimconn.vimconnUnexpectedResponse("failed to find affinity task")
# wait for task to complete
return True
else:
raise vimconn.vimconnUnexpectedResponse(
return True
else:
raise vimconn.vimconnUnexpectedResponse(
- "failed to create affinity rule {}".format(rule_name))
+ "failed to create affinity rule {}".format(rule_name))
-
- def get_add_rule_reference (self, respool_href, headers):
+ def get_add_rule_reference(self, respool_href, headers):
""" This method finds href to add vm to host affinity rule to vCD
Args:
""" This method finds href to add vm to host affinity rule to vCD
Args:
addrule_href - href to add vm to host affinity rule of resource pool
"""
addrule_href = None
addrule_href - href to add vm to host affinity rule of resource pool
"""
addrule_href = None
- resp = self.perform_request(req_type='GET',url=respool_href, headers=headers)
+ resp = self.perform_request(req_type='GET', url=respool_href, headers=headers)
if resp.status_code != requests.codes.ok:
if resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(respool_href, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(respool_href, resp.status_code))
else:
resp_xml = XmlElementTree.fromstring(resp.content)
else:
resp_xml = XmlElementTree.fromstring(resp.content)
if 'VMWProviderVdcResourcePool' in child.tag:
for schild in child:
if 'Link' in schild.tag:
if 'VMWProviderVdcResourcePool' in child.tag:
for schild in child:
if 'Link' in schild.tag:
- if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwVmHostAffinityRule+xml" and \
- schild.attrib.get('rel') == "add":
+ if (schild.attrib.get(
+ 'type') == "application/vnd.vmware.admin.vmwVmHostAffinityRule+xml" and
+ schild.attrib.get('rel') == "add"):
addrule_href = schild.attrib.get('href')
break
return addrule_href
addrule_href = schild.attrib.get('href')
break
return addrule_href
def add_vm_to_vmgroup(self, vm_uuid, vmGroupNameURL, vmGroup_name, headers):
""" Method to add deployed VM to newly created VM Group.
This is required to create VM to Host affinity in vCD
def add_vm_to_vmgroup(self, vm_uuid, vmGroupNameURL, vmGroup_name, headers):
""" Method to add deployed VM to newly created VM Group.
This is required to create VM to Host affinity in vCD
False- if any error encounter
"""
False- if any error encounter
"""
- addvm_resp = self.perform_request(req_type='GET',url=vmGroupNameURL, headers=headers)#, data=payload)
+ addvm_resp = self.perform_request(req_type='GET', url=vmGroupNameURL, headers=headers) # , data=payload)
if addvm_resp.status_code != requests.codes.ok:
if addvm_resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call to get VM Group Name url {} failed. Return status code {}"\
- .format(vmGroupNameURL, addvm_resp.status_code))
+ self.logger.debug("REST API call to get VM Group Name url {} failed. Return status code {}"
+ .format(vmGroupNameURL, addvm_resp.status_code))
return False
else:
resp_xml = XmlElementTree.fromstring(addvm_resp.content)
for child in resp_xml:
if child.tag.split('}')[1] == 'Link':
if child.attrib.get("rel") == "addVms":
return False
else:
resp_xml = XmlElementTree.fromstring(addvm_resp.content)
for child in resp_xml:
if child.tag.split('}')[1] == 'Link':
if child.attrib.get("rel") == "addVms":
- addvmtogrpURL = child.attrib.get("href")
+ addvmtogrpURL = child.attrib.get("href")
- #Get vm details
- url_list = [self.url, '/api/vApp/vm-',vm_uuid]
+ # Get vm details
+ url_list = [self.url, '/api/vApp/vm-', vm_uuid]
vmdetailsURL = ''.join(url_list)
vmdetailsURL = ''.join(url_list)
- resp = self.perform_request(req_type='GET',url=vmdetailsURL, headers=headers)
+ resp = self.perform_request(req_type='GET', url=vmdetailsURL, headers=headers)
if resp.status_code != requests.codes.ok:
if resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(vmdetailsURL, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(vmdetailsURL, resp.status_code))
resp_xml = XmlElementTree.fromstring(resp.content)
if resp_xml.tag.split('}')[1] == "Vm":
vm_id = resp_xml.attrib.get("id")
vm_name = resp_xml.attrib.get("name")
vm_href = resp_xml.attrib.get("href")
resp_xml = XmlElementTree.fromstring(resp.content)
if resp_xml.tag.split('}')[1] == "Vm":
vm_id = resp_xml.attrib.get("id")
vm_name = resp_xml.attrib.get("name")
vm_href = resp_xml.attrib.get("href")
- #print vm_id, vm_name, vm_href
- #Add VM into VMgroup
+ # print vm_id, vm_name, vm_href
+ # Add VM into VMgroup
payload = """<?xml version="1.0" encoding="UTF-8"?>\
<ns2:Vms xmlns:ns2="http://www.vmware.com/vcloud/v1.5" \
xmlns="http://www.vmware.com/vcloud/versions" \
payload = """<?xml version="1.0" encoding="UTF-8"?>\
<ns2:Vms xmlns:ns2="http://www.vmware.com/vcloud/v1.5" \
xmlns="http://www.vmware.com/vcloud/versions" \
type="application/vnd.vmware.vcloud.vm+xml" />\
</ns2:Vms>""".format(vm_href, vm_id, vm_name)
type="application/vnd.vmware.vcloud.vm+xml" />\
</ns2:Vms>""".format(vm_href, vm_id, vm_name)
- addvmtogrp_resp = self.perform_request(req_type='POST',url=addvmtogrpURL, headers=headers, data=payload)
+ addvmtogrp_resp = self.perform_request(req_type='POST', url=addvmtogrpURL, headers=headers, data=payload)
if addvmtogrp_resp.status_code != requests.codes.accepted:
if addvmtogrp_resp.status_code != requests.codes.accepted:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(addvmtogrpURL, addvmtogrp_resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(addvmtogrpURL,
+ addvmtogrp_resp.
+ status_code))
- self.logger.debug ("Done adding VM {} to VMgroup {}".format(vm_name, vmGroup_name))
+ self.logger.debug("Done adding VM {} to VMgroup {}".format(vm_name, vmGroup_name))
def create_vmgroup(self, vmgroup_name, vmgroup_href, headers):
"""Method to create a VM group in vCD
def create_vmgroup(self, vmgroup_name, vmgroup_href, headers):
"""Method to create a VM group in vCD
vmgroup_href : href for vmgroup
headers- Headers for REST request
"""
vmgroup_href : href for vmgroup
headers- Headers for REST request
"""
- #POST to add URL with required data
+ # POST to add URL with required data
vmgroup_status = False
payload = """<VMWVmGroup xmlns="http://www.vmware.com/vcloud/extension/v1.5" \
xmlns:vcloud_v1.5="http://www.vmware.com/vcloud/v1.5" name="{}">\
<vmCount>1</vmCount>\
</VMWVmGroup>""".format(vmgroup_name)
vmgroup_status = False
payload = """<VMWVmGroup xmlns="http://www.vmware.com/vcloud/extension/v1.5" \
xmlns:vcloud_v1.5="http://www.vmware.com/vcloud/v1.5" name="{}">\
<vmCount>1</vmCount>\
</VMWVmGroup>""".format(vmgroup_name)
- resp = self.perform_request(req_type='POST',url=vmgroup_href, headers=headers, data=payload)
+ resp = self.perform_request(req_type='POST', url=vmgroup_href, headers=headers, data=payload)
if resp.status_code != requests.codes.accepted:
if resp.status_code != requests.codes.accepted:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(vmgroup_href, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(vmgroup_href, resp.status_code))
return vmgroup_status
else:
vmgroup_task = self.get_task_from_response(resp.content)
return vmgroup_status
else:
vmgroup_task = self.get_task_from_response(resp.content)
if result.get('status') == 'success':
self.logger.debug("create_vmgroup(): Successfully created VM group {}".format(vmgroup_name))
if result.get('status') == 'success':
self.logger.debug("create_vmgroup(): Successfully created VM group {}".format(vmgroup_name))
vmgroup_status = True
return vmgroup_status
else:
vmgroup_status = True
return vmgroup_status
else:
- raise vimconn.vimconnUnexpectedResponse(\
- "create_vmgroup(): failed to create VM group {}".format(vmgroup_name))
-
+ raise vimconn.vimconnUnexpectedResponse(
+ "create_vmgroup(): failed to create VM group {}".format(vmgroup_name))
def find_vmgroup_reference(self, url, headers):
""" Method to create a new VMGroup which is required to add created VM
def find_vmgroup_reference(self, url, headers):
""" Method to create a new VMGroup which is required to add created VM
Returns:
returns href to VM group to create VM group
"""
Returns:
returns href to VM group to create VM group
"""
- #Perform GET on resource pool to find 'add' link to create VMGroup
- #https://vcd-ip/api/admin/extension/providervdc/<providervdc id>/resourcePools
+ # Perform GET on resource pool to find 'add' link to create VMGroup
+ #
https://vcd-ip/api/admin/extension/providervdc/<providervdc id>/resourcePools
- resp = self.perform_request(req_type='GET',url=url, headers=headers)
+ resp = self.perform_request(req_type='GET', url=url, headers=headers)
if resp.status_code != requests.codes.ok:
if resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(url, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(url, resp.status_code))
- #Get the href to add vmGroup to vCD
+ # Get the href to add vmGroup to vCD
resp_xml = XmlElementTree.fromstring(resp.content)
for child in resp_xml:
if 'VMWProviderVdcResourcePool' in child.tag:
for schild in child:
if 'Link' in schild.tag:
resp_xml = XmlElementTree.fromstring(resp.content)
for child in resp_xml:
if 'VMWProviderVdcResourcePool' in child.tag:
for schild in child:
if 'Link' in schild.tag:
- #Find href with type VMGroup and rel with add
+ # Find href with type VMGroup and rel with add
if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwVmGroupType+xml"\
and schild.attrib.get('rel') == "add":
vmgrp_href = schild.attrib.get('href')
return vmgrp_href
if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwVmGroupType+xml"\
and schild.attrib.get('rel') == "add":
vmgrp_href = schild.attrib.get('href')
return vmgrp_href
def check_availibility_zone(self, az, respool_href, headers):
""" Method to verify requested av zone is present or not in provided
resource pool
def check_availibility_zone(self, az, respool_href, headers):
""" Method to verify requested av zone is present or not in provided
resource pool
az_found - True if availibility_zone is found else False
"""
az_found = False
az_found - True if availibility_zone is found else False
"""
az_found = False
- headers['Accept']='application/*+xml;version=27.0'
- resp = self.perform_request(req_type='GET',url=respool_href, headers=headers)
+ headers['Accept'] = 'application/*+xml;version=27.0'
+ resp = self.perform_request(req_type='GET', url=respool_href, headers=headers)
if resp.status_code != requests.codes.ok:
if resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(respool_href, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}".format(respool_href, resp.status_code))
- #Get the href to hostGroups and find provided hostGroup is present in it
+ # Get the href to hostGroups and find provided hostGroup is present in it
resp_xml = XmlElementTree.fromstring(resp.content)
for child in resp_xml:
resp_xml = XmlElementTree.fromstring(resp.content)
for child in resp_xml:
if 'Link' in schild.tag:
if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
hostGroup_href = schild.attrib.get('href')
if 'Link' in schild.tag:
if schild.attrib.get('type') == "application/vnd.vmware.admin.vmwHostGroupsType+xml":
hostGroup_href = schild.attrib.get('href')
- hg_resp = self.perform_request(req_type='GET',url=hostGroup_href, headers=headers)
+ hg_resp = self.perform_request(req_type='GET', url=hostGroup_href, headers=headers)
if hg_resp.status_code != requests.codes.ok:
if hg_resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}".format(hostGroup_href, hg_resp.status_code))
+ self.logger.debug(
+ "REST API call {} failed. Return status code {}".format(hostGroup_href,
+ hg_resp.status_code))
else:
hg_resp_xml = XmlElementTree.fromstring(hg_resp.content)
for hostGroup in hg_resp_xml:
else:
hg_resp_xml = XmlElementTree.fromstring(hg_resp.content)
for hostGroup in hg_resp_xml:
def get_pvdc_for_org(self, org_vdc, headers):
""" This method gets provider vdc references from organisation
def get_pvdc_for_org(self, org_vdc, headers):
""" This method gets provider vdc references from organisation
pvdc_href - href to pvdc
"""
pvdc_href - href to pvdc
"""
- #Get provider VDC references from vCD
+ # Get provider VDC references from vCD
- #url = '<vcd url>/api/admin/extension/providerVdcReferences'
+ # url = '<vcd url>/api/admin/extension/providerVdcReferences'
url_list = [self.url, '/api/admin/extension/providerVdcReferences']
url = ''.join(url_list)
url_list = [self.url, '/api/admin/extension/providerVdcReferences']
url = ''.join(url_list)
- response = self.perform_request(req_type='GET',url=url, headers=headers)
+ response = self.perform_request(req_type='GET', url=url, headers=headers)
if response.status_code != requests.codes.ok:
if response.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}"\
- .format(url, response.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}"
+ .format(url, response.status_code))
else:
xmlroot_response = XmlElementTree.fromstring(response.text)
for child in xmlroot_response:
if 'ProviderVdcReference' in child.tag:
pvdc_href = child.attrib.get('href')
else:
xmlroot_response = XmlElementTree.fromstring(response.text)
for child in xmlroot_response:
if 'ProviderVdcReference' in child.tag:
pvdc_href = child.attrib.get('href')
- #Get vdcReferences to find org
- pvdc_resp = self.perform_request(req_type='GET',url=pvdc_href, headers=headers)
+ # Get vdcReferences to find org
+ pvdc_resp = self.perform_request(req_type='GET', url=pvdc_href, headers=headers)
if pvdc_resp.status_code != requests.codes.ok:
if pvdc_resp.status_code != requests.codes.ok:
- raise vimconn.vimconnException("REST API call {} failed. "\
- "Return status code {}"\
+ raise vimconn.vimconnException("REST API call {} failed. "
+ "Return status code {}"
.format(url, pvdc_resp.status_code))
pvdc_resp_xml = XmlElementTree.fromstring(pvdc_resp.content)
.format(url, pvdc_resp.status_code))
pvdc_resp_xml = XmlElementTree.fromstring(pvdc_resp.content)
if child.attrib.get('type') == "application/vnd.vmware.admin.vdcReferences+xml":
vdc_href = child.attrib.get('href')
if child.attrib.get('type') == "application/vnd.vmware.admin.vdcReferences+xml":
vdc_href = child.attrib.get('href')
- #Check if provided org is present in vdc
+ # Check if provided org is present in vdc
vdc_resp = self.perform_request(req_type='GET',
url=vdc_href,
headers=headers)
if vdc_resp.status_code != requests.codes.ok:
vdc_resp = self.perform_request(req_type='GET',
url=vdc_href,
headers=headers)
if vdc_resp.status_code != requests.codes.ok:
- raise vimconn.vimconnException("REST API call {} failed. "\
- "Return status code {}"\
+ raise vimconn.vimconnException("REST API call {} failed. "
+ "Return status code {}"
.format(url, vdc_resp.status_code))
vdc_resp_xml = XmlElementTree.fromstring(vdc_resp.content)
for child in vdc_resp_xml:
.format(url, vdc_resp.status_code))
vdc_resp_xml = XmlElementTree.fromstring(vdc_resp.content)
for child in vdc_resp_xml:
if child.attrib.get('name') == org_vdc:
return pvdc_href
if child.attrib.get('name') == org_vdc:
return pvdc_href
def get_resource_pool_details(self, pvdc_href, headers):
""" Method to get resource pool information.
Host groups are property of resource group.
def get_resource_pool_details(self, pvdc_href, headers):
""" Method to get resource pool information.
Host groups are property of resource group.
respool_href - Returns href link reference to resource pool
"""
respool_href = None
respool_href - Returns href link reference to resource pool
"""
respool_href = None
- resp = self.perform_request(req_type='GET',url=pvdc_href, headers=headers)
+ resp = self.perform_request(req_type='GET', url=pvdc_href, headers=headers)
if resp.status_code != requests.codes.ok:
if resp.status_code != requests.codes.ok:
- self.logger.debug ("REST API call {} failed. Return status code {}"\
- .format(pvdc_href, resp.status_code))
+ self.logger.debug("REST API call {} failed. Return status code {}"
+ .format(pvdc_href, resp.status_code))
else:
respool_resp_xml = XmlElementTree.fromstring(resp.content)
for child in respool_resp_xml:
else:
respool_resp_xml = XmlElementTree.fromstring(resp.content)
for child in respool_resp_xml:
break
return respool_href
break
return respool_href
def log_message(self, msg):
"""
Method to log error messages related to Affinity rule creation
def log_message(self, msg):
"""
Method to log error messages related to Affinity rule creation
msg - Error message to be logged
"""
msg - Error message to be logged
"""
- #get token to connect vCD as a normal user
+ # get token to connect vCD as a normal user
self.get_token()
self.logger.debug(msg)
raise vimconn.vimconnException(msg)
self.get_token()
self.logger.debug(msg)
raise vimconn.vimconnException(msg)
-
- ##
- ##
- ## based on current discussion
- ##
- ##
- ## server:
+ # #
+ # #
+ # # based on current discussion
+ # #
+ # #
+ # # server:
# created: '2016-09-08T11:51:58'
# description: simple-instance.linux1.1
# flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
# created: '2016-09-08T11:51:58'
# description: simple-instance.linux1.1
# flavor: ddc6776e-75a9-11e6-ad5f-0800273e724c
self.logger.debug("Client requesting vm instance {} ".format(vim_vm_uuid))
self.logger.debug("Client requesting vm instance {} ".format(vim_vm_uuid))
- org, vdc = self.get_vdc_details()
+ _, vdc = self.get_vdc_details()
if vdc is None:
raise vimconn.vimconnConnectionException(
"Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
if vdc is None:
raise vimconn.vimconnConnectionException(
"Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
self.logger.debug("Client requesting refresh vm status for {} ".format(vm_list))
self.logger.debug("Client requesting refresh vm status for {} ".format(vm_list))
- org,vdc = self.get_vdc_details()
+ _, vdc = self.get_vdc_details()
if vdc is None:
raise vimconn.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
if vdc is None:
raise vimconn.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
vm_details = {}
for vm in the_vapp.get_all_vms():
vm_details = {}
for vm in the_vapp.get_all_vms():
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vm.get('href'),
headers=headers)
if response.status_code != 200:
response = self.perform_request(req_type='GET',
url=vm.get('href'),
headers=headers)
if response.status_code != 200:
- self.logger.error("refresh_vms_status : REST call {} failed reason : {}"\
- "status code : {}".format(vm.get('href'),
- response.text,
- response.status_code))
- raise vimconn.vimconnException("refresh_vms_status : Failed to get "\
- "VM details")
+ self.logger.error("refresh_vms_status : REST call {} failed reason : {}"
+ "status code : {}".format(vm.get('href'),
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("refresh_vms_status : Failed to get VM details")
xmlroot = XmlElementTree.fromstring(response.text)
result = response.text.replace("\n", " ")
xmlroot = XmlElementTree.fromstring(response.text)
result = response.text.replace("\n", " ")
- hdd_match = re.search('vcloud:capacity="(\d+)"\svcloud:storageProfileOverrideVmDefault=',result)
+ hdd_match = re.search(
+ 'vcloud:capacity="(\d+)"\svcloud:storageProfileOverrideVmDefault=', result)
if hdd_match:
hdd_mb = hdd_match.group(1)
vm_details['hdd_mb'] = int(hdd_mb) if hdd_mb else None
if hdd_match:
hdd_mb = hdd_match.group(1)
vm_details['hdd_mb'] = int(hdd_mb) if hdd_mb else None
- cpus_match = re.search('<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>',result)
+ cpus_match = re.search(
+ '<rasd:Description>Number of Virtual CPUs</.*?>(\d+)</rasd:VirtualQuantity>', result)
if cpus_match:
cpus = cpus_match.group(1)
vm_details['cpus'] = int(cpus) if cpus else None
if cpus_match:
cpus = cpus_match.group(1)
vm_details['cpus'] = int(cpus) if cpus else None
- memory_mb = re.search('<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>',result).group(1)
+ memory_mb = re.search(
+ '<rasd:Description>Memory Size</.*?>(\d+)</rasd:VirtualQuantity>', result).group(1)
vm_details['memory_mb'] = int(memory_mb) if memory_mb else None
vm_details['status'] = vcdStatusCode2manoFormat[int(xmlroot.get('status'))]
vm_details['id'] = xmlroot.get('id')
vm_details['memory_mb'] = int(memory_mb) if memory_mb else None
vm_details['status'] = vcdStatusCode2manoFormat[int(xmlroot.get('status'))]
vm_details['id'] = xmlroot.get('id')
# get networks
vm_ip = None
vm_mac = None
# get networks
vm_ip = None
vm_mac = None
- networks = re.findall('<NetworkConnection needsCustomization=.*?</NetworkConnection>',result)
+ networks = re.findall('<NetworkConnection needsCustomization=.*?</NetworkConnection>', result)
- mac_s = re.search('<MACAddress>(.*?)</MACAddress>',network)
+ mac_s = re.search('<MACAddress>(.*?)</MACAddress>', network)
vm_mac = mac_s.group(1) if mac_s else None
vm_mac = mac_s.group(1) if mac_s else None
- ip_s = re.search('<IpAddress>(.*?)</IpAddress>',network)
+ ip_s = re.search('<IpAddress>(.*?)</IpAddress>', network)
vm_ip = ip_s.group(1) if ip_s else None
if vm_ip is None:
if not nsx_edge_list:
nsx_edge_list = self.get_edge_details()
if nsx_edge_list is None:
vm_ip = ip_s.group(1) if ip_s else None
if vm_ip is None:
if not nsx_edge_list:
nsx_edge_list = self.get_edge_details()
if nsx_edge_list is None:
- raise vimconn.vimconnException("refresh_vms_status:"\
+ raise vimconn.vimconnException("refresh_vms_status:"
"Failed to get edge details from NSX Manager")
if vm_mac is not None:
vm_ip = self.get_ipaddr_from_NSXedge(nsx_edge_list, vm_mac)
"Failed to get edge details from NSX Manager")
if vm_mac is not None:
vm_ip = self.get_ipaddr_from_NSXedge(nsx_edge_list, vm_mac)
- net_s = re.search('network="(.*?)"',network)
+ net_s = re.search('network="(.*?)"', network)
network_name = net_s.group(1) if net_s else None
vm_net_id = self.get_network_id_by_name(network_name)
network_name = net_s.group(1) if net_s else None
vm_net_id = self.get_network_id_by_name(network_name)
def get_edge_details(self):
"""Get the NSX edge list from NSX Manager
Returns list of NSX edges
def get_edge_details(self):
"""Get the NSX edge list from NSX Manager
Returns list of NSX edges
try:
resp = requests.get(self.nsx_manager + nsx_api_url,
try:
resp = requests.get(self.nsx_manager + nsx_api_url,
- auth = (self.nsx_user, self.nsx_password),
- verify = False, headers = rheaders)
+ auth=(self.nsx_user, self.nsx_password),
+ verify=False, headers=rheaders)
if resp.status_code == requests.codes.ok:
paged_Edge_List = XmlElementTree.fromstring(resp.text)
for edge_pages in paged_Edge_List:
if resp.status_code == requests.codes.ok:
paged_Edge_List = XmlElementTree.fromstring(resp.text)
for edge_pages in paged_Edge_List:
if edge_summary.tag == 'pagingInfo':
for element in edge_summary:
if element.tag == 'totalCount' and element.text == '0':
if edge_summary.tag == 'pagingInfo':
for element in edge_summary:
if element.tag == 'totalCount' and element.text == '0':
- raise vimconn.vimconnException("get_edge_details: No NSX edges details found: {}"
- .format(self.nsx_manager))
+ raise vimconn.vimconnException(
+ "get_edge_details: No NSX edges details found: {}"
+ .format(self.nsx_manager))
if edge_summary.tag == 'edgeSummary':
for element in edge_summary:
if edge_summary.tag == 'edgeSummary':
for element in edge_summary:
.format(self.nsx_manager))
if not edge_list:
.format(self.nsx_manager))
if not edge_list:
- raise vimconn.vimconnException("get_edge_details: "\
+ raise vimconn.vimconnException("get_edge_details: "
"No NSX edge details found: {}"
.format(self.nsx_manager))
else:
"No NSX edge details found: {}"
.format(self.nsx_manager))
else:
return None
except Exception as exp:
return None
except Exception as exp:
- self.logger.debug("get_edge_details: "\
+ self.logger.debug("get_edge_details: "
"Failed to get NSX edge details from NSX Manager: {}"
.format(exp))
"Failed to get NSX edge details from NSX Manager: {}"
.format(exp))
- raise vimconn.vimconnException("get_edge_details: "\
+ raise vimconn.vimconnException("get_edge_details: "
"Failed to get NSX edge details from NSX Manager: {}"
.format(exp))
"Failed to get NSX edge details from NSX Manager: {}"
.format(exp))
def get_ipaddr_from_NSXedge(self, nsx_edges, mac_address):
"""Get IP address details from NSX edges, using the MAC address
PARAMS: nsx_edges : List of NSX edges
def get_ipaddr_from_NSXedge(self, nsx_edges, mac_address):
"""Get IP address details from NSX edges, using the MAC address
PARAMS: nsx_edges : List of NSX edges
try:
for edge in nsx_edges:
try:
for edge in nsx_edges:
- nsx_api_url = '/api/4.0/edges/'+ edge +'/dhcp/leaseInfo'
+ nsx_api_url = '/api/4.0/edges/' + edge + '/dhcp/leaseInfo'
resp = requests.get(self.nsx_manager + nsx_api_url,
resp = requests.get(self.nsx_manager + nsx_api_url,
- auth = (self.nsx_user, self.nsx_password),
- verify = False, headers = rheaders)
+ auth=(self.nsx_user, self.nsx_password),
+ verify=False, headers=rheaders)
if resp.status_code == requests.codes.ok:
dhcp_leases = XmlElementTree.fromstring(resp.text)
if resp.status_code == requests.codes.ok:
dhcp_leases = XmlElementTree.fromstring(resp.text)
dhcpLeaseInfo = child
for leaseInfo in dhcpLeaseInfo:
for elem in leaseInfo:
dhcpLeaseInfo = child
for leaseInfo in dhcpLeaseInfo:
for elem in leaseInfo:
- if (elem.tag)=='macAddress':
+ if (elem.tag) == 'macAddress':
edge_mac_addr = elem.text
edge_mac_addr = elem.text
- if (elem.tag)=='ipAddress':
+ if (elem.tag) == 'ipAddress':
ip_addr = elem.text
if edge_mac_addr is not None:
if edge_mac_addr == mac_address:
self.logger.debug("Found ip addr {} for mac {} at NSX edge {}"
ip_addr = elem.text
if edge_mac_addr is not None:
if edge_mac_addr == mac_address:
self.logger.debug("Found ip addr {} for mac {} at NSX edge {}"
- .format(ip_addr, mac_address,edge))
+ .format(ip_addr, mac_address, edge))
- self.logger.debug("get_ipaddr_from_NSXedge: "\
+ self.logger.debug("get_ipaddr_from_NSXedge: "
"Error occurred while getting DHCP lease info from NSX Manager: {}"
.format(resp.content))
"Error occurred while getting DHCP lease info from NSX Manager: {}"
.format(resp.content))
if vm__vim_uuid is None or action_dict is None:
raise vimconn.vimconnException("Invalid request. VM id or action is None.")
if vm__vim_uuid is None or action_dict is None:
raise vimconn.vimconnException("Invalid request. VM id or action is None.")
- org, vdc = self.get_vdc_details()
+ _, vdc = self.get_vdc_details()
if vdc is None:
raise vimconn.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
if vdc is None:
raise vimconn.vimconnException("Failed to get a reference of VDC for a tenant {}".format(self.tenant_name))
result = self.client.get_task_monitor().wait_for_success(task=poweron_task)
self.instance_actions_result("resume", result, vapp_name)
elif "shutoff" in action_dict or "shutdown" in action_dict:
result = self.client.get_task_monitor().wait_for_success(task=poweron_task)
self.instance_actions_result("resume", result, vapp_name)
elif "shutoff" in action_dict or "shutdown" in action_dict:
- action_name , value = list(action_dict.items())[0]
+ action_name, _ = list(action_dict.items())[0]
self.logger.info("action_vminstance: {} vApp: {}".format(action_name, vapp_name))
shutdown_task = vapp.shutdown()
result = self.client.get_task_monitor().wait_for_success(task=shutdown_task)
self.logger.info("action_vminstance: {} vApp: {}".format(action_name, vapp_name))
shutdown_task = vapp.shutdown()
result = self.client.get_task_monitor().wait_for_success(task=shutdown_task)
reboot_task = vapp.reboot()
self.client.get_task_monitor().wait_for_success(task=reboot_task)
else:
reboot_task = vapp.reboot()
self.client.get_task_monitor().wait_for_success(task=reboot_task)
else:
- raise vimconn.vimconnException("action_vminstance: Invalid action {} or action is None.".format(action_dict))
+ raise vimconn.vimconnException(
+ "action_vminstance: Invalid action {} or action is None.".format(action_dict))
- except Exception as exp :
+ except Exception as exp:
self.logger.debug("action_vminstance: Failed with Exception {}".format(exp))
raise vimconn.vimconnException("action_vminstance: Failed with Exception {}".format(exp))
self.logger.debug("action_vminstance: Failed with Exception {}".format(exp))
raise vimconn.vimconnException("action_vminstance: Failed with Exception {}".format(exp))
- if console_type==None or console_type=='novnc':
+ if console_type is None or console_type == 'novnc':
url_rest_call = "{}/api/vApp/vm-{}/screen/action/acquireMksTicket".format(self.url, vm_id)
url_rest_call = "{}/api/vApp/vm-{}/screen/action/acquireMksTicket".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='POST',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='POST',
- url=url_rest_call,
- headers=headers)
+ url=url_rest_call,
+ headers=headers)
if response.status_code == 403:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
if response.status_code == 403:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {}".format(url_rest_call,
"status code : {}".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("get_vminstance_console : Failed to get "\
- "VM Mks ticket details")
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("get_vminstance_console : Failed to get "
+ "VM Mks ticket details")
s = re.search("<Host>(.*?)</Host>", response.text)
console_dict['server'] = s.group(1) if s else None
s1 = re.search("<Port>(\d+)</Port>", response.text)
console_dict['port'] = s1.group(1) if s1 else None
s = re.search("<Host>(.*?)</Host>", response.text)
console_dict['server'] = s.group(1) if s else None
s1 = re.search("<Port>(\d+)</Port>", response.text)
console_dict['port'] = s1.group(1) if s1 else None
url_rest_call = "{}/api/vApp/vm-{}/screen/action/acquireTicket".format(self.url, vm_id)
url_rest_call = "{}/api/vApp/vm-{}/screen/action/acquireTicket".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='POST',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='POST',
- url=url_rest_call,
- headers=headers)
+ url=url_rest_call,
+ headers=headers)
if response.status_code == 403:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
if response.status_code == 403:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {}".format(url_rest_call,
"status code : {}".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("get_vminstance_console : Failed to get "\
- "VM console details")
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("get_vminstance_console : Failed to get "
+ "VM console details")
s = re.search(">.*?/(vm-\d+.*)</", response.text)
console_dict['suffix'] = s.group(1) if s else None
console_dict['protocol'] = "https"
s = re.search(">.*?/(vm-\d+.*)</", response.text)
console_dict['suffix'] = s.group(1) if s else None
console_dict['protocol'] = "https"
for net_uuid in org_network_dict:
if net_uuid == network_uuid:
return org_network_dict[net_uuid]
for net_uuid in org_network_dict:
if net_uuid == network_uuid:
return org_network_dict[net_uuid]
self.logger.debug("Exception in get_network_name_by_id")
self.logger.debug(traceback.format_exc())
self.logger.debug("Exception in get_network_name_by_id")
self.logger.debug(traceback.format_exc())
vm_list_rest_call = ''.join(url_list)
if client_as_admin._session:
vm_list_rest_call = ''.join(url_list)
if client_as_admin._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': client_as_admin._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': client_as_admin._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
provider_network = None
available_network = None
provider_network = None
available_network = None
- add_vdc_rest_url = None
+ # add_vdc_rest_url = None
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call,
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call,
if child.tag.split("}")[1] == 'Link':
if child.attrib.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
and child.attrib.get('rel') == 'add':
if child.tag.split("}")[1] == 'Link':
if child.attrib.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
and child.attrib.get('rel') == 'add':
- add_vdc_rest_url = child.attrib.get('href')
- except:
+ child.attrib.get('href')
+ except Exception:
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
if networks.attrib.get('href') is not None and networks.attrib.get('name') is not None:
if networks.attrib.get('name') == physical_network_name:
network_url = networks.attrib.get('href')
if networks.attrib.get('href') is not None and networks.attrib.get('name') is not None:
if networks.attrib.get('name') == physical_network_name:
network_url = networks.attrib.get('href')
- available_network = network_url[network_url.rindex('/')+1:]
+ available_network = network_url[network_url.rindex('/') + 1:]
break
except Exception as e:
return None
break
except Exception as e:
return None
vm_list_rest_call = ''.join(url_list)
if self.client._session:
vm_list_rest_call = ''.join(url_list)
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
- url=vm_list_rest_call,
- headers=headers)
+ url=vm_list_rest_call,
+ headers=headers)
if response.status_code == 403:
response = self.retry_rest('GET', vm_list_rest_call)
if response.status_code == 403:
response = self.retry_rest('GET', vm_list_rest_call)
vm_list_rest_call = ''.join(url_list)
if self.client._session:
vm_list_rest_call = ''.join(url_list)
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
- #response = requests.get(vm_list_rest_call, headers=headers, verify=False)
+ # response = requests.get(vm_list_rest_call, headers=headers, verify=False)
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
if child.attrib['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
catalog_list[child.attrib['href'].split("/")[-1:][0]] = child.attrib['name']
org_dict['catalogs'] = catalog_list
if child.attrib['type'] == 'application/vnd.vmware.vcloud.catalog+xml':
catalog_list[child.attrib['href'].split("/")[-1:][0]] = child.attrib['name']
org_dict['catalogs'] = catalog_list
if vm_xml.tag.split("}")[1] == 'Org':
org_uuid = vm_xml.attrib['href'].split('/')[-1:]
org_dict[org_uuid[0]] = vm_xml.attrib['name']
if vm_xml.tag.split("}")[1] == 'Org':
org_uuid = vm_xml.attrib['href'].split('/')[-1:]
org_dict[org_uuid[0]] = vm_xml.attrib['name']
# vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
# vm and use raw UUID as key
vapp_dict[rawuuid[0][13:]] = vm_xml.attrib
# vm in format vappTemplate-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
# vm and use raw UUID as key
vapp_dict[rawuuid[0][13:]] = vm_xml.attrib
# vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
# vm and use raw UUID as key
vm_dict[rawuuid[0][3:]] = vm_xml.attrib
# vm in format vm-e63d40e7-4ff5-4c6d-851f-96c1e4da86a5 we remove
# vm and use raw UUID as key
vm_dict[rawuuid[0][3:]] = vm_xml.attrib
if 'vm-' in rawuuid[0]:
vm_dict[rawuuid[0][3:]] = vm_xml.attrib
break
if 'vm-' in rawuuid[0]:
vm_dict[rawuuid[0][3:]] = vm_xml.attrib
break
vm_list_rest_call = ''.join(url_list)
if self.client._session:
vm_list_rest_call = ''.join(url_list)
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
- #Retry login if session expired & retry sending request
+ # Retry login if session expired & retry sending request
if response.status_code == 403:
response = self.retry_rest('GET', vm_list_rest_call)
if response.status_code == 403:
response = self.retry_rest('GET', vm_list_rest_call)
tagKey = configuration.tag.split("}")[1].strip()
if tagKey != "":
network_configuration[tagKey] = configuration.text.strip()
tagKey = configuration.tag.split("}")[1].strip()
if tagKey != "":
network_configuration[tagKey] = configuration.text.strip()
- except Exception as exp :
+ except Exception as exp:
self.logger.debug("get_vcd_network: Failed with Exception {}".format(exp))
raise vimconn.vimconnException("get_vcd_network: Failed with Exception {}".format(exp))
self.logger.debug("get_vcd_network: Failed with Exception {}".format(exp))
raise vimconn.vimconnException("get_vcd_network: Failed with Exception {}".format(exp))
vm_list_rest_call = ''.join(url_list)
if client._session:
vm_list_rest_call = ''.join(url_list)
if client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='DELETE',
url=vm_list_rest_call,
headers=headers)
response = self.perform_request(req_type='DELETE',
url=vm_list_rest_call,
headers=headers)
if len(vcd_uuid) == 4:
self.logger.info("Created new network name: {} uuid: {}".format(network_name, vcd_uuid[3]))
return vcd_uuid[3]
if len(vcd_uuid) == 4:
self.logger.info("Created new network name: {} uuid: {}".format(network_name, vcd_uuid[3]))
return vcd_uuid[3]
self.logger.debug("Failed create network {}".format(network_name))
return None
self.logger.debug("Failed create network {}".format(network_name))
return None
vm_list_rest_call = ''.join(url_list)
if client_as_admin._session:
vm_list_rest_call = ''.join(url_list)
if client_as_admin._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': client_as_admin._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': client_as_admin._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
if child.attrib.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
and child.attrib.get('rel') == 'add':
add_vdc_rest_url = child.attrib.get('href')
if child.attrib.get('type') == 'application/vnd.vmware.vcloud.orgVdcNetwork+xml' \
and child.attrib.get('rel') == 'add':
add_vdc_rest_url = child.attrib.get('href')
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
if networks.attrib.get('href') is not None:
available_networks = networks.attrib.get('href')
break
if networks.attrib.get('href') is not None:
available_networks = networks.attrib.get('href')
break
- #Configure IP profile of the network
+ # Configure IP profile of the network
ip_profile = ip_profile if ip_profile is not None else DEFAULT_IP_PROFILE
if 'subnet_address' not in ip_profile or ip_profile['subnet_address'] is None:
ip_profile = ip_profile if ip_profile is not None else DEFAULT_IP_PROFILE
if 'subnet_address' not in ip_profile or ip_profile['subnet_address'] is None:
ip_base = "192.168.{}.".format(subnet_rand)
ip_profile['subnet_address'] = ip_base + "0/24"
else:
ip_base = "192.168.{}.".format(subnet_rand)
ip_profile['subnet_address'] = ip_base + "0/24"
else:
- ip_base = ip_profile['subnet_address'].rsplit('.',1)[0] + '.'
+ ip_base = ip_profile['subnet_address'].rsplit('.', 1)[0] + '.'
if 'gateway_address' not in ip_profile or ip_profile['gateway_address'] is None:
if 'gateway_address' not in ip_profile or ip_profile['gateway_address'] is None:
- ip_profile['gateway_address']=ip_base + "1"
+ ip_profile['gateway_address'] = ip_base + "1"
if 'dhcp_count' not in ip_profile or ip_profile['dhcp_count'] is None:
if 'dhcp_count' not in ip_profile or ip_profile['dhcp_count'] is None:
- ip_profile['dhcp_count']=DEFAULT_IP_PROFILE['dhcp_count']
+ ip_profile['dhcp_count'] = DEFAULT_IP_PROFILE['dhcp_count']
if 'dhcp_enabled' not in ip_profile or ip_profile['dhcp_enabled'] is None:
if 'dhcp_enabled' not in ip_profile or ip_profile['dhcp_enabled'] is None:
- ip_profile['dhcp_enabled']=DEFAULT_IP_PROFILE['dhcp_enabled']
+ ip_profile['dhcp_enabled'] = DEFAULT_IP_PROFILE['dhcp_enabled']
if 'dhcp_start_address' not in ip_profile or ip_profile['dhcp_start_address'] is None:
if 'dhcp_start_address' not in ip_profile or ip_profile['dhcp_start_address'] is None:
- ip_profile['dhcp_start_address']=ip_base + "3"
+ ip_profile['dhcp_start_address'] = ip_base + "3"
if 'ip_version' not in ip_profile or ip_profile['ip_version'] is None:
if 'ip_version' not in ip_profile or ip_profile['ip_version'] is None:
- ip_profile['ip_version']=DEFAULT_IP_PROFILE['ip_version']
+ ip_profile['ip_version'] = DEFAULT_IP_PROFILE['ip_version']
if 'dns_address' not in ip_profile or ip_profile['dns_address'] is None:
if 'dns_address' not in ip_profile or ip_profile['dns_address'] is None:
- ip_profile['dns_address']=ip_base + "2"
+ ip_profile['dns_address'] = ip_base + "2"
- gateway_address=ip_profile['gateway_address']
- dhcp_count=int(ip_profile['dhcp_count'])
- subnet_address=self.convert_cidr_to_netmask(ip_profile['subnet_address'])
+ gateway_address = ip_profile['gateway_address']
+ dhcp_count = int(ip_profile['dhcp_count'])
+ subnet_address = self.convert_cidr_to_netmask(ip_profile['subnet_address'])
- if ip_profile['dhcp_enabled']==True:
- dhcp_enabled='true'
+ if ip_profile['dhcp_enabled'] is True:
+ dhcp_enabled = 'true'
- dhcp_enabled='false'
- dhcp_start_address=ip_profile['dhcp_start_address']
+ dhcp_enabled = 'false'
+ dhcp_start_address = ip_profile['dhcp_start_address']
- #derive dhcp_end_address from dhcp_start_address & dhcp_count
+ # derive dhcp_end_address from dhcp_start_address & dhcp_count
end_ip_int = int(netaddr.IPAddress(dhcp_start_address))
end_ip_int += dhcp_count - 1
dhcp_end_address = str(netaddr.IPAddress(end_ip_int))
end_ip_int = int(netaddr.IPAddress(dhcp_start_address))
end_ip_int += dhcp_count - 1
dhcp_end_address = str(netaddr.IPAddress(end_ip_int))
- ip_version=ip_profile['ip_version']
- dns_address=ip_profile['dns_address']
+ # ip_version = ip_profile['ip_version']
+ dns_address = ip_profile['dns_address']
except KeyError as exp:
self.logger.debug("Create Network REST: Key error {}".format(exp))
raise vimconn.vimconnException("Create Network REST: Key error{}".format(exp))
except KeyError as exp:
self.logger.debug("Create Network REST: Key error {}".format(exp))
raise vimconn.vimconnException("Create Network REST: Key error{}".format(exp))
url_list = [self.url, '/api/admin/network/', parent_network_uuid]
available_networks = ''.join(url_list)
url_list = [self.url, '/api/admin/network/', parent_network_uuid]
available_networks = ''.join(url_list)
- #Creating all networks as Direct Org VDC type networks.
- #Unused in case of Underlay (data/ptp) network interface.
- fence_mode="isolated"
- is_inherited='false'
+ # Creating all networks as Direct Org VDC type networks.
+ # Unused in case of Underlay (data/ptp) network interface.
+ fence_mode = "isolated"
+ is_inherited = 'false'
dns_list = dns_address.split(";")
dns1 = dns_list[0]
dns2_text = ""
if len(dns_list) >= 2:
dns2_text = "\n <Dns2>{}</Dns2>\n".format(dns_list[1])
if net_type == "isolated":
dns_list = dns_address.split(";")
dns1 = dns_list[0]
dns2_text = ""
if len(dns_list) >= 2:
dns2_text = "\n <Dns2>{}</Dns2>\n".format(dns_list[1])
if net_type == "isolated":
+ fence_mode = "isolated"
data = """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
<Description>Openmano created</Description>
<Configuration>
data = """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
<Description>Openmano created</Description>
<Configuration>
headers['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
try:
response = self.perform_request(req_type='POST',
headers['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
try:
response = self.perform_request(req_type='POST',
- url=add_vdc_rest_url,
- headers=headers,
- data=data)
+ url=add_vdc_rest_url,
+ headers=headers,
+ data=data)
if response.status_code != 201:
if response.status_code != 201:
- self.logger.debug("Create Network POST REST API call failed. Return status code {}, response.text: {}"
+ self.logger.debug("Create Network POST REST API call failed. "
+ "Return status code {}, response.text: {}"
.format(response.status_code, response.text))
else:
network_task = self.get_task_from_response(response.text)
.format(response.status_code, response.text))
else:
network_task = self.get_task_from_response(response.text)
"""
if cidr_ip is not None:
if '/' in cidr_ip:
"""
if cidr_ip is not None:
if '/' in cidr_ip:
- network, net_bits = cidr_ip.split('/')
+ _, net_bits = cidr_ip.split('/')
netmask = socket.inet_ntoa(struct.pack(">I", (0xffffffff << (32 - int(net_bits))) & 0xffffffff))
else:
netmask = cidr_ip
netmask = socket.inet_ntoa(struct.pack(">I", (0xffffffff << (32 - int(net_bits))) & 0xffffffff))
else:
netmask = cidr_ip
url_list = [self.url, '/api/admin']
if vca:
url_list = [self.url, '/api/admin']
if vca:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=''.join(url_list),
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=''.join(url_list),
vdc_id = child.attrib.get('href').split("/")[-1]
vdc_dict[vdc_id] = task_resp_xmlroot.get('href')
return vdc_dict
vdc_id = child.attrib.get('href').split("/")[-1]
vdc_dict[vdc_id] = task_resp_xmlroot.get('href')
return vdc_dict
self.logger.debug("Respond body {}".format(xml_content))
return None
self.logger.debug("Respond body {}".format(xml_content))
return None
url_list = [self.url, '/api/vdcTemplates']
vm_list_rest_call = ''.join(url_list)
url_list = [self.url, '/api/vdcTemplates']
vm_list_rest_call = ''.join(url_list)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
if child.tag.split("}")[1] == 'VdcTemplate':
if child.attrib.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml':
vdc_template_ref = child.attrib.get('href')
if child.tag.split("}")[1] == 'VdcTemplate':
if child.attrib.get('type') == 'application/vnd.vmware.admin.vdcTemplate+xml':
vdc_template_ref = child.attrib.get('href')
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
if response.status_code >= 200 and response.status_code < 300:
return response.text
return None
if response.status_code >= 200 and response.status_code < 300:
return response.text
return None
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
vm_list_rest_call = ''.join(url_list)
if vca._session:
vm_list_rest_call = ''.join(url_list)
if vca._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
provider_vdc_ref = None
add_vdc_rest_url = None
response = self.perform_request(req_type='GET',
url=vm_list_rest_call,
headers=headers)
provider_vdc_ref = None
add_vdc_rest_url = None
- available_networks = None
+ # available_networks = None
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call,
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call,
if child.attrib.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
and child.attrib.get('rel') == 'add':
add_vdc_rest_url = child.attrib.get('href')
if child.attrib.get('type') == 'application/vnd.vmware.admin.createVdcParams+xml' \
and child.attrib.get('rel') == 'add':
add_vdc_rest_url = child.attrib.get('href')
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response.text))
return None
if child.tag.split("}")[1] == 'ProviderVdcReferences':
for sub_child in child:
provider_vdc_ref = sub_child.attrib.get('href')
if child.tag.split("}")[1] == 'ProviderVdcReferences':
for sub_child in child:
provider_vdc_ref = sub_child.attrib.get('href')
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response))
return None
self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
self.logger.debug("Respond body {}".format(response))
return None
get_vapp_restcall = ''.join(url_list)
if vca._session:
get_vapp_restcall = ''.join(url_list)
if vca._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=get_vapp_restcall,
headers=headers)
if response.status_code == 403:
'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=get_vapp_restcall,
headers=headers)
if response.status_code == 403:
- if need_admin_access == False:
+ if need_admin_access is False:
response = self.retry_rest('GET', get_vapp_restcall)
if response.status_code != requests.codes.ok:
response = self.retry_rest('GET', get_vapp_restcall)
if response.status_code != requests.codes.ok:
xmlroot_respond = XmlElementTree.fromstring(response.text)
parsed_respond['ovfDescriptorUploaded'] = xmlroot_respond.attrib['ovfDescriptorUploaded']
xmlroot_respond = XmlElementTree.fromstring(response.text)
parsed_respond['ovfDescriptorUploaded'] = xmlroot_respond.attrib['ovfDescriptorUploaded']
- namespaces = {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
- 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
- 'vmw': 'http://www.vmware.com/schema/ovf',
- 'vm': 'http://www.vmware.com/vcloud/v1.5',
- 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
- "vmext":"http://www.vmware.com/vcloud/extension/v1.5",
- "xmlns":"http://www.vmware.com/vcloud/v1.5"
- }
+ namespaces = {
+ "vssd": "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData",
+ 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
+ 'vmw': 'http://www.vmware.com/schema/ovf',
+ 'vm': 'http://www.vmware.com/vcloud/v1.5',
+ 'rasd': "http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
+ "vmext": "http://www.vmware.com/vcloud/extension/v1.5",
+ "xmlns": "http://www.vmware.com/vcloud/v1.5"
+ }
created_section = xmlroot_respond.find('vm:DateCreated', namespaces)
if created_section is not None:
created_section = xmlroot_respond.find('vm:DateCreated', namespaces)
if created_section is not None:
if children_section is not None:
parsed_respond['name'] = children_section.attrib['name']
parsed_respond['nestedHypervisorEnabled'] = children_section.attrib['nestedHypervisorEnabled'] \
if children_section is not None:
parsed_respond['name'] = children_section.attrib['name']
parsed_respond['nestedHypervisorEnabled'] = children_section.attrib['nestedHypervisorEnabled'] \
- if "nestedHypervisorEnabled" in children_section.attrib else None
+ if "nestedHypervisorEnabled" in children_section.attrib else None
parsed_respond['deployed'] = children_section.attrib['deployed']
parsed_respond['status'] = children_section.attrib['status']
parsed_respond['vmuuid'] = children_section.attrib['id'].split(":")[-1]
parsed_respond['deployed'] = children_section.attrib['deployed']
parsed_respond['status'] = children_section.attrib['status']
parsed_respond['vmuuid'] = children_section.attrib['id'].split(":")[-1]
vmext = vim_info.find('vmext:VmVimObjectRef', namespaces)
if vmext is not None:
vm_vcenter_info["vm_moref_id"] = vmext.find('vmext:MoRef', namespaces).text
vmext = vim_info.find('vmext:VmVimObjectRef', namespaces)
if vmext is not None:
vm_vcenter_info["vm_moref_id"] = vmext.find('vmext:MoRef', namespaces).text
- parsed_respond["vm_vcenter_info"]= vm_vcenter_info
+ parsed_respond["vm_vcenter_info"] = vm_vcenter_info
virtual_hardware_section = children_section.find('ovf:VirtualHardwareSection', namespaces)
vm_virtual_hardware_info = {}
if virtual_hardware_section is not None:
virtual_hardware_section = children_section.find('ovf:VirtualHardwareSection', namespaces)
vm_virtual_hardware_info = {}
if virtual_hardware_section is not None:
- for item in virtual_hardware_section.iterfind('ovf:Item',namespaces):
- if item.find("rasd:Description",namespaces).text == "Hard disk":
- disk_size = item.find("rasd:HostResource" ,namespaces
- ).attrib["{"+namespaces['vm']+"}capacity"]
+ for item in virtual_hardware_section.iterfind('ovf:Item', namespaces):
+ if item.find("rasd:Description", namespaces).text == "Hard disk":
+ disk_size = item.find(
+ "rasd:HostResource", namespaces).attrib["{" + namespaces['vm'] + "}capacity"]
- vm_virtual_hardware_info["disk_size"]= disk_size
+ vm_virtual_hardware_info["disk_size"] = disk_size
break
for link in virtual_hardware_section:
break
for link in virtual_hardware_section:
vm_virtual_hardware_info["disk_edit_href"] = link.attrib['href']
break
vm_virtual_hardware_info["disk_edit_href"] = link.attrib['href']
break
- parsed_respond["vm_virtual_hardware"]= vm_virtual_hardware_info
- except Exception as exp :
+ parsed_respond["vm_virtual_hardware"] = vm_virtual_hardware_info
+ except Exception as exp:
self.logger.info("Error occurred calling rest api for getting vApp details {}".format(exp))
return parsed_respond
self.logger.info("Error occurred calling rest api for getting vApp details {}".format(exp))
return parsed_respond
if vm_uuid is None:
return None
if self.client._session:
if vm_uuid is None:
return None
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
vm_dict = self.get_vapp_details_rest(vapp_uuid=vm_uuid)
console_dict = vm_dict['acquireTicket']
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
vm_dict = self.get_vapp_details_rest(vapp_uuid=vm_uuid)
console_dict = vm_dict['acquireTicket']
- #Flavor disk is in GB convert it into MB
+ # Flavor disk is in GB convert it into MB
flavor_disk = int(flavor_disk) * 1024
vm_details = self.get_vapp_details_rest(vapp_uuid)
if vm_details:
vm_name = vm_details["name"]
flavor_disk = int(flavor_disk) * 1024
vm_details = self.get_vapp_details_rest(vapp_uuid)
if vm_details:
vm_name = vm_details["name"]
- self.logger.info("VM: {} flavor_disk :{}".format(vm_name , flavor_disk))
+ self.logger.info("VM: {} flavor_disk :{}".format(vm_name, flavor_disk))
if vm_details and "vm_virtual_hardware" in vm_details:
vm_disk = int(vm_details["vm_virtual_hardware"]["disk_size"])
disk_edit_href = vm_details["vm_virtual_hardware"]["disk_edit_href"]
if vm_details and "vm_virtual_hardware" in vm_details:
vm_disk = int(vm_details["vm_virtual_hardware"]["disk_size"])
disk_edit_href = vm_details["vm_virtual_hardware"]["disk_edit_href"]
- self.logger.info("VM: {} VM_disk :{}".format(vm_name , vm_disk))
+ self.logger.info("VM: {} VM_disk :{}".format(vm_name, vm_disk))
if flavor_disk > vm_disk:
if flavor_disk > vm_disk:
- status = self.modify_vm_disk_rest(disk_edit_href ,flavor_disk)
- self.logger.info("Modify disk of VM {} from {} to {} MB".format(vm_name,
- vm_disk, flavor_disk ))
+ status = self.modify_vm_disk_rest(disk_edit_href, flavor_disk)
+ self.logger.info("Modify disk of VM {} from {} to {} MB".format(
+ vm_name,
+ vm_disk, flavor_disk))
else:
status = True
self.logger.info("No need to modify disk of VM {}".format(vm_name))
else:
status = True
self.logger.info("No need to modify disk of VM {}".format(vm_name))
except Exception as exp:
self.logger.info("Error occurred while modifing disk size {}".format(exp))
except Exception as exp:
self.logger.info("Error occurred while modifing disk size {}".format(exp))
-
- def modify_vm_disk_rest(self, disk_href , disk_size):
+ def modify_vm_disk_rest(self, disk_href, disk_size):
"""
Method retrieve modify vm disk size
"""
Method retrieve modify vm disk size
return None
if self.client._session:
return None
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=disk_href,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=disk_href,
if response.status_code != requests.codes.ok:
self.logger.debug("GET REST API call {} failed. Return status code {}".format(disk_href,
if response.status_code != requests.codes.ok:
self.logger.debug("GET REST API call {} failed. Return status code {}".format(disk_href,
return None
try:
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
return None
try:
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
- namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
+ namespaces["xmlns"] = "http://www.vmware.com/vcloud/v1.5"
- for item in lxmlroot_respond.iterfind('xmlns:Item',namespaces):
- if item.find("rasd:Description",namespaces).text == "Hard disk":
- disk_item = item.find("rasd:HostResource" ,namespaces )
+ for item in lxmlroot_respond.iterfind('xmlns:Item', namespaces):
+ if item.find("rasd:Description", namespaces).text == "Hard disk":
+ disk_item = item.find("rasd:HostResource", namespaces)
if disk_item is not None:
if disk_item is not None:
- disk_item.attrib["{"+namespaces['xmlns']+"}capacity"] = str(disk_size)
+ disk_item.attrib["{" + namespaces['xmlns'] + "}capacity"] = str(disk_size)
break
data = lxmlElementTree.tostring(lxmlroot_respond, encoding='utf8', method='xml',
break
data = lxmlElementTree.tostring(lxmlroot_respond, encoding='utf8', method='xml',
- #Send PUT request to modify disk size
+ # Send PUT request to modify disk size
headers['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
response = self.perform_request(req_type='PUT',
headers['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItemsList+xml; charset=ISO-8859-1'
response = self.perform_request(req_type='PUT',
- url=disk_href,
- headers=headers,
- data=data)
+ url=disk_href,
+ headers=headers,
+ data=data)
if response.status_code == 403:
add_headers = {'Content-Type': headers['Content-Type']}
response = self.retry_rest('PUT', disk_href, add_headers, data)
if response.status_code != 202:
self.logger.debug("PUT REST API call {} failed. Return status code {}".format(disk_href,
if response.status_code == 403:
add_headers = {'Content-Type': headers['Content-Type']}
response = self.retry_rest('PUT', disk_href, add_headers, data)
if response.status_code != 202:
self.logger.debug("PUT REST API call {} failed. Return status code {}".format(disk_href,
else:
modify_disk_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=modify_disk_task)
else:
modify_disk_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=modify_disk_task)
try:
no_of_pci_devices = len(pci_devices)
if no_of_pci_devices > 0:
try:
no_of_pci_devices = len(pci_devices)
if no_of_pci_devices > 0:
host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
self.logger.info("VM {} is currently on host {}".format(vm_obj, host_obj))
if host_obj and vm_obj:
host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
self.logger.info("VM {} is currently on host {}".format(vm_obj, host_obj))
if host_obj and vm_obj:
- #get PCI devies from host on which vapp is currently installed
+ # get PCI devies from host on which vapp is currently installed
avilable_pci_devices = self.get_pci_devices(host_obj, no_of_pci_devices)
if avilable_pci_devices is None:
avilable_pci_devices = self.get_pci_devices(host_obj, no_of_pci_devices)
if avilable_pci_devices is None:
- #find other hosts with active pci devices
- new_host_obj , avilable_pci_devices = self.get_host_and_PCIdevices(
- content,
- no_of_pci_devices
- )
+ # find other hosts with active pci devices
+ new_host_obj, avilable_pci_devices = self.get_host_and_PCIdevices(
+ content,
+ no_of_pci_devices
+ )
- if new_host_obj is not None and avilable_pci_devices is not None and len(avilable_pci_devices)> 0:
- #Migrate vm to the host where PCI devices are availble
+ if (new_host_obj is not None and
+ avilable_pci_devices is not None and
+ len(avilable_pci_devices) > 0):
+ # Migrate vm to the host where PCI devices are availble
self.logger.info("Relocate VM {} on new host {}".format(vm_obj, new_host_obj))
task = self.relocate_vm(new_host_obj, vm_obj)
if task is not None:
self.logger.info("Relocate VM {} on new host {}".format(vm_obj, new_host_obj))
task = self.relocate_vm(new_host_obj, vm_obj)
if task is not None:
else:
self.logger.info("Fail to migrate VM : {}".format(result))
raise vimconn.vimconnNotFoundException(
else:
self.logger.info("Fail to migrate VM : {}".format(result))
raise vimconn.vimconnNotFoundException(
- "Fail to migrate VM : {} to host {}".format(
- vmname_andid,
- new_host_obj)
+ "Fail to migrate VM : {} to host {}".format(
+ vmname_andid,
+ new_host_obj)
- if host_obj is not None and avilable_pci_devices is not None and len(avilable_pci_devices)> 0:
- #Add PCI devices one by one
+ if host_obj is not None and avilable_pci_devices is not None and len(avilable_pci_devices) > 0:
+ # Add PCI devices one by one
for pci_device in avilable_pci_devices:
task = self.add_pci_to_vm(host_obj, vm_obj, pci_device)
if task:
for pci_device in avilable_pci_devices:
task = self.add_pci_to_vm(host_obj, vm_obj, pci_device)
if task:
- status= self.wait_for_vcenter_task(task, vcenter_conect)
+ status = self.wait_for_vcenter_task(task, vcenter_conect)
- self.logger.info("Added PCI device {} to VM {}".format(pci_device,str(vm_obj)))
+ self.logger.info("Added PCI device {} to VM {}".format(pci_device, str(vm_obj)))
- self.logger.error("Fail to add PCI device {} to VM {}".format(pci_device,str(vm_obj)))
+ self.logger.error("Fail to add PCI device {} to VM {}".format(pci_device,
+ str(vm_obj)))
return True, vm_obj, vcenter_conect
else:
return True, vm_obj, vcenter_conect
else:
- self.logger.error("Currently there is no host with"\
+ self.logger.error("Currently there is no host with"
" {} number of avaialble PCI devices required for VM {}".format(
" {} number of avaialble PCI devices required for VM {}".format(
- no_of_pci_devices,
- vmname_andid)
+ no_of_pci_devices,
+ vmname_andid)
)
raise vimconn.vimconnNotFoundException(
)
raise vimconn.vimconnNotFoundException(
- "Currently there is no host with {} "\
- "number of avaialble PCI devices required for VM {}".format(
- no_of_pci_devices,
- vmname_andid))
+ "Currently there is no host with {} "
+ "number of avaialble PCI devices required for VM {}".format(
+ no_of_pci_devices,
+ vmname_andid))
- self.logger.debug("No infromation about PCI devices {} ",pci_devices)
+ self.logger.debug("No infromation about PCI devices {} ", pci_devices)
except vmodl.MethodFault as error:
except vmodl.MethodFault as error:
- self.logger.error("Error occurred while adding PCI devices {} ",error)
+ self.logger.error("Error occurred while adding PCI devices {} ", error)
return None, vm_obj, vcenter_conect
def get_vm_obj(self, content, mob_id):
return None, vm_obj, vcenter_conect
def get_vm_obj(self, content, mob_id):
"""
vm_obj = None
host_obj = None
"""
vm_obj = None
host_obj = None
container = content.viewManager.CreateContainerView(content.rootFolder,
container = content.viewManager.CreateContainerView(content.rootFolder,
- [vim.VirtualMachine], True
- )
+ [vim.VirtualMachine], True
+ )
for vm in container.view:
mobID = vm._GetMoId()
if mobID == mob_id:
for vm in container.view:
mobID = vm._GetMoId()
if mobID == mob_id:
all_device_ids.append(device.id)
all_devices.append(device)
all_device_ids.append(device.id)
all_devices.append(device)
- #check if devices are in use
+ # check if devices are in use
avalible_devices = all_devices
for vm in host.vm:
if vm.runtime.powerState == vim.VirtualMachinePowerState.poweredOn:
avalible_devices = all_devices
for vm in host.vm:
if vm.runtime.powerState == vim.VirtualMachinePowerState.poweredOn:
if use_device.id == device.backing.id:
avalible_devices.remove(use_device)
used_devices_ids.append(device.backing.id)
if use_device.id == device.backing.id:
avalible_devices.remove(use_device)
used_devices_ids.append(device.backing.id)
- self.logger.debug("Device {} from devices {}"\
- "is in use".format(device.backing.id,
- device)
- )
+ self.logger.debug("Device {} from devices {}"
+ "is in use".format(device.backing.id,
+ device)
+ )
if len(avalible_devices) < need_devices:
self.logger.debug("Host {} don't have {} number of active devices".format(host,
if len(avalible_devices) < need_devices:
self.logger.debug("Host {} don't have {} number of active devices".format(host,
self.logger.debug("found only {} devices {}".format(len(avalible_devices),
avalible_devices))
return None
else:
required_devices = avalible_devices[:need_devices]
self.logger.info("Found {} PCI devices on host {} but required only {}".format(
self.logger.debug("found only {} devices {}".format(len(avalible_devices),
avalible_devices))
return None
else:
required_devices = avalible_devices[:need_devices]
self.logger.info("Found {} PCI devices on host {} but required only {}".format(
- len(avalible_devices),
- host,
- need_devices))
+ len(avalible_devices),
+ host,
+ need_devices))
self.logger.info("Retruning {} devices as {}".format(need_devices,
self.logger.info("Retruning {} devices as {}".format(need_devices,
return required_devices
except Exception as exp:
return required_devices
except Exception as exp:
try:
if content:
container = content.viewManager.CreateContainerView(content.rootFolder,
try:
if content:
container = content.viewManager.CreateContainerView(content.rootFolder,
- [vim.HostSystem], True)
+ [vim.HostSystem], True)
for host in container.view:
devices = self.get_pci_devices(host, need_devices)
if devices:
for host in container.view:
devices = self.get_pci_devices(host, need_devices)
if devices:
except Exception as exp:
self.logger.error("Error {} occurred while finding pci devices on host: {}".format(exp, host_obj))
except Exception as exp:
self.logger.error("Error {} occurred while finding pci devices on host: {}".format(exp, host_obj))
- return host_obj,pci_device_objs
+ return host_obj, pci_device_objs
- def relocate_vm(self, dest_host, vm) :
+ def relocate_vm(self, dest_host, vm):
"""
Method to get the relocate VM to new host
"""
Method to get the relocate VM to new host
self.logger.info("Migrating {} to destination host {}".format(vm, dest_host))
except Exception as exp:
self.logger.error("Error occurred while relocate VM {} to new host {}: {}".format(
self.logger.info("Migrating {} to destination host {}".format(vm, dest_host))
except Exception as exp:
self.logger.error("Error occurred while relocate VM {} to new host {}: {}".format(
return task
def wait_for_vcenter_task(self, task, actionName='job', hideResult=False):
return task
def wait_for_vcenter_task(self, task, actionName='job', hideResult=False):
if task.info.state == vim.TaskInfo.State.success:
if task.info.result is not None and not hideResult:
self.logger.info('{} completed successfully, result: {}'.format(
if task.info.state == vim.TaskInfo.State.success:
if task.info.result is not None and not hideResult:
self.logger.info('{} completed successfully, result: {}'.format(
- actionName,
- task.info.result))
+ actionName,
+ task.info.result))
else:
self.logger.info('Task {} completed successfully.'.format(actionName))
else:
self.logger.error('{} did not complete successfully: {} '.format(
else:
self.logger.info('Task {} completed successfully.'.format(actionName))
else:
self.logger.error('{} did not complete successfully: {} '.format(
- actionName,
- task.info.error)
- )
+ actionName,
+ task.info.error)
+ )
- def add_pci_to_vm(self,host_object, vm_object, host_pci_dev):
+ def add_pci_to_vm(self, host_object, vm_object, host_pci_dev):
"""
Method to add pci device in given VM
"""
Method to add pci device in given VM
"""
task = None
if vm_object and host_object and host_pci_dev:
"""
task = None
if vm_object and host_object and host_pci_dev:
- try :
- #Add PCI device to VM
+ try:
+ # Add PCI device to VM
pci_passthroughs = vm_object.environmentBrowser.QueryConfigTarget(host=None).pciPassthrough
systemid_by_pciid = {item.pciDevice.id: item.systemId for item in pci_passthroughs}
pci_passthroughs = vm_object.environmentBrowser.QueryConfigTarget(host=None).pciPassthrough
systemid_by_pciid = {item.pciDevice.id: item.systemId for item in pci_passthroughs}
self.logger.error("Device {} is not a passthrough device ".format(host_pci_dev))
return None
self.logger.error("Device {} is not a passthrough device ".format(host_pci_dev))
return None
- deviceId = hex(host_pci_dev.deviceId % 2**16).lstrip('0x')
+ deviceId = hex(host_pci_dev.deviceId % 2 ** 16).lstrip('0x')
backing = vim.VirtualPCIPassthroughDeviceBackingInfo(deviceId=deviceId,
backing = vim.VirtualPCIPassthroughDeviceBackingInfo(deviceId=deviceId,
- id=host_pci_dev.id,
- systemId=systemid_by_pciid[host_pci_dev.id],
- vendorId=host_pci_dev.vendorId,
- deviceName=host_pci_dev.deviceName)
+ id=host_pci_dev.id,
+ systemId=systemid_by_pciid[host_pci_dev.id],
+ vendorId=host_pci_dev.vendorId,
+ deviceName=host_pci_dev.deviceName)
hba_object = vim.VirtualPCIPassthrough(key=-100, backing=backing)
hba_object = vim.VirtualPCIPassthrough(key=-100, backing=backing)
task = vm_object.ReconfigVM_Task(spec=vmConfigSpec)
self.logger.info("Adding PCI device {} into VM {} from host {} ".format(
task = vm_object.ReconfigVM_Task(spec=vmConfigSpec)
self.logger.info("Adding PCI device {} into VM {} from host {} ".format(
- host_pci_dev, vm_object, host_object)
- )
+ host_pci_dev, vm_object, host_object)
+ )
except Exception as exp:
self.logger.error("Error occurred while adding pci devive {} to VM {}: {}".format(
except Exception as exp:
self.logger.error("Error occurred while adding pci devive {} to VM {}: {}".format(
- host_pci_dev,
- vm_object,
- exp))
+ host_pci_dev,
+ vm_object,
+ exp))
return task
def get_vm_vcenter_info(self):
return task
def get_vm_vcenter_info(self):
if self.vcenter_ip is not None:
vm_vcenter_info["vm_vcenter_ip"] = self.vcenter_ip
else:
if self.vcenter_ip is not None:
vm_vcenter_info["vm_vcenter_ip"] = self.vcenter_ip
else:
- raise vimconn.vimconnException(message="vCenter IP is not provided."\
- " Please provide vCenter IP while attaching datacenter to tenant in --config")
+ raise vimconn.vimconnException(message="vCenter IP is not provided."
+ " Please provide vCenter IP while attaching datacenter "
+ "to tenant in --config")
if self.vcenter_port is not None:
vm_vcenter_info["vm_vcenter_port"] = self.vcenter_port
else:
if self.vcenter_port is not None:
vm_vcenter_info["vm_vcenter_port"] = self.vcenter_port
else:
- raise vimconn.vimconnException(message="vCenter port is not provided."\
- " Please provide vCenter port while attaching datacenter to tenant in --config")
+ raise vimconn.vimconnException(message="vCenter port is not provided."
+ " Please provide vCenter port while attaching datacenter "
+ "to tenant in --config")
if self.vcenter_user is not None:
vm_vcenter_info["vm_vcenter_user"] = self.vcenter_user
else:
if self.vcenter_user is not None:
vm_vcenter_info["vm_vcenter_user"] = self.vcenter_user
else:
- raise vimconn.vimconnException(message="vCenter user is not provided."\
- " Please provide vCenter user while attaching datacenter to tenant in --config")
+ raise vimconn.vimconnException(message="vCenter user is not provided."
+ " Please provide vCenter user while attaching datacenter "
+ "to tenant in --config")
if self.vcenter_password is not None:
vm_vcenter_info["vm_vcenter_password"] = self.vcenter_password
else:
if self.vcenter_password is not None:
vm_vcenter_info["vm_vcenter_password"] = self.vcenter_password
else:
- raise vimconn.vimconnException(message="vCenter user password is not provided."\
- " Please provide vCenter user password while attaching datacenter to tenant in --config")
+ raise vimconn.vimconnException(message="vCenter user password is not provided."
+ " Please provide vCenter user password while attaching datacenter "
+ "to tenant in --config")
def get_vm_pci_details(self, vmuuid):
"""
Method to get VM PCI device details from vCenter
def get_vm_pci_details(self, vmuuid):
"""
Method to get VM PCI device details from vCenter
"""
vm_pci_devices_info = {}
try:
"""
vm_pci_devices_info = {}
try:
- vcenter_conect, content = self.get_vcenter_content()
+ _, content = self.get_vcenter_content()
vm_moref_id = self.get_vm_moref_id(vmuuid)
if vm_moref_id:
vm_moref_id = self.get_vm_moref_id(vmuuid)
if vm_moref_id:
if content:
host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
if host_obj and vm_obj:
if content:
host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
if host_obj and vm_obj:
- vm_pci_devices_info["host_name"]= host_obj.name
- vm_pci_devices_info["host_ip"]= host_obj.config.network.vnic[0].spec.ip.ipAddress
+ vm_pci_devices_info["host_name"] = host_obj.name
+ vm_pci_devices_info["host_ip"] = host_obj.config.network.vnic[0].spec.ip.ipAddress
for device in vm_obj.config.hardware.device:
if type(device) == vim.vm.device.VirtualPCIPassthrough:
for device in vm_obj.config.hardware.device:
if type(device) == vim.vm.device.VirtualPCIPassthrough:
- device_details={'devide_id':device.backing.id,
- 'pciSlotNumber':device.slotInfo.pciSlotNumber,
- }
+ device_details = {'devide_id': device.backing.id,
+ 'pciSlotNumber': device.slotInfo.pciSlotNumber,
+ }
vm_pci_devices_info[device.deviceInfo.label] = device_details
else:
vm_pci_devices_info[device.deviceInfo.label] = device_details
else:
- self.logger.error("Can not connect to vCenter while getting "\
- "PCI devices infromationn")
+ self.logger.error("Can not connect to vCenter while getting "
+ "PCI devices infromationn")
return vm_pci_devices_info
except Exception as exp:
return vm_pci_devices_info
except Exception as exp:
- self.logger.error("Error occurred while getting VM infromationn"\
- " for VM : {}".format(exp))
+ self.logger.error("Error occurred while getting VM information"
+ " for VM : {}".format(exp))
raise vimconn.vimconnException(message=exp)
raise vimconn.vimconnException(message=exp)
def reserve_memory_for_all_vms(self, vapp, memory_mb):
"""
Method to reserve memory for all VMs
def reserve_memory_for_all_vms(self, vapp, memory_mb):
"""
Method to reserve memory for all VMs
url_rest_call = "{}/api/vApp/vm-{}/virtualHardwareSection/memory".format(self.url, vm_id)
url_rest_call = "{}/api/vApp/vm-{}/virtualHardwareSection/memory".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
headers['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItem+xml'
response = self.perform_request(req_type='GET',
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
headers['Content-Type'] = 'application/vnd.vmware.vcloud.rasdItem+xml'
response = self.perform_request(req_type='GET',
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("reserve_memory_for_all_vms : Failed to get "\
+ raise vimconn.vimconnException("reserve_memory_for_all_vms : Failed to get "
"memory")
bytexml = bytes(bytearray(response.text, encoding='utf-8'))
contentelem = lxmlElementTree.XML(bytexml)
"memory")
bytexml = bytes(bytearray(response.text, encoding='utf-8'))
contentelem = lxmlElementTree.XML(bytexml)
- namespaces = {prefix:uri for prefix,uri in contentelem.nsmap.items() if prefix}
- namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
+ namespaces = {prefix: uri for prefix, uri in contentelem.nsmap.items() if prefix}
+ namespaces["xmlns"] = "http://www.vmware.com/vcloud/v1.5"
# Find the reservation element in the response
memelem_list = contentelem.findall(".//rasd:Reservation", namespaces)
# Find the reservation element in the response
memelem_list = contentelem.findall(".//rasd:Reservation", namespaces)
response = self.retry_rest('PUT', url_rest_call, add_headers, newdata)
if response.status_code != 202:
response = self.retry_rest('PUT', url_rest_call, add_headers, newdata)
if response.status_code != 202:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {} ".format(url_rest_call,
"status code : {} ".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("reserve_memory_for_all_vms : Failed to update "\
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("reserve_memory_for_all_vms : Failed to update "
"virtual hardware memory section")
else:
mem_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=mem_task)
if result.get('status') == 'success':
"virtual hardware memory section")
else:
mem_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=mem_task)
if result.get('status') == 'success':
- self.logger.info("reserve_memory_for_all_vms(): VM {} succeeded "\
- .format(vm_id))
+ self.logger.info("reserve_memory_for_all_vms(): VM {} succeeded "
+ .format(vm_id))
- self.logger.error("reserve_memory_for_all_vms(): VM {} failed "\
+ self.logger.error("reserve_memory_for_all_vms(): VM {} failed "
.format(vm_id))
def connect_vapp_to_org_vdc_network(self, vapp_id, net_name):
.format(vm_id))
def connect_vapp_to_org_vdc_network(self, vapp_id, net_name):
url_rest_call = "{}/api/vApp/vapp-{}/networkConfigSection/".format(self.url, vapp_id)
url_rest_call = "{}/api/vApp/vapp-{}/networkConfigSection/".format(self.url, vapp_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=url_rest_call,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=url_rest_call,
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to get "\
+ raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to get "
"network config section")
data = response.text
headers['Content-Type'] = 'application/vnd.vmware.vcloud.networkConfigSection+xml'
net_id = self.get_network_id_by_name(net_name)
if not net_id:
"network config section")
data = response.text
headers['Content-Type'] = 'application/vnd.vmware.vcloud.networkConfigSection+xml'
net_id = self.get_network_id_by_name(net_name)
if not net_id:
- raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to find "\
+ raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to find "
"existing network")
bytexml = bytes(bytearray(data, encoding='utf-8'))
"existing network")
bytexml = bytes(bytearray(data, encoding='utf-8'))
response = self.retry_rest('PUT', url_rest_call, add_headers, newdata)
if response.status_code != 202:
response = self.retry_rest('PUT', url_rest_call, add_headers, newdata)
if response.status_code != 202:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {} ".format(url_rest_call,
"status code : {} ".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to update "\
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("connect_vapp_to_org_vdc_network : Failed to update "
"network config section")
else:
vapp_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=vapp_task)
if result.get('status') == 'success':
"network config section")
else:
vapp_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=vapp_task)
if result.get('status') == 'success':
- self.logger.info("connect_vapp_to_org_vdc_network(): Vapp {} connected to "\
+ self.logger.info("connect_vapp_to_org_vdc_network(): Vapp {} connected to "
"network {}".format(vapp_id, net_name))
else:
"network {}".format(vapp_id, net_name))
else:
- self.logger.error("connect_vapp_to_org_vdc_network(): Vapp {} failed to "\
+ self.logger.error("connect_vapp_to_org_vdc_network(): Vapp {} failed to "
"connect to network {}".format(vapp_id, net_name))
def remove_primary_network_adapter_from_all_vms(self, vapp):
"connect to network {}".format(vapp_id, net_name))
def remove_primary_network_adapter_from_all_vms(self, vapp):
url_rest_call = "{}/api/vApp/vm-{}/networkConnectionSection/".format(self.url, vm_id)
url_rest_call = "{}/api/vApp/vm-{}/networkConnectionSection/".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=url_rest_call,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=url_rest_call,
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
"status code : {}".format(url_rest_call,
response.text,
response.status_code))
- raise vimconn.vimconnException("remove_primary_network_adapter : Failed to get "\
+ raise vimconn.vimconnException("remove_primary_network_adapter : Failed to get "
"network connection section")
data = response.text
"network connection section")
data = response.text
xmlns:ovfenv="http://schemas.dmtf.org/ovf/environment/1"
xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5"
xmlns:ns9="http://www.vmware.com/vcloud/versions"
xmlns:ovfenv="http://schemas.dmtf.org/ovf/environment/1"
xmlns:vmext="http://www.vmware.com/vcloud/extension/v1.5"
xmlns:ns9="http://www.vmware.com/vcloud/versions"
- href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml" ovf:required="false">
+ href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml"
+ ovf:required="false">
<ovf:Info>Specifies the available VM network connections</ovf:Info>
<PrimaryNetworkConnectionIndex>0</PrimaryNetworkConnectionIndex>
<ovf:Info>Specifies the available VM network connections</ovf:Info>
<PrimaryNetworkConnectionIndex>0</PrimaryNetworkConnectionIndex>
- <Link rel="edit" href="{url}" type="application/vnd.vmware.vcloud.networkConnectionSection+xml"/>
+ <Link rel="edit" href="{url}"
+ type="application/vnd.vmware.vcloud.networkConnectionSection+xml"/>
</NetworkConnectionSection>""".format(url=url_rest_call)
response = self.perform_request(req_type='PUT',
url=url_rest_call,
</NetworkConnectionSection>""".format(url=url_rest_call)
response = self.perform_request(req_type='PUT',
url=url_rest_call,
response = self.retry_rest('PUT', url_rest_call, add_headers, newdata)
if response.status_code != 202:
response = self.retry_rest('PUT', url_rest_call, add_headers, newdata)
if response.status_code != 202:
- self.logger.error("REST call {} failed reason : {}"\
+ self.logger.error("REST call {} failed reason : {}"
"status code : {} ".format(url_rest_call,
"status code : {} ".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("remove_primary_network_adapter : Failed to update "\
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("remove_primary_network_adapter : Failed to update "
"network connection section")
else:
nic_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=nic_task)
if result.get('status') == 'success':
"network connection section")
else:
nic_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=nic_task)
if result.get('status') == 'success':
- self.logger.info("remove_primary_network_adapter(): VM {} conneced to "\
- "default NIC type".format(vm_id))
+ self.logger.info("remove_primary_network_adapter(): VM {} conneced to "
+ "default NIC type".format(vm_id))
- self.logger.error("remove_primary_network_adapter(): VM {} failed to "\
+ self.logger.error("remove_primary_network_adapter(): VM {} failed to "
"connect NIC type".format(vm_id))
def add_network_adapter_to_vms(self, vapp, network_name, primary_nic_index, nicIndex, net, nic_type=None):
"connect NIC type".format(vm_id))
def add_network_adapter_to_vms(self, vapp, network_name, primary_nic_index, nicIndex, net, nic_type=None):
- self.logger.info("Add network adapter to VM: network_name {} nicIndex {} nic_type {}".\
+ self.logger.info("Add network adapter to VM: network_name {} nicIndex {} nic_type {}".
format(network_name, nicIndex, nic_type))
try:
ip_address = None
floating_ip = False
mac_address = None
format(network_name, nicIndex, nic_type))
try:
ip_address = None
floating_ip = False
mac_address = None
- if 'floating_ip' in net: floating_ip = net['floating_ip']
+ if 'floating_ip' in net:
+ floating_ip = net['floating_ip']
# Stub for ip_address feature
# Stub for ip_address feature
- if 'ip_address' in net: ip_address = net['ip_address']
+ if 'ip_address' in net:
+ ip_address = net['ip_address']
- if 'mac_address' in net: mac_address = net['mac_address']
+ if 'mac_address' in net:
+ mac_address = net['mac_address']
if floating_ip:
allocation_mode = "POOL"
if floating_ip:
allocation_mode = "POOL"
url_rest_call = "{}/api/vApp/vm-{}/networkConnectionSection/".format(self.url, vm_id)
url_rest_call = "{}/api/vApp/vm-{}/networkConnectionSection/".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=url_rest_call,
headers=headers)
response = self.perform_request(req_type='GET',
url=url_rest_call,
headers=headers)
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {}".format(url_rest_call,
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {}".format(url_rest_call,
- response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to get "\
- "network connection section")
+ response.status_code))
+ raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to get "
+ "network connection section")
data = response.text
data = data.split('<Link rel="edit"')[0]
data = response.text
data = data.split('<Link rel="edit"')[0]
<IsConnected>true</IsConnected>
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
</NetworkConnection>""".format(primary_nic_index, network_name, nicIndex,
<IsConnected>true</IsConnected>
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
</NetworkConnection>""".format(primary_nic_index, network_name, nicIndex,
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
- item = item.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
+ item = item.replace('</NetworkConnectionIndex>\n',
+ '</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
- item = item.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag))
+ item = item.replace('</IsConnected>\n', '</IsConnected>\n{}\n'.format(mac_tag))
- data = data.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item))
+ data = data.replace('</ovf:Info>\n',
+ '</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item))
else:
self.logger.debug("add_network_adapter PrimaryNIC in data")
new_item = """<NetworkConnection network="{}">
else:
self.logger.debug("add_network_adapter PrimaryNIC in data")
new_item = """<NetworkConnection network="{}">
<IsConnected>true</IsConnected>
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
</NetworkConnection>""".format(network_name, nicIndex,
<IsConnected>true</IsConnected>
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
</NetworkConnection>""".format(network_name, nicIndex,
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
- new_item = new_item.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
+ new_item = new_item.replace('</NetworkConnectionIndex>\n',
+ '</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
- new_item = new_item.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag))
+ new_item = new_item.replace('</IsConnected>\n', '</IsConnected>\n{}\n'.format(mac_tag))
data = data + new_item + '</NetworkConnectionSection>'
data = data + new_item + '</NetworkConnectionSection>'
response = self.retry_rest('PUT', url_rest_call, add_headers, data)
if response.status_code != 202:
response = self.retry_rest('PUT', url_rest_call, add_headers, data)
if response.status_code != 202:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {} ".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to update "\
- "network connection section")
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {} ".format(url_rest_call,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to update "
+ "network connection section")
else:
nic_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=nic_task)
if result.get('status') == 'success':
else:
nic_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=nic_task)
if result.get('status') == 'success':
- self.logger.info("add_network_adapter_to_vms(): VM {} conneced to "\
- "default NIC type".format(vm_id))
+ self.logger.info("add_network_adapter_to_vms(): VM {} conneced to "
+ "default NIC type".format(vm_id))
- self.logger.error("add_network_adapter_to_vms(): VM {} failed to "\
- "connect NIC type".format(vm_id))
+ self.logger.error("add_network_adapter_to_vms(): VM {} failed to "
+ "connect NIC type".format(vm_id))
else:
for vms in vapp.get_all_vms():
vm_id = vms.get('id').split(':')[-1]
url_rest_call = "{}/api/vApp/vm-{}/networkConnectionSection/".format(self.url, vm_id)
else:
for vms in vapp.get_all_vms():
vm_id = vms.get('id').split(':')[-1]
url_rest_call = "{}/api/vApp/vm-{}/networkConnectionSection/".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=url_rest_call,
headers=headers)
response = self.perform_request(req_type='GET',
url=url_rest_call,
headers=headers)
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
response = self.retry_rest('GET', url_rest_call)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {}".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to get "\
- "network connection section")
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {}".format(url_rest_call,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to get "
+ "network connection section")
data = response.text
data = data.split('<Link rel="edit"')[0]
vcd_netadapter_type = nic_type
data = response.text
data = data.split('<Link rel="edit"')[0]
vcd_netadapter_type = nic_type
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
<NetworkAdapterType>{}</NetworkAdapterType>
</NetworkConnection>""".format(primary_nic_index, network_name, nicIndex,
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
<NetworkAdapterType>{}</NetworkAdapterType>
</NetworkConnection>""".format(primary_nic_index, network_name, nicIndex,
- allocation_mode, vcd_netadapter_type)
+ allocation_mode, vcd_netadapter_type)
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
- item = item.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
+ item = item.replace('</NetworkConnectionIndex>\n',
+ '</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
- item = item.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag))
+ item = item.replace('</IsConnected>\n', '</IsConnected>\n{}\n'.format(mac_tag))
- data = data.replace('</ovf:Info>\n','</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item))
+ data = data.replace('</ovf:Info>\n',
+ '</ovf:Info>\n{}\n</NetworkConnectionSection>'.format(item))
else:
self.logger.debug("add_network_adapter PrimaryNIC in data nic_type {}".format(nic_type))
new_item = """<NetworkConnection network="{}">
else:
self.logger.debug("add_network_adapter PrimaryNIC in data nic_type {}".format(nic_type))
new_item = """<NetworkConnection network="{}">
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
<NetworkAdapterType>{}</NetworkAdapterType>
</NetworkConnection>""".format(network_name, nicIndex,
<IpAddressAllocationMode>{}</IpAddressAllocationMode>
<NetworkAdapterType>{}</NetworkAdapterType>
</NetworkConnection>""".format(network_name, nicIndex,
- allocation_mode, vcd_netadapter_type)
+ allocation_mode, vcd_netadapter_type)
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
# Stub for ip_address feature
if ip_address:
ip_tag = '<IpAddress>{}</IpAddress>'.format(ip_address)
- new_item = new_item.replace('</NetworkConnectionIndex>\n','</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
+ new_item = new_item.replace('</NetworkConnectionIndex>\n',
+ '</NetworkConnectionIndex>\n{}\n'.format(ip_tag))
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
if mac_address:
mac_tag = '<MACAddress>{}</MACAddress>'.format(mac_address)
- new_item = new_item.replace('</IsConnected>\n','</IsConnected>\n{}\n'.format(mac_tag))
+ new_item = new_item.replace('</IsConnected>\n', '</IsConnected>\n{}\n'.format(mac_tag))
data = data + new_item + '</NetworkConnectionSection>'
data = data + new_item + '</NetworkConnectionSection>'
response = self.retry_rest('PUT', url_rest_call, add_headers, data)
if response.status_code != 202:
response = self.retry_rest('PUT', url_rest_call, add_headers, data)
if response.status_code != 202:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {}".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to update "\
- "network connection section")
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {}".format(url_rest_call,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("add_network_adapter_to_vms : Failed to update "
+ "network connection section")
else:
nic_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=nic_task)
if result.get('status') == 'success':
else:
nic_task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=nic_task)
if result.get('status') == 'success':
- self.logger.info("add_network_adapter_to_vms(): VM {} "\
- "conneced to NIC type {}".format(vm_id, nic_type))
+ self.logger.info("add_network_adapter_to_vms(): VM {} "
+ "conneced to NIC type {}".format(vm_id, nic_type))
- self.logger.error("add_network_adapter_to_vms(): VM {} "\
- "failed to connect NIC type {}".format(vm_id, nic_type))
+ self.logger.error("add_network_adapter_to_vms(): VM {} "
+ "failed to connect NIC type {}".format(vm_id, nic_type))
- self.logger.error("add_network_adapter_to_vms() : exception occurred "\
- "while adding Network adapter")
+ self.logger.error("add_network_adapter_to_vms() : exception occurred "
+ "while adding Network adapter")
raise vimconn.vimconnException(message=exp)
raise vimconn.vimconnException(message=exp)
def set_numa_affinity(self, vmuuid, paired_threads_id):
"""
Method to assign numa affinity in vm configuration parammeters
def set_numa_affinity(self, vmuuid, paired_threads_id):
"""
Method to assign numa affinity in vm configuration parammeters
vcenter_conect, content = self.get_vcenter_content()
vm_moref_id = self.get_vm_moref_id(vmuuid)
vcenter_conect, content = self.get_vcenter_content()
vm_moref_id = self.get_vm_moref_id(vmuuid)
- host_obj, vm_obj = self.get_vm_obj(content ,vm_moref_id)
+ _, vm_obj = self.get_vm_obj(content, vm_moref_id)
if vm_obj:
config_spec = vim.vm.ConfigSpec()
config_spec.extraConfig = []
if vm_obj:
config_spec = vim.vm.ConfigSpec()
config_spec.extraConfig = []
config_spec.extraConfig.append(opt)
task = vm_obj.ReconfigVM_Task(config_spec)
if task:
config_spec.extraConfig.append(opt)
task = vm_obj.ReconfigVM_Task(config_spec)
if task:
- result = self.wait_for_vcenter_task(task, vcenter_conect)
+ self.wait_for_vcenter_task(task, vcenter_conect)
extra_config = vm_obj.config.extraConfig
flag = False
for opts in extra_config:
if 'numa.nodeAffinity' in opts.key:
flag = True
extra_config = vm_obj.config.extraConfig
flag = False
for opts in extra_config:
if 'numa.nodeAffinity' in opts.key:
flag = True
- self.logger.info("set_numa_affinity: Sucessfully assign numa affinity "\
- "value {} for vm {}".format(opt.value, vm_obj))
+ self.logger.info("set_numa_affinity: Sucessfully assign numa affinity "
+ "value {} for vm {}".format(opt.value, vm_obj))
if flag:
return
else:
self.logger.error("set_numa_affinity: Failed to assign numa affinity")
except Exception as exp:
if flag:
return
else:
self.logger.error("set_numa_affinity: Failed to assign numa affinity")
except Exception as exp:
- self.logger.error("set_numa_affinity : exception occurred while setting numa affinity "\
- "for VM {} : {}".format(vm_obj, vm_moref_id))
- raise vimconn.vimconnException("set_numa_affinity : Error {} failed to assign numa "\
- "affinity".format(exp))
-
+ self.logger.error("set_numa_affinity : exception occurred while setting numa affinity "
+ "for VM {} : {}".format(vm_obj, vm_moref_id))
+ raise vimconn.vimconnException("set_numa_affinity : Error {} failed to assign numa "
+ "affinity".format(exp))
def cloud_init(self, vapp, cloud_config):
"""
def cloud_init(self, vapp, cloud_config):
"""
self.logger.debug("cloud_init : Guest os customization started..")
customize_script = self.format_script(key_pairs=key_pairs, users_list=userdata)
self.logger.debug("cloud_init : Guest os customization started..")
customize_script = self.format_script(key_pairs=key_pairs, users_list=userdata)
- customize_script = customize_script.replace("&","&")
+ customize_script = customize_script.replace("&", "&")
self.guest_customization(vapp, customize_script)
except Exception as exp:
self.guest_customization(vapp, customize_script)
except Exception as exp:
- self.logger.error("cloud_init : exception occurred while injecting "\
- "ssh-key")
- raise vimconn.vimconnException("cloud_init : Error {} failed to inject "\
- "ssh-key".format(exp))
+ self.logger.error("cloud_init : exception occurred while injecting "
+ "ssh-key")
+ raise vimconn.vimconnException("cloud_init : Error {} failed to inject "
+ "ssh-key".format(exp))
def format_script(self, key_pairs=[], users_list=[]):
bash_script = """#!/bin/sh
def format_script(self, key_pairs=[], users_list=[]):
bash_script = """#!/bin/sh
- echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
- if [ "$1" = "precustomization" ];then
- echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
- """
+echo performing customization tasks with param $1 at `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"`>> /root/customization.log
+if [ "$1" = "precustomization" ];then
+ echo performing precustomization tasks on `date "+DATE: %Y-%m-%d - TIME: %H:%M:%S"` >> /root/customization.log
+"""
keys = "\n".join(key_pairs)
if keys:
keys = "\n".join(key_pairs)
if keys:
echo '{key}' >> /root/.ssh/authorized_keys
""".format(key=keys)
echo '{key}' >> /root/.ssh/authorized_keys
""".format(key=keys)
- bash_script+= keys_data
+ bash_script += keys_data
- if 'name' in user: user_name = user['name']
+ if 'name' in user:
+ user_name = user['name']
if 'key-pairs' in user:
user_keys = "\n".join(user['key-pairs'])
else:
if 'key-pairs' in user:
user_keys = "\n".join(user['key-pairs'])
else:
useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
""".format(user_name=user_name)
useradd -d /home/{user_name} -m -g users -s /bin/bash {user_name}
""".format(user_name=user_name)
- bash_script+= add_user_name
+ bash_script += add_user_name
if user_keys:
user_keys_data = """
if user_keys:
user_keys_data = """
# make centos with selinux happy
which restorecon && restorecon -Rv /home/{user_name}/.ssh
echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
# make centos with selinux happy
which restorecon && restorecon -Rv /home/{user_name}/.ssh
echo '{user_key}' >> /home/{user_name}/.ssh/authorized_keys
- """.format(user_name=user_name,user_key=user_keys)
+ """.format(user_name=user_name, user_key=user_keys)
- bash_script+= user_keys_data
+ bash_script += user_keys_data
- return bash_script+"\n\tfi"
+ return bash_script + "\n\tfi"
def guest_customization(self, vapp, customize_script):
"""
def guest_customization(self, vapp, customize_script):
"""
for vm in vapp.get_all_vms():
vm_id = vm.get('id').split(':')[-1]
vm_name = vm.get('name')
for vm in vapp.get_all_vms():
vm_id = vm.get('id').split(':')[-1]
vm_name = vm.get('name')
- vm_name = vm_name.replace('_','-')
+ vm_name = vm_name.replace('_', '-')
vm_customization_url = "{}/api/vApp/vm-{}/guestCustomizationSection/".format(self.url, vm_id)
vm_customization_url = "{}/api/vApp/vm-{}/guestCustomizationSection/".format(self.url, vm_id)
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
headers['Content-Type'] = "application/vnd.vmware.vcloud.guestCustomizationSection+xml"
data = """<GuestCustomizationSection
xmlns="http://www.vmware.com/vcloud/v1.5"
xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
headers['Content-Type'] = "application/vnd.vmware.vcloud.guestCustomizationSection+xml"
data = """<GuestCustomizationSection
xmlns="http://www.vmware.com/vcloud/v1.5"
xmlns:ovf="http://schemas.dmtf.org/ovf/envelope/1"
- ovf:required="false" href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
+ ovf:required="false" href="{}"
+ type="application/vnd.vmware.vcloud.guestCustomizationSection+xml">
<ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
<Enabled>true</Enabled>
<ChangeSid>false</ChangeSid>
<ovf:Info>Specifies Guest OS Customization Settings</ovf:Info>
<Enabled>true</Enabled>
<ChangeSid>false</ChangeSid>
<ResetPasswordRequired>false</ResetPasswordRequired>
<CustomizationScript>{}</CustomizationScript>
<ComputerName>{}</ComputerName>
<ResetPasswordRequired>false</ResetPasswordRequired>
<CustomizationScript>{}</CustomizationScript>
<ComputerName>{}</ComputerName>
- <Link href="{}" type="application/vnd.vmware.vcloud.guestCustomizationSection+xml" rel="edit"/>
+ <Link href="{}"
+ type="application/vnd.vmware.vcloud.guestCustomizationSection+xml" rel="edit"/>
</GuestCustomizationSection>
""".format(vm_customization_url,
</GuestCustomizationSection>
""".format(vm_customization_url,
- vm_id,
- customize_script,
- vm_name,
+ vm_id,
+ customize_script,
+ vm_name,
vm_customization_url)
response = self.perform_request(req_type='PUT',
vm_customization_url)
response = self.perform_request(req_type='PUT',
- url=vm_customization_url,
- headers=headers,
- data=data)
+ url=vm_customization_url,
+ headers=headers,
+ data=data)
if response.status_code == 202:
guest_task = self.get_task_from_response(response.text)
self.client.get_task_monitor().wait_for_success(task=guest_task)
if response.status_code == 202:
guest_task = self.get_task_from_response(response.text)
self.client.get_task_monitor().wait_for_success(task=guest_task)
- self.logger.info("guest_customization : customized guest os task "\
- "completed for VM {}".format(vm_name))
+ self.logger.info("guest_customization : customized guest os task "
+ "completed for VM {}".format(vm_name))
- self.logger.error("guest_customization : task for customized guest os"\
- "failed for VM {}".format(vm_name))
- raise vimconn.vimconnException("guest_customization : failed to perform"\
- "guest os customization on VM {}".format(vm_name))
+ self.logger.error("guest_customization : task for customized guest os"
+ "failed for VM {}".format(vm_name))
+ raise vimconn.vimconnException("guest_customization : failed to perform"
+ "guest os customization on VM {}".format(vm_name))
def add_new_disk(self, vapp_uuid, disk_size):
"""
def add_new_disk(self, vapp_uuid, disk_size):
"""
status = False
vm_details = None
try:
status = False
vm_details = None
try:
- #Disk size in GB, convert it into MB
+ # Disk size in GB, convert it into MB
if disk_size is not None:
disk_size_mb = int(disk_size) * 1024
vm_details = self.get_vapp_details_rest(vapp_uuid)
if disk_size is not None:
disk_size_mb = int(disk_size) * 1024
vm_details = self.get_vapp_details_rest(vapp_uuid)
if status:
self.logger.info("Added new disk to VM: {} disk size:{}GB".format(vm_details["name"], disk_size))
else:
if status:
self.logger.info("Added new disk to VM: {} disk size:{}GB".format(vm_details["name"], disk_size))
else:
- #If failed to add disk, delete VM
+ # If failed to add disk, delete VM
msg = "add_new_disk: Failed to add new disk to {}".format(vm_details["name"])
self.rollback_newvm(vapp_uuid, msg)
msg = "add_new_disk: Failed to add new disk to {}".format(vm_details["name"])
self.rollback_newvm(vapp_uuid, msg)
def add_new_disk_rest(self, disk_href, disk_size_mb):
"""
Retrives vApp Disks section & add new empty disk
def add_new_disk_rest(self, disk_href, disk_size_mb):
"""
Retrives vApp Disks section & add new empty disk
"""
status = False
if self.client._session:
"""
status = False
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=disk_href,
headers=headers)
response = self.perform_request(req_type='GET',
url=disk_href,
headers=headers)
.format(disk_href, response.status_code))
return status
try:
.format(disk_href, response.status_code))
return status
try:
- #Find but type & max of instance IDs assigned to disks
+ # Find but type & max of instance IDs assigned to disks
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
lxmlroot_respond = lxmlElementTree.fromstring(response.content)
namespaces = {prefix: uri for prefix, uri in lxmlroot_respond.nsmap.items() if prefix}
- namespaces["xmlns"]= "http://www.vmware.com/vcloud/v1.5"
+ namespaces["xmlns"] = "http://www.vmware.com/vcloud/v1.5"
- for item in lxmlroot_respond.iterfind('xmlns:Item',namespaces):
- if item.find("rasd:Description",namespaces).text == "Hard disk":
- inst_id = int(item.find("rasd:InstanceID" ,namespaces).text)
+ for item in lxmlroot_respond.iterfind('xmlns:Item', namespaces):
+ if item.find("rasd:Description", namespaces).text == "Hard disk":
+ inst_id = int(item.find("rasd:InstanceID", namespaces).text)
if inst_id > instance_id:
instance_id = inst_id
if inst_id > instance_id:
instance_id = inst_id
- disk_item = item.find("rasd:HostResource" ,namespaces)
- bus_subtype = disk_item.attrib["{"+namespaces['xmlns']+"}busSubType"]
- bus_type = disk_item.attrib["{"+namespaces['xmlns']+"}busType"]
+ disk_item = item.find("rasd:HostResource", namespaces)
+ bus_subtype = disk_item.attrib["{" + namespaces['xmlns'] + "}busSubType"]
+ bus_type = disk_item.attrib["{" + namespaces['xmlns'] + "}busType"]
instance_id = instance_id + 1
instance_id = instance_id + 1
<rasd:Description>Hard disk</rasd:Description>
<rasd:ElementName>New disk</rasd:ElementName>
<rasd:HostResource
<rasd:Description>Hard disk</rasd:Description>
<rasd:ElementName>New disk</rasd:ElementName>
<rasd:HostResource
</Item>""".format(disk_size_mb, bus_subtype, bus_type, instance_id)
new_data = response.text
</Item>""".format(disk_size_mb, bus_subtype, bus_type, instance_id)
new_data = response.text
- #Add new item at the bottom
+ # Add new item at the bottom
new_data = new_data.replace('</Item>\n</RasdItemsList>', '</Item>\n{}\n</RasdItemsList>'.format(new_item))
# Send PUT request to modify virtual hardware section with new disk
new_data = new_data.replace('</Item>\n</RasdItemsList>', '</Item>\n{}\n</RasdItemsList>'.format(new_item))
# Send PUT request to modify virtual hardware section with new disk
def add_existing_disk(self, catalogs=None, image_id=None, size=None, template_name=None, vapp_uuid=None):
"""
Method to add existing disk to vm
def add_existing_disk(self, catalogs=None, image_id=None, size=None, template_name=None, vapp_uuid=None):
"""
Method to add existing disk to vm
"""
disk_info = None
vcenter_conect, content = self.get_vcenter_content()
"""
disk_info = None
vcenter_conect, content = self.get_vcenter_content()
- #find moref-id of vm in image
+ # find moref-id of vm in image
catalog_vm_info = self.get_vapp_template_details(catalogs=catalogs,
image_id=image_id,
catalog_vm_info = self.get_vapp_template_details(catalogs=catalogs,
image_id=image_id,
if catalog_vm_info and "vm_vcenter_info" in catalog_vm_info:
if "vm_moref_id" in catalog_vm_info["vm_vcenter_info"]:
catalog_vm_moref_id = catalog_vm_info["vm_vcenter_info"].get("vm_moref_id", None)
if catalog_vm_moref_id:
self.logger.info("Moref_id of VM in catalog : {}" .format(catalog_vm_moref_id))
if catalog_vm_info and "vm_vcenter_info" in catalog_vm_info:
if "vm_moref_id" in catalog_vm_info["vm_vcenter_info"]:
catalog_vm_moref_id = catalog_vm_info["vm_vcenter_info"].get("vm_moref_id", None)
if catalog_vm_moref_id:
self.logger.info("Moref_id of VM in catalog : {}" .format(catalog_vm_moref_id))
- host, catalog_vm_obj = self.get_vm_obj(content, catalog_vm_moref_id)
+ _, catalog_vm_obj = self.get_vm_obj(content, catalog_vm_moref_id)
disk_info = self.find_disk(catalog_vm_obj)
else:
exp_msg = "No VM with image id {} found".format(image_id)
disk_info = self.find_disk(catalog_vm_obj)
else:
exp_msg = "No VM with image id {} found".format(image_id)
if disk_info:
self.logger.info("Existing disk_info : {}".format(disk_info))
if disk_info:
self.logger.info("Existing disk_info : {}".format(disk_info))
vm_moref_id = self.get_vm_moref_id(vapp_uuid)
vm_moref_id = self.get_vm_moref_id(vapp_uuid)
- host, vm_obj = self.get_vm_obj(content, vm_moref_id)
+ _, vm_obj = self.get_vm_obj(content, vm_moref_id)
if vm_obj:
status = self.add_disk(vcenter_conect=vcenter_conect,
vm=vm_obj,
if vm_obj:
status = self.add_disk(vcenter_conect=vcenter_conect,
vm=vm_obj,
)
else:
msg = "No disk found with image id {} to add in VM {}".format(
)
else:
msg = "No disk found with image id {} to add in VM {}".format(
- image_id,
- vm_obj.config.name)
+ image_id,
+ vm_obj.config.name)
self.rollback_newvm(vapp_uuid, msg, exp_type="NotFound")
self.rollback_newvm(vapp_uuid, msg, exp_type="NotFound")
def find_disk(self, vm_obj):
"""
Method to find details of existing disk in VM
def find_disk(self, vm_obj):
"""
Method to find details of existing disk in VM
devices = vm_obj.config.hardware.device
for device in devices:
if type(device) is vim.vm.device.VirtualDisk:
devices = vm_obj.config.hardware.device
for device in devices:
if type(device) is vim.vm.device.VirtualDisk:
- if isinstance(device.backing,vim.vm.device.VirtualDisk.FlatVer2BackingInfo) and hasattr(device.backing, 'fileName'):
+ if (isinstance(device.backing, vim.vm.device.VirtualDisk.FlatVer2BackingInfo) and
+ hasattr(device.backing, 'fileName')):
disk_info["full_path"] = device.backing.fileName
disk_info["datastore"] = device.backing.datastore
disk_info["capacityKB"] = device.capacityInKB
break
except Exception as exp:
disk_info["full_path"] = device.backing.fileName
disk_info["datastore"] = device.backing.datastore
disk_info["capacityKB"] = device.capacityInKB
break
except Exception as exp:
- self.logger.error("find_disk() : exception occurred while "\
+ self.logger.error("find_disk() : exception occurred while "
"getting existing disk details :{}".format(exp))
return disk_info
"getting existing disk details :{}".format(exp))
return disk_info
def add_disk(self, vcenter_conect=None, vm=None, size=None, vapp_uuid=None, disk_info={}):
"""
Method to add existing disk in VM
def add_disk(self, vcenter_conect=None, vm=None, size=None, vapp_uuid=None, disk_info={}):
"""
Method to add existing disk in VM
fullpath = disk_info["full_path"] if "full_path" in disk_info else None
capacityKB = disk_info["capacityKB"] if "capacityKB" in disk_info else None
if size is not None:
fullpath = disk_info["full_path"] if "full_path" in disk_info else None
capacityKB = disk_info["capacityKB"] if "capacityKB" in disk_info else None
if size is not None:
- #Convert size from GB to KB
+ # Convert size from GB to KB
sizeKB = int(size) * 1024 * 1024
sizeKB = int(size) * 1024 * 1024
- #compare size of existing disk and user given size.Assign whicherver is greater
+ # compare size of existing disk and user given size.Assign whicherver is greater
self.logger.info("Add Existing disk : sizeKB {} , capacityKB {}".format(
self.logger.info("Add Existing disk : sizeKB {} , capacityKB {}".format(
if sizeKB > capacityKB:
capacityKB = sizeKB
if sizeKB > capacityKB:
capacityKB = sizeKB
if unit_number == 7:
unit_number += 1
if isinstance(dev, vim.vm.device.VirtualDisk):
if unit_number == 7:
unit_number += 1
if isinstance(dev, vim.vm.device.VirtualDisk):
- #vim.vm.device.VirtualSCSIController
+ # vim.vm.device.VirtualSCSIController
controller_key = dev.controllerKey
self.logger.info("Add Existing disk : unit number {} , controller key {}".format(
controller_key = dev.controllerKey
self.logger.info("Add Existing disk : unit number {} , controller key {}".format(
- unit_number, controller_key))
+ unit_number, controller_key))
# add disk here
dev_changes = []
disk_spec = vim.vm.device.VirtualDeviceSpec()
# add disk here
dev_changes = []
disk_spec = vim.vm.device.VirtualDeviceSpec()
vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.thinProvisioned = True
disk_spec.device.backing.diskMode = 'persistent'
vim.vm.device.VirtualDisk.FlatVer2BackingInfo()
disk_spec.device.backing.thinProvisioned = True
disk_spec.device.backing.diskMode = 'persistent'
- disk_spec.device.backing.datastore = datastore
- disk_spec.device.backing.fileName = fullpath
+ disk_spec.device.backing.datastore = datastore
+ disk_spec.device.backing.fileName = fullpath
disk_spec.device.unitNumber = unit_number
disk_spec.device.capacityInKB = capacityKB
disk_spec.device.unitNumber = unit_number
disk_spec.device.capacityInKB = capacityKB
msg = "add_disk() : Can not add disk to VM with disk info {} ".format(disk_info)
self.rollback_newvm(vapp_uuid, msg)
msg = "add_disk() : Can not add disk to VM with disk info {} ".format(disk_info)
self.rollback_newvm(vapp_uuid, msg)
def get_vcenter_content(self):
"""
Get the vsphere content object
def get_vcenter_content(self):
"""
Get the vsphere content object
try:
vm_vcenter_info = self.get_vm_vcenter_info()
except Exception as exp:
try:
vm_vcenter_info = self.get_vm_vcenter_info()
except Exception as exp:
- self.logger.error("Error occurred while getting vCenter infromationn"\
- " for VM : {}".format(exp))
+ self.logger.error("Error occurred while getting vCenter infromationn"
+ " for VM : {}".format(exp))
raise vimconn.vimconnException(message=exp)
context = None
raise vimconn.vimconnException(message=exp)
context = None
context = ssl._create_unverified_context()
vcenter_conect = SmartConnect(
context = ssl._create_unverified_context()
vcenter_conect = SmartConnect(
- host=vm_vcenter_info["vm_vcenter_ip"],
- user=vm_vcenter_info["vm_vcenter_user"],
- pwd=vm_vcenter_info["vm_vcenter_password"],
- port=int(vm_vcenter_info["vm_vcenter_port"]),
- sslContext=context
- )
+ host=vm_vcenter_info["vm_vcenter_ip"],
+ user=vm_vcenter_info["vm_vcenter_user"],
+ pwd=vm_vcenter_info["vm_vcenter_password"],
+ port=int(vm_vcenter_info["vm_vcenter_port"]),
+ sslContext=context
+ )
atexit.register(Disconnect, vcenter_conect)
content = vcenter_conect.RetrieveContent()
return vcenter_conect, content
atexit.register(Disconnect, vcenter_conect)
content = vcenter_conect.RetrieveContent()
return vcenter_conect, content
def get_vm_moref_id(self, vapp_uuid):
"""
Get the moref_id of given VM
def get_vm_moref_id(self, vapp_uuid):
"""
Get the moref_id of given VM
return vm_moref_id
except Exception as exp:
return vm_moref_id
except Exception as exp:
- self.logger.error("Error occurred while getting VM moref ID "\
- " for VM : {}".format(exp))
+ self.logger.error("Error occurred while getting VM moref ID "
+ " for VM : {}".format(exp))
-
- def get_vapp_template_details(self, catalogs=None, image_id=None , template_name=None):
+ def get_vapp_template_details(self, catalogs=None, image_id=None, template_name=None):
"""
Method to get vApp template details
Args :
"""
Method to get vApp template details
Args :
raise vimconn.vimconnConnectionException("Failed to connect vCD")
try:
raise vimconn.vimconnConnectionException("Failed to connect vCD")
try:
- org, vdc = self.get_vdc_details()
+ org, _ = self.get_vdc_details()
catalog = self.get_catalog_obj(image_id, catalogs)
if catalog:
items = org.get_catalog_item(catalog.get('name'), catalog.get('name'))
catalog_items = [items.attrib]
if len(catalog_items) == 1:
catalog = self.get_catalog_obj(image_id, catalogs)
if catalog:
items = org.get_catalog_item(catalog.get('name'), catalog.get('name'))
catalog_items = [items.attrib]
if len(catalog_items) == 1:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=catalog_items[0].get('href'),
headers=headers)
catalogItem = XmlElementTree.fromstring(response.text)
response = self.perform_request(req_type='GET',
url=catalog_items[0].get('href'),
headers=headers)
catalogItem = XmlElementTree.fromstring(response.text)
- entity = [child for child in catalogItem if child.get("type") == "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
+ entity = [child for child in catalogItem if child.get("type") ==
+ "application/vnd.vmware.vcloud.vAppTemplate+xml"][0]
vapp_tempalte_href = entity.get("href")
vapp_tempalte_href = entity.get("href")
- #get vapp details and parse moref id
-
- namespaces = {"vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
- 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
- 'vmw': 'http://www.vmware.com/schema/ovf',
- 'vm': 'http://www.vmware.com/vcloud/v1.5',
- 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
- 'vmext':"http://www.vmware.com/vcloud/extension/v1.5",
- 'xmlns':"http://www.vmware.com/vcloud/v1.5"
- }
+ # get vapp details and parse moref id
+
+ namespaces = {
+ "vssd":"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData" ,
+ 'ovf': 'http://schemas.dmtf.org/ovf/envelope/1',
+ 'vmw': 'http://www.vmware.com/schema/ovf',
+ 'vm': 'http://www.vmware.com/vcloud/v1.5',
+ 'rasd':"http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData",
+ 'vmext':"http://www.vmware.com/vcloud/extension/v1.5",
+ 'xmlns':"http://www.vmware.com/vcloud/v1.5"
+ }
if vca._session:
response = self.perform_request(req_type='GET',
if vca._session:
response = self.perform_request(req_type='GET',
- url=vapp_tempalte_href,
- headers=headers)
+ url=vapp_tempalte_href,
+ headers=headers)
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(
- vapp_tempalte_href, response.status_code))
+ vapp_tempalte_href, response.status_code))
else:
xmlroot_respond = XmlElementTree.fromstring(response.text)
else:
xmlroot_respond = XmlElementTree.fromstring(response.text)
vmext = vim_info.find('vmext:VmVimObjectRef', namespaces)
if vmext is not None:
vm_vcenter_info["vm_moref_id"] = vmext.find('vmext:MoRef', namespaces).text
vmext = vim_info.find('vmext:VmVimObjectRef', namespaces)
if vmext is not None:
vm_vcenter_info["vm_moref_id"] = vmext.find('vmext:MoRef', namespaces).text
- parsed_response["vm_vcenter_info"]= vm_vcenter_info
+ parsed_response["vm_vcenter_info"] = vm_vcenter_info
- except Exception as exp :
+ except Exception as exp:
self.logger.info("Error occurred calling rest api for getting vApp details {}".format(exp))
return parsed_response
self.logger.info("Error occurred calling rest api for getting vApp details {}".format(exp))
return parsed_response
-
- def rollback_newvm(self, vapp_uuid, msg , exp_type="Genric"):
+ def rollback_newvm(self, vapp_uuid, msg, exp_type="Genric"):
"""
Method to delete vApp
Args :
"""
Method to delete vApp
Args :
- status = self.delete_vminstance(vapp_uuid)
+ self.delete_vminstance(vapp_uuid)
else:
msg = "No vApp ID"
self.logger.error(msg)
else:
msg = "No vApp ID"
self.logger.error(msg)
try:
no_of_sriov_devices = len(sriov_nets)
if no_of_sriov_devices > 0:
try:
no_of_sriov_devices = len(sriov_nets)
if no_of_sriov_devices > 0:
host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
self.logger.info("VM {} is currently on host {}".format(vm_obj, host_obj))
if host_obj and vm_obj:
host_obj, vm_obj = self.get_vm_obj(content, vm_moref_id)
self.logger.info("VM {} is currently on host {}".format(vm_obj, host_obj))
if host_obj and vm_obj:
- #get SRIOV devies from host on which vapp is currently installed
+ # get SRIOV devies from host on which vapp is currently installed
avilable_sriov_devices = self.get_sriov_devices(host_obj,
avilable_sriov_devices = self.get_sriov_devices(host_obj,
- no_of_sriov_devices,
- )
+ no_of_sriov_devices,
+ )
if len(avilable_sriov_devices) == 0:
if len(avilable_sriov_devices) == 0:
- #find other hosts with active pci devices
- new_host_obj , avilable_sriov_devices = self.get_host_and_sriov_devices(
- content,
- no_of_sriov_devices,
- )
+ # find other hosts with active pci devices
+ new_host_obj, avilable_sriov_devices = self.get_host_and_sriov_devices(
+ content,
+ no_of_sriov_devices,
+ )
- if new_host_obj is not None and len(avilable_sriov_devices)> 0:
- #Migrate vm to the host where SRIOV devices are available
+ if new_host_obj is not None and len(avilable_sriov_devices) > 0:
+ # Migrate vm to the host where SRIOV devices are available
self.logger.info("Relocate VM {} on new host {}".format(vm_obj,
self.logger.info("Relocate VM {} on new host {}".format(vm_obj,
task = self.relocate_vm(new_host_obj, vm_obj)
if task is not None:
result = self.wait_for_vcenter_task(task, vcenter_conect)
task = self.relocate_vm(new_host_obj, vm_obj)
if task is not None:
result = self.wait_for_vcenter_task(task, vcenter_conect)
else:
self.logger.info("Fail to migrate VM : {}".format(result))
raise vimconn.vimconnNotFoundException(
else:
self.logger.info("Fail to migrate VM : {}".format(result))
raise vimconn.vimconnNotFoundException(
- "Fail to migrate VM : {} to host {}".format(
- vmname_andid,
- new_host_obj)
+ "Fail to migrate VM : {} to host {}".format(
+ vmname_andid,
+ new_host_obj)
- if host_obj is not None and avilable_sriov_devices is not None and len(avilable_sriov_devices)> 0:
- #Add SRIOV devices one by one
+ if (host_obj is not None and
+ avilable_sriov_devices is not None and
+ len(avilable_sriov_devices) > 0):
+ # Add SRIOV devices one by one
for sriov_net in sriov_nets:
network_name = sriov_net.get('net_id')
for sriov_net in sriov_nets:
network_name = sriov_net.get('net_id')
- dvs_portgr_name = self.create_dvPort_group(network_name)
+ self.create_dvPort_group(network_name)
if sriov_net.get('type') == "VF" or sriov_net.get('type') == "SR-IOV":
if sriov_net.get('type') == "VF" or sriov_net.get('type') == "SR-IOV":
- #add vlan ID ,Modify portgroup for vlan ID
+ # add vlan ID ,Modify portgroup for vlan ID
self.configure_vlanID(content, vcenter_conect, network_name)
task = self.add_sriov_to_vm(content,
self.configure_vlanID(content, vcenter_conect, network_name)
task = self.add_sriov_to_vm(content,
avilable_sriov_devices[0]
)
if task:
avilable_sriov_devices[0]
)
if task:
- status= self.wait_for_vcenter_task(task, vcenter_conect)
+ status = self.wait_for_vcenter_task(task, vcenter_conect)
if status:
self.logger.info("Added SRIOV {} to VM {}".format(
if status:
self.logger.info("Added SRIOV {} to VM {}".format(
- no_of_sriov_devices,
- str(vm_obj)))
+ no_of_sriov_devices,
+ str(vm_obj)))
else:
self.logger.error("Fail to add SRIOV {} to VM {}".format(
else:
self.logger.error("Fail to add SRIOV {} to VM {}".format(
- no_of_sriov_devices,
- str(vm_obj)))
+ no_of_sriov_devices,
+ str(vm_obj)))
raise vimconn.vimconnUnexpectedResponse(
raise vimconn.vimconnUnexpectedResponse(
- "Fail to add SRIOV adapter in VM ".format(str(vm_obj))
+ "Fail to add SRIOV adapter in VM ".format(str(vm_obj))
)
return True, vm_obj, vcenter_conect
else:
)
return True, vm_obj, vcenter_conect
else:
- self.logger.error("Currently there is no host with"\
- " {} number of avaialble SRIOV "\
+ self.logger.error("Currently there is no host with"
+ " {} number of avaialble SRIOV "
"VFs required for VM {}".format(
"VFs required for VM {}".format(
- no_of_sriov_devices,
- vmname_andid)
+ no_of_sriov_devices,
+ vmname_andid)
)
raise vimconn.vimconnNotFoundException(
)
raise vimconn.vimconnNotFoundException(
- "Currently there is no host with {} "\
- "number of avaialble SRIOV devices required for VM {}".format(
- no_of_sriov_devices,
- vmname_andid))
+ "Currently there is no host with {} "
+ "number of avaialble SRIOV devices required for VM {}".format(
+ no_of_sriov_devices,
+ vmname_andid))
- self.logger.debug("No infromation about SRIOV devices {} ",sriov_nets)
+ self.logger.debug("No infromation about SRIOV devices {} ", sriov_nets)
except vmodl.MethodFault as error:
except vmodl.MethodFault as error:
- self.logger.error("Error occurred while adding SRIOV {} ",error)
+ self.logger.error("Error occurred while adding SRIOV {} ", error)
return None, vm_obj, vcenter_conect
return None, vm_obj, vcenter_conect
-
- def get_sriov_devices(self,host, no_of_vfs):
+ def get_sriov_devices(self, host, no_of_vfs):
"""
Method to get the details of SRIOV devices on given host
Args:
"""
Method to get the details of SRIOV devices on given host
Args:
Returns:
array of SRIOV devices
"""
Returns:
array of SRIOV devices
"""
if host:
for device in host.config.pciPassthruInfo:
if host:
for device in host.config.pciPassthruInfo:
- if isinstance(device,vim.host.SriovInfo) and device.sriovActive:
+ if isinstance(device, vim.host.SriovInfo) and device.sriovActive:
if device.numVirtualFunction >= no_of_vfs:
sriovInfo.append(device)
break
return sriovInfo
if device.numVirtualFunction >= no_of_vfs:
sriovInfo.append(device)
break
return sriovInfo
def get_host_and_sriov_devices(self, content, no_of_vfs):
"""
Method to get the details of SRIOV devices infromation on all hosts
def get_host_and_sriov_devices(self, content, no_of_vfs):
"""
Method to get the details of SRIOV devices infromation on all hosts
try:
if content:
container = content.viewManager.CreateContainerView(content.rootFolder,
try:
if content:
container = content.viewManager.CreateContainerView(content.rootFolder,
- [vim.HostSystem], True)
+ [vim.HostSystem], True)
for host in container.view:
devices = self.get_sriov_devices(host, no_of_vfs)
if devices:
for host in container.view:
devices = self.get_sriov_devices(host, no_of_vfs)
if devices:
except Exception as exp:
self.logger.error("Error {} occurred while finding SRIOV devices on host: {}".format(exp, host_obj))
except Exception as exp:
self.logger.error("Error {} occurred while finding SRIOV devices on host: {}".format(exp, host_obj))
- return host_obj,sriov_device_objs
+ return host_obj, sriov_device_objs
-
- def add_sriov_to_vm(self,content, vm_obj, host_obj, network_name, sriov_device):
+ def add_sriov_to_vm(self, content, vm_obj, host_obj, network_name, sriov_device):
"""
Method to add SRIOV adapter to vm
"""
Method to add SRIOV adapter to vm
nic.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic.device = vim.vm.device.VirtualSriovEthernetCard()
nic.device.addressType = 'assigned'
nic.operation = vim.vm.device.VirtualDeviceSpec.Operation.add
nic.device = vim.vm.device.VirtualSriovEthernetCard()
nic.device.addressType = 'assigned'
- #nic.device.key = 13016
+ # nic.device.key = 13016
nic.device.deviceInfo = vim.Description()
nic.device.deviceInfo.label = vnic_label
nic.device.deviceInfo.summary = network_name
nic.device.deviceInfo = vim.Description()
nic.device.deviceInfo.label = vnic_label
nic.device.deviceInfo.summary = network_name
self.logger.error("Error {} occurred while adding SRIOV adapter in VM: {}".format(exp, vm_obj))
return None
self.logger.error("Error {} occurred while adding SRIOV adapter in VM: {}".format(exp, vm_obj))
return None
def create_dvPort_group(self, network_name):
"""
Method to create disributed virtual portgroup
def create_dvPort_group(self, network_name):
"""
Method to create disributed virtual portgroup
"""
try:
new_network_name = [network_name, '-', str(uuid.uuid4())]
"""
try:
new_network_name = [network_name, '-', str(uuid.uuid4())]
- network_name=''.join(new_network_name)
+ network_name = ''.join(new_network_name)
vcenter_conect, content = self.get_vcenter_content()
dv_switch = self.get_obj(content, [vim.DistributedVirtualSwitch], self.dvs_name)
vcenter_conect, content = self.get_vcenter_content()
dv_switch = self.get_obj(content, [vim.DistributedVirtualSwitch], self.dvs_name)
self.logger.debug("No disributed virtual switch found with name {}".format(network_name))
except Exception as exp:
self.logger.debug("No disributed virtual switch found with name {}".format(network_name))
except Exception as exp:
- self.logger.error("Error occurred while creating disributed virtaul port group {}"\
- " : {}".format(network_name, exp))
+ self.logger.error("Error occurred while creating disributed virtaul port group {}"
+ " : {}".format(network_name, exp))
- def reconfig_portgroup(self, content, dvPort_group_name , config_info={}):
+ def reconfig_portgroup(self, content, dvPort_group_name, config_info={}):
"""
Method to reconfigure disributed virtual portgroup
"""
Method to reconfigure disributed virtual portgroup
else:
return None
except Exception as exp:
else:
return None
except Exception as exp:
- self.logger.error("Error occurred while reconfiguraing disributed virtaul port group {}"\
- " : {}".format(dvPort_group_name, exp))
+ self.logger.error("Error occurred while reconfiguraing disributed virtaul port group {}"
+ " : {}".format(dvPort_group_name, exp))
-
- def destroy_dvport_group(self , dvPort_group_name):
+ def destroy_dvport_group(self, dvPort_group_name):
"""
Method to destroy disributed virtual portgroup
"""
Method to destroy disributed virtual portgroup
Returns:
True if portgroup successfully got deleted else false
"""
Returns:
True if portgroup successfully got deleted else false
"""
- vcenter_conect, content = self.get_vcenter_content()
+ vcenter_conect, _ = self.get_vcenter_content()
try:
status = None
dvPort_group = self.get_dvport_group(dvPort_group_name)
try:
status = None
dvPort_group = self.get_dvport_group(dvPort_group_name)
return status
except vmodl.MethodFault as exp:
self.logger.error("Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
return status
except vmodl.MethodFault as exp:
self.logger.error("Caught vmodl fault {} while deleting disributed virtaul port group {}".format(
- exp, dvPort_group_name))
+ exp, dvPort_group_name))
def get_dvport_group(self, dvPort_group_name):
"""
Method to get disributed virtual portgroup
def get_dvport_group(self, dvPort_group_name):
"""
Method to get disributed virtual portgroup
Returns:
portgroup object
"""
Returns:
portgroup object
"""
- vcenter_conect, content = self.get_vcenter_content()
+ _, content = self.get_vcenter_content()
- container = content.viewManager.CreateContainerView(content.rootFolder, [vim.dvs.DistributedVirtualPortgroup], True)
+ container = content.viewManager.CreateContainerView(content.rootFolder,
+ [vim.dvs.DistributedVirtualPortgroup], True)
for item in container.view:
if item.key == dvPort_group_name:
dvPort_group = item
break
return dvPort_group
except vmodl.MethodFault as exp:
for item in container.view:
if item.key == dvPort_group_name:
dvPort_group = item
break
return dvPort_group
except vmodl.MethodFault as exp:
- self.logger.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
- exp, dvPort_group_name))
+ self.logger.error("Caught vmodl fault {} for disributed virtual port group {}".format(
+ exp, dvPort_group_name))
return None
def get_vlanID_from_dvs_portgr(self, dvPort_group_name):
return None
def get_vlanID_from_dvs_portgr(self, dvPort_group_name):
vlanId = dvPort_group.config.defaultPortConfig.vlan.vlanId
except vmodl.MethodFault as exp:
self.logger.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
vlanId = dvPort_group.config.defaultPortConfig.vlan.vlanId
except vmodl.MethodFault as exp:
self.logger.error("Caught vmodl fault {} for disributed virtaul port group {}".format(
- exp, dvPort_group_name))
+ exp, dvPort_group_name))
def configure_vlanID(self, content, vcenter_conect, dvPort_group_name):
"""
Method to configure vlanID in disributed virtual portgroup vlanID
def configure_vlanID(self, content, vcenter_conect, dvPort_group_name):
"""
Method to configure vlanID in disributed virtual portgroup vlanID
"""
vlanID = self.get_vlanID_from_dvs_portgr(dvPort_group_name)
if vlanID == 0:
"""
vlanID = self.get_vlanID_from_dvs_portgr(dvPort_group_name)
if vlanID == 0:
vlanID = self.genrate_vlanID(dvPort_group_name)
vlanID = self.genrate_vlanID(dvPort_group_name)
- config = {"vlanID":vlanID}
+ config = {"vlanID": vlanID}
task = self.reconfig_portgroup(content, dvPort_group_name,
task = self.reconfig_portgroup(content, dvPort_group_name,
- status= self.wait_for_vcenter_task(task, vcenter_conect)
+ status = self.wait_for_vcenter_task(task, vcenter_conect)
if status:
self.logger.info("Reconfigured Port group {} for vlan ID {}".format(
if status:
self.logger.info("Reconfigured Port group {} for vlan ID {}".format(
- dvPort_group_name,vlanID))
+ dvPort_group_name, vlanID))
else:
self.logger.error("Fail reconfigure portgroup {} for vlanID{}".format(
else:
self.logger.error("Fail reconfigure portgroup {} for vlanID{}".format(
- dvPort_group_name, vlanID))
-
+ dvPort_group_name, vlanID))
def genrate_vlanID(self, network_name):
"""
def genrate_vlanID(self, network_name):
"""
"""
vlan_id = None
used_ids = []
"""
vlan_id = None
used_ids = []
- if self.config.get('vlanID_range') == None:
- raise vimconn.vimconnConflictException("You must provide a 'vlanID_range' "\
- "at config value before creating sriov network with vlan tag")
+ if self.config.get('vlanID_range') is None:
+ raise vimconn.vimconnConflictException("You must provide a 'vlanID_range' "
+ "at config value before creating sriov network with vlan tag")
if "used_vlanIDs" not in self.persistent_info:
self.persistent_info["used_vlanIDs"] = {}
else:
if "used_vlanIDs" not in self.persistent_info:
self.persistent_info["used_vlanIDs"] = {}
else:
start_vlanid, end_vlanid = vlanID_range.split("-")
if start_vlanid > end_vlanid:
raise vimconn.vimconnConflictException("Invalid vlan ID range {}".format(
start_vlanid, end_vlanid = vlanID_range.split("-")
if start_vlanid > end_vlanid:
raise vimconn.vimconnConflictException("Invalid vlan ID range {}".format(
- for id in range(int(start_vlanid), int(end_vlanid) + 1):
- if id not in used_ids:
- vlan_id = id
+ for vid in range(int(start_vlanid), int(end_vlanid) + 1):
+ if vid not in used_ids:
+ vlan_id = vid
self.persistent_info["used_vlanIDs"][network_name] = vlan_id
return vlan_id
if vlan_id is None:
raise vimconn.vimconnConflictException("All Vlan IDs are in use")
self.persistent_info["used_vlanIDs"][network_name] = vlan_id
return vlan_id
if vlan_id is None:
raise vimconn.vimconnConflictException("All Vlan IDs are in use")
def get_obj(self, content, vimtype, name):
"""
Get the vsphere object associated with a given text name
def get_obj(self, content, vimtype, name):
"""
Get the vsphere object associated with a given text name
def insert_media_to_vm(self, vapp, image_id):
"""
Method to insert media CD-ROM (ISO image) from catalog to vm.
def insert_media_to_vm(self, vapp, image_id):
"""
Method to insert media CD-ROM (ISO image) from catalog to vm.
# fetching catalog details
rest_url = "{}/api/catalog/{}".format(self.url, image_id)
if vca._session:
# fetching catalog details
rest_url = "{}/api/catalog/{}".format(self.url, image_id)
if vca._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=rest_url,
headers=headers)
if response.status_code != 200:
'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
url=rest_url,
headers=headers)
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {}".format(url_rest_call,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("insert_media_to_vm(): Failed to get "\
- "catalog details")
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {}".format(url_rest_call,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("insert_media_to_vm(): Failed to get "
+ "catalog details")
# searching iso name and id
iso_name, media_id = self.get_media_details(vca, response.text)
if iso_name and media_id:
# searching iso name and id
iso_name, media_id = self.get_media_details(vca, response.text)
if iso_name and media_id:
- data ="""<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+ data = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<ns6:MediaInsertOrEjectParams
xmlns="http://www.vmware.com/vcloud/versions" xmlns:ns2="http://schemas.dmtf.org/ovf/envelope/1"
xmlns:ns3="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
<ns6:MediaInsertOrEjectParams
xmlns="http://www.vmware.com/vcloud/versions" xmlns:ns2="http://schemas.dmtf.org/ovf/envelope/1"
xmlns:ns3="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
id="urn:vcloud:media:{}"
href="https://{}/api/media/{}"/>
</ns6:MediaInsertOrEjectParams>""".format(iso_name, media_id,
id="urn:vcloud:media:{}"
href="https://{}/api/media/{}"/>
</ns6:MediaInsertOrEjectParams>""".format(iso_name, media_id,
for vms in vapp.get_all_vms():
vm_id = vms.get('id').split(':')[-1]
headers['Content-Type'] = 'application/vnd.vmware.vcloud.mediaInsertOrEjectParams+xml'
for vms in vapp.get_all_vms():
vm_id = vms.get('id').split(':')[-1]
headers['Content-Type'] = 'application/vnd.vmware.vcloud.mediaInsertOrEjectParams+xml'
- rest_url = "{}/api/vApp/vm-{}/media/action/insertMedia".format(self.url,vm_id)
+ rest_url = "{}/api/vApp/vm-{}/media/action/insertMedia".format(self.url, vm_id)
response = self.perform_request(req_type='POST',
response = self.perform_request(req_type='POST',
- url=rest_url,
- data=data,
+ url=rest_url,
+ data=data,
headers=headers)
if response.status_code != 202:
headers=headers)
if response.status_code != 202:
- error_msg = "insert_media_to_vm() : Failed to insert CD-ROM to vm. Reason {}. " \
- "Status code {}".format(response.text, response.status_code)
+ error_msg = ("insert_media_to_vm() : Failed to insert CD-ROM to vm. Reason {}. "
+ "Status code {}".format(response.text, response.status_code))
self.logger.error(error_msg)
raise vimconn.vimconnException(error_msg)
else:
task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=task)
if result.get('status') == 'success':
self.logger.error(error_msg)
raise vimconn.vimconnException(error_msg)
else:
task = self.get_task_from_response(response.text)
result = self.client.get_task_monitor().wait_for_success(task=task)
if result.get('status') == 'success':
- self.logger.info("insert_media_to_vm(): Sucessfully inserted media ISO"\
- " image to vm {}".format(vm_id))
+ self.logger.info("insert_media_to_vm(): Sucessfully inserted media ISO"
+ " image to vm {}".format(vm_id))
- self.logger.error("insert_media_to_vm() : exception occurred "\
- "while inserting media CD-ROM")
+ self.logger.error("insert_media_to_vm() : exception occurred "
+ "while inserting media CD-ROM")
raise vimconn.vimconnException(message=exp)
raise vimconn.vimconnException(message=exp)
def get_media_details(self, vca, content):
"""
Method to get catalog item details
def get_media_details(self, vca, content):
"""
Method to get catalog item details
if cataloghref_list is not None:
for href in cataloghref_list:
if href:
if cataloghref_list is not None:
for href in cataloghref_list:
if href:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
- 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
+ 'x-vcloud-authorization': vca._session.headers['x-vcloud-authorization']}
response = self.perform_request(req_type='GET',
response = self.perform_request(req_type='GET',
- url=href,
- headers=headers)
+ url=href,
+ headers=headers)
if response.status_code != 200:
if response.status_code != 200:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {}".format(href,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("get_media_details : Failed to get "\
- "catalogitem details")
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {}".format(href,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("get_media_details : Failed to get "
+ "catalogitem details")
list_xmlroot = XmlElementTree.fromstring(response.text)
for child in list_xmlroot.iter():
if 'Entity' in child.tag:
if 'media' in child.attrib.get('href'):
name = child.attrib.get('name')
media_id = child.attrib.get('href').split('/').pop()
list_xmlroot = XmlElementTree.fromstring(response.text)
for child in list_xmlroot.iter():
if 'Entity' in child.tag:
if 'media' in child.attrib.get('href'):
name = child.attrib.get('name')
media_id = child.attrib.get('href').split('/').pop()
else:
self.logger.debug("Media name and id not found")
else:
self.logger.debug("Media name and id not found")
- self.logger.error("get_media_details : exception occurred "\
- "getting media details")
+ self.logger.error("get_media_details : exception occurred "
+ "getting media details")
raise vimconn.vimconnException(message=exp)
raise vimconn.vimconnException(message=exp)
def retry_rest(self, method, url, add_headers=None, data=None):
""" Method to get Token & retry respective REST request
Args:
def retry_rest(self, method, url, add_headers=None, data=None):
""" Method to get Token & retry respective REST request
Args:
self.get_token()
if self.client._session:
self.get_token()
if self.client._session:
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
if add_headers:
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
if add_headers:
headers=headers)
return response
headers=headers)
return response
def get_token(self):
""" Generate a new token if expired
def get_token(self):
""" Generate a new token if expired
# pyvcloud not giving a specific exception, Refresh nevertheless
self.logger.debug("Received exception {}, refreshing token ".format(str(e)))
# pyvcloud not giving a specific exception, Refresh nevertheless
self.logger.debug("Received exception {}, refreshing token ".format(str(e)))
- #Retry once, if failed by refreshing token
+ # Retry once, if failed by refreshing token
if vdc is None:
self.get_token()
org = Org(self.client, resource=self.client.get_org())
if vdc is None:
self.get_token()
org = Org(self.client, resource=self.client.get_org())
def perform_request(self, req_type, url, headers=None, data=None):
"""Perform the POST/PUT/GET/DELETE request."""
def perform_request(self, req_type, url, headers=None, data=None):
"""Perform the POST/PUT/GET/DELETE request."""
- #Log REST request details
+ # Log REST request details
self.log_request(req_type, url=url, headers=headers, data=data)
# perform request and return its result
if req_type == 'GET':
response = requests.get(url=url,
self.log_request(req_type, url=url, headers=headers, data=data)
# perform request and return its result
if req_type == 'GET':
response = requests.get(url=url,
- headers=headers,
- verify=False)
+ headers=headers,
+ verify=False)
elif req_type == 'PUT':
response = requests.put(url=url,
elif req_type == 'PUT':
response = requests.put(url=url,
- headers=headers,
- data=data,
- verify=False)
+ headers=headers,
+ data=data,
+ verify=False)
elif req_type == 'POST':
response = requests.post(url=url,
elif req_type == 'POST':
response = requests.post(url=url,
- headers=headers,
- data=data,
- verify=False)
+ headers=headers,
+ data=data,
+ verify=False)
elif req_type == 'DELETE':
response = requests.delete(url=url,
elif req_type == 'DELETE':
response = requests.delete(url=url,
- headers=headers,
- verify=False)
- #Log the REST response
+ headers=headers,
+ verify=False)
+ # Log the REST response
self.log_response(response)
return response
self.log_response(response)
return response
def log_request(self, req_type, url=None, headers=None, data=None):
"""Logs REST request details"""
def log_request(self, req_type, url=None, headers=None, data=None):
"""Logs REST request details"""
if data is not None:
self.logger.debug("Request data: {}".format(data))
if data is not None:
self.logger.debug("Request data: {}".format(data))
def log_response(self, response):
"""Logs REST response details"""
self.logger.debug("Response status code: {} ".format(response.status_code))
def log_response(self, response):
"""Logs REST response details"""
self.logger.debug("Response status code: {} ".format(response.status_code))
def get_task_from_response(self, content):
"""
content - API response.text(response.text)
def get_task_from_response(self, content):
"""
content - API response.text(response.text)
-
- def power_on_vapp(self,vapp_id, vapp_name):
+ def power_on_vapp(self, vapp_id, vapp_name):
"""
vapp_id - vApp uuid
vapp_name - vAapp name
return - Task object
"""
"""
vapp_id - vApp uuid
vapp_name - vAapp name
return - Task object
"""
- headers = {'Accept':'application/*+xml;version=' + API_VERSION,
+ headers = {'Accept': 'application/*+xml;version=' + API_VERSION,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
poweron_href = "{}/api/vApp/vapp-{}/power/action/powerOn".format(self.url,
'x-vcloud-authorization': self.client._session.headers['x-vcloud-authorization']}
poweron_href = "{}/api/vApp/vapp-{}/power/action/powerOn".format(self.url,
response = self.perform_request(req_type='POST',
response = self.perform_request(req_type='POST',
headers=headers)
if response.status_code != 202:
headers=headers)
if response.status_code != 202:
- self.logger.error("REST call {} failed reason : {}"\
- "status code : {} ".format(poweron_href,
- response.text,
- response.status_code))
- raise vimconn.vimconnException("power_on_vapp() : Failed to power on "\
- "vApp {}".format(vapp_name))
+ self.logger.error("REST call {} failed reason : {}"
+ "status code : {} ".format(poweron_href,
+ response.text,
+ response.status_code))
+ raise vimconn.vimconnException("power_on_vapp() : Failed to power on "
+ "vApp {}".format(vapp_name))
else:
poweron_task = self.get_task_from_response(response.text)
return poweron_task
else:
poweron_task = self.get_task_from_response(response.text)
return poweron_task
projects / osm / RO.git / commitdiff