# -*- coding: utf-8 -*-
##
-# Copyright 2016-2017 VMware Inc.
+# Copyright 2016-2019 VMware Inc.
# This file is part of ETSI OSM
# All Rights Reserved.
#
import vimconn
import os
+import shutil
+import subprocess
+import tempfile
import traceback
import itertools
import requests
INTERVAL_TIME = 5
MAX_WAIT_TIME = 1800
-API_VERSION = '31.0'
+API_VERSION = '27.0'
__author__ = "Mustafa Bayramov, Arpita Kate, Sachin Bhangare, Prakash Kasar"
__date__ = "$09-Mar-2018 11:09:29$"
return vdclist
- def new_network(self, net_name, net_type, ip_profile=None, shared=False, vlan=None):
+ def new_network(self, net_name, net_type, ip_profile=None, shared=False, provider_network_profile=None):
"""Adds a tenant network to VIM
Params:
'net_name': name of the network
'dhcp_start_address': ip_schema, first IP to grant
'dhcp_count': number of IPs to grant.
'shared': if this network can be seen/use by other tenants/organization
- 'vlan': in case of a data or ptp net_type, the intended vlan tag to be used for the network
+ 'provider_network_profile': (optional) contains {segmentation-id: vlan, provider-network: vim_netowrk}
Returns a tuple with the network identifier and created_items, or raises an exception on error
created_items can be None or a dictionary where this method can include key-values that will be passed to
the method delete_network. Can be used to store created segments, created l2gw connections, etc.
as not present.
"""
- self.logger.debug("new_network tenant {} net_type {} ip_profile {} shared {}"
- .format(net_name, net_type, ip_profile, shared))
+ 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")
created_items = {}
isshared = 'false'
# if self.config.get('dv_switch_name') == None:
# raise vimconn.vimconnConflictException("You must provide 'dv_switch_name' at config value")
# network_uuid = self.create_dvPort_group(net_name)
+ parent_network_uuid = None
+
+ import traceback
+ traceback.print_stack()
+
+ if provider_network_profile is not None:
+ for k, v in provider_network_profile.items():
+ if k == 'physical_network':
+ parent_network_uuid = self.get_physical_network_by_name(v)
network_uuid = self.create_network(network_name=net_name, net_type=net_type,
- ip_profile=ip_profile, isshared=isshared)
+ ip_profile=ip_profile, isshared=isshared,
+ parent_network_uuid=parent_network_uuid)
if network_uuid is not None:
return network_uuid, created_items
else:
"""
for catalog in catalogs:
if catalog['name'] == catalog_name:
- return True
- return False
+ return catalog['id']
def create_vimcatalog(self, vca=None, catalog_name=None):
""" Create new catalog entry in vCloud director.
catalog_name catalog that client wish to create. Note no validation done for a name.
Client must make sure that provide valid string representation.
- Return (bool) True if catalog created.
+ Returns catalog id if catalog created else None.
"""
try:
- result = vca.create_catalog(catalog_name, catalog_name)
- if result is not None:
- return True
+ 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'
+ return id_attr_value.split(':')[-1]
catalogs = vca.list_catalogs()
- except:
- return False
+ except Exception as ex:
+ self.logger.error(
+ 'create_vimcatalog(): Creation of catalog "{}" failed with error: {}'.format(catalog_name, ex))
+ raise
return self.catalog_exists(catalog_name, catalogs)
# noinspection PyIncorrectDocstring
if len(catalogs) == 0:
self.logger.info("Creating a new catalog entry {} in vcloud director".format(catalog_name))
- result = self.create_vimcatalog(org, catalog_md5_name)
- if not result:
+ if self.create_vimcatalog(org, catalog_md5_name) is None:
raise vimconn.vimconnException("Failed create new catalog {} ".format(catalog_md5_name))
result = self.upload_vimimage(vca=org, catalog_name=catalog_md5_name,
# if we didn't find existing catalog we create a new one and upload image.
self.logger.debug("Creating new catalog entry {} - {}".format(catalog_name, catalog_md5_name))
- result = self.create_vimcatalog(org, catalog_md5_name)
- if not result:
+ if self.create_vimcatalog(org, catalog_md5_name) is None:
raise vimconn.vimconnException("Failed create new catalog {} ".format(catalog_md5_name))
result = self.upload_vimimage(vca=org, catalog_name=catalog_md5_name,
else:
result = (response.content).replace("\n"," ")
- src = re.search('<Vm goldMaster="false"\sstatus="\d+"\sname="(.*?)"\s'
- 'id="(\w+:\w+:vm:.*?)"\shref="(.*?)"\s'
- 'type="application/vnd\.vmware\.vcloud\.vm\+xml',result)
- if src:
- vm_name = src.group(1)
- vm_id = src.group(2)
- vm_href = src.group(3)
+ vapp_template_tree = XmlElementTree.fromstring(response.content)
+ children_element = [child for child in vapp_template_tree if 'Children' in child.tag][0]
+ vm_element = [child for child in children_element if 'Vm' in child.tag][0]
+ vm_name = vm_element.get('name')
+ 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)
# cloud-init for ssh-key injection
if cloud_config:
- self.cloud_init(vapp,cloud_config)
+ # Create a catalog which will be carrying the config drive ISO
+ # This catalog is deleted during vApp deletion. The catalog name carries
+ # vApp UUID and thats how it gets identified during its deletion.
+ config_drive_catalog_name = 'cfg_drv-' + vapp_uuid
+ self.logger.info('new_vminstance(): Creating catalog "{}" to carry config drive ISO'.format(
+ config_drive_catalog_name))
+ config_drive_catalog_id = self.create_vimcatalog(org, config_drive_catalog_name)
+ if config_drive_catalog_id is None:
+ error_msg = "new_vminstance(): Failed to create new catalog '{}' to carry the config drive " \
+ "ISO".format(config_drive_catalog_name)
+ raise Exception(error_msg)
+
+ # Create config-drive ISO
+ _, userdata = self._create_user_data(cloud_config)
+ # self.logger.debug('new_vminstance(): The userdata for cloud-init: {}'.format(userdata))
+ iso_path = self.create_config_drive_iso(userdata)
+ self.logger.debug('new_vminstance(): The ISO is successfully created. Path: {}'.format(iso_path))
+
+ self.logger.info('new_vminstance(): uploading iso to catalog {}'.format(config_drive_catalog_name))
+ self.upload_iso_to_catalog(config_drive_catalog_id, iso_path)
+ # Attach the config-drive ISO to the VM
+ self.logger.info('new_vminstance(): Attaching the config-drive ISO to the VM')
+ # The ISO remains in INVALID_STATE right after the PUT request (its a blocking call though)
+ time.sleep(5)
+ self.insert_media_to_vm(vapp, config_drive_catalog_id)
+ shutil.rmtree(os.path.dirname(iso_path), ignore_errors=True)
# If VM has PCI devices or SRIOV reserve memory for VM
if reserve_memory:
self.logger.error("new_vminstance(): failed to power on vApp "\
"{}".format(vmname_andid))
- except Exception as exp :
+ except Exception as exp:
+ try:
+ self.delete_vminstance(vapp_uuid)
+ except Exception as exp2:
+ self.logger.error("new_vminstance rollback fail {}".format(exp2))
# it might be a case if specific mandatory entry in dict is empty or some other pyVcloud exception
self.logger.error("new_vminstance(): Failed create new vm instance {} with exception {}"
.format(name, exp))
else:
raise vimconn.vimconnUnexpectedResponse("new_vminstance(): Failed create new vm instance {}".format(name))
+ def create_config_drive_iso(self, user_data):
+ tmpdir = tempfile.mkdtemp()
+ iso_path = os.path.join(tmpdir, 'ConfigDrive.iso')
+ latest_dir = os.path.join(tmpdir, 'openstack', 'latest')
+ os.makedirs(latest_dir)
+ with open(os.path.join(latest_dir, 'meta_data.json'), 'w') as meta_file_obj, \
+ open(os.path.join(latest_dir, 'user_data'), 'w') as userdata_file_obj:
+ userdata_file_obj.write(user_data)
+ meta_file_obj.write(json.dumps({"availability_zone": "nova",
+ "launch_index": 0,
+ "name": "ConfigDrive",
+ "uuid": str(uuid.uuid4())}
+ )
+ )
+ genisoimage_cmd = 'genisoimage -J -r -V config-2 -o {iso_path} {source_dir_path}'.format(
+ iso_path=iso_path, source_dir_path=tmpdir)
+ self.logger.info('create_config_drive_iso(): Creating ISO by running command "{}"'.format(genisoimage_cmd))
+ try:
+ FNULL = open(os.devnull, 'w')
+ subprocess.check_call(genisoimage_cmd, shell=True, stdout=FNULL)
+ except subprocess.CalledProcessError as e:
+ shutil.rmtree(tmpdir, ignore_errors=True)
+ error_msg = 'create_config_drive_iso(): Exception while running genisoimage command: {}'.format(e)
+ self.logger.error(error_msg)
+ raise Exception(error_msg)
+ return iso_path
+
+ def upload_iso_to_catalog(self, catalog_id, iso_file_path):
+ if not os.path.isfile(iso_file_path):
+ error_msg = "upload_iso_to_catalog(): Given iso file is not present. Given path: {}".format(iso_file_path)
+ self.logger.error(error_msg)
+ raise Exception(error_msg)
+ iso_file_stat = os.stat(iso_file_path)
+ xml_media_elem = '''<?xml version="1.0" encoding="UTF-8"?>
+ <Media
+ xmlns="http://www.vmware.com/vcloud/v1.5"
+ name="{iso_name}"
+ size="{iso_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,
+ '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'
+ response = self.perform_request(req_type='POST', url=catalog_href, headers=headers, data=xml_media_elem)
+
+ if response.status_code != 201:
+ error_msg = "upload_iso_to_catalog(): Failed to POST an action/upload request to {}".format(catalog_href)
+ self.logger.error(error_msg)
+ raise Exception(error_msg)
+
+ catalogItem = XmlElementTree.fromstring(response.content)
+ entity = [child for child in catalogItem if child.get("type") == "application/vnd.vmware.vcloud.media+xml"][0]
+ entity_href = entity.get('href')
+
+ response = self.perform_request(req_type='GET', url=entity_href, headers=headers)
+ if response.status_code != 200:
+ raise Exception("upload_iso_to_catalog(): Failed to GET entity href {}".format(entity_href))
+
+ match = re.search(r'<Files>\s+?<File.+?href="(.+?)"/>\s+?</File>\s+?</Files>', response.text, re.DOTALL)
+ if match:
+ media_upload_href = match.group(1)
+ else:
+ raise Exception('Could not parse the upload URL for the media file from the last response')
+ upload_iso_task = self.get_task_from_response(response.content)
+ headers['Content-Type'] = 'application/octet-stream'
+ response = self.perform_request(req_type='PUT',
+ url=media_upload_href,
+ headers=headers,
+ data=open(iso_file_path, 'rb'))
+
+ if response.status_code != 200:
+ raise Exception('PUT request to "{}" failed'.format(media_upload_href))
+ result = self.client.get_task_monitor().wait_for_success(task=upload_iso_task)
+ 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):
""" Method to find presence of av zone is VIM resource pool
self.logger.debug("delete_vminstance(): Failed delete uuid {} ".format(vm__vim_uuid))
else:
self.logger.info("Deleted vm instance {} sccessfully".format(vm__vim_uuid))
+ config_drive_catalog_name, config_drive_catalog_id = 'cfg_drv-' + vm__vim_uuid, None
+ catalog_list = self.get_image_list()
+ try:
+ config_drive_catalog_id = [catalog_['id'] for catalog_ in catalog_list
+ if catalog_['name'] == config_drive_catalog_name][0]
+ except IndexError:
+ pass
+ if config_drive_catalog_id:
+ self.logger.debug('delete_vminstance(): Found a config drive catalog {} matching '
+ 'vapp_name"{}". Deleting it.'.format(config_drive_catalog_id, vapp_name))
+ self.delete_image(config_drive_catalog_id)
return vm__vim_uuid
except:
self.logger.debug(traceback.format_exc())
The return network uuid.
network_uuid: network_id
"""
-
if not network_name:
self.logger.debug("get_network_id_by_name() : Network name is empty")
return None
if org_dict and 'networks' in org_dict:
org_network_dict = org_dict['networks']
for net_uuid,net_name in org_network_dict.iteritems():
- #For python3
- #for net_uuid,net_name in org_network_dict.items():
if net_name == network_name:
return net_uuid
return None
+ def get_physical_network_by_name(self, physical_network_name):
+ '''
+ Methos returns uuid of physical network which passed
+ Args:
+ physical_network_name: physical network name
+ Returns:
+ UUID of physical_network_name
+ '''
+ try:
+ client_as_admin = self.connect_as_admin()
+ if not client_as_admin:
+ raise vimconn.vimconnConnectionException("Failed to connect vCD.")
+ url_list = [self.url, '/api/admin/vdc/', self.tenant_id]
+ 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']}
+
+ response = self.perform_request(req_type='GET',
+ url=vm_list_rest_call,
+ headers=headers)
+
+ provider_network = None
+ available_network = 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,
+ response.status_code))
+ return None
+ else:
+ try:
+ vm_list_xmlroot = XmlElementTree.fromstring(response.content)
+ for child in vm_list_xmlroot:
+
+ if child.tag.split("}")[1] == 'ProviderVdcReference':
+ provider_network = child.attrib.get('href')
+ # application/vnd.vmware.admin.providervdc+xml
+ 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:
+ self.logger.debug("Failed parse respond for rest api call {}".format(vm_list_rest_call))
+ self.logger.debug("Respond body {}".format(response.content))
+ return None
+
+ # find pvdc provided available network
+ response = self.perform_request(req_type='GET',
+ url=provider_network,
+ headers=headers)
+
+ if response.status_code != requests.codes.ok:
+ self.logger.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call,
+ response.status_code))
+ return None
+
+ try:
+ vm_list_xmlroot = XmlElementTree.fromstring(response.content)
+ for child in vm_list_xmlroot.iter():
+ if child.tag.split("}")[1] == 'AvailableNetworks':
+ for networks in child.iter():
+ 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:]
+ break
+ except Exception as e:
+ return None
+
+ return available_network
+ except Exception as e:
+ self.logger.error("Error while getting physical network: {}".format(e))
+
def list_org_action(self):
"""
Method leverages vCloud director and query for available organization for particular user
try:
vm_list_xmlroot = XmlElementTree.fromstring(response.content)
for child in vm_list_xmlroot:
+
if child.tag.split("}")[1] == 'ProviderVdcReference':
provider_network = child.attrib.get('href')
# application/vnd.vmware.admin.providervdc+xml
response = self.perform_request(req_type='GET',
url=provider_network,
headers=headers)
+
if response.status_code != requests.codes.ok:
self.logger.debug("REST API call {} failed. Return status code {}".format(vm_list_rest_call,
response.status_code))
dns2_text = ""
if len(dns_list) >= 2:
dns2_text = "\n <Dns2>{}</Dns2>\n".format(dns_list[1])
- data = """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
- <Description>Openmano created</Description>
- <Configuration>
- <IpScopes>
- <IpScope>
- <IsInherited>{1:s}</IsInherited>
- <Gateway>{2:s}</Gateway>
- <Netmask>{3:s}</Netmask>
- <Dns1>{4:s}</Dns1>{5:s}
- <IsEnabled>{6:s}</IsEnabled>
- <IpRanges>
- <IpRange>
- <StartAddress>{7:s}</StartAddress>
- <EndAddress>{8:s}</EndAddress>
- </IpRange>
- </IpRanges>
- </IpScope>
- </IpScopes>
- <FenceMode>{9:s}</FenceMode>
- </Configuration>
- <IsShared>{10:s}</IsShared>
- </OrgVdcNetwork> """.format(escape(network_name), is_inherited, gateway_address,
- subnet_address, dns1, dns2_text, dhcp_enabled,
- dhcp_start_address, dhcp_end_address,
- fence_mode, isshared)
+ 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>
+ <IpScopes>
+ <IpScope>
+ <IsInherited>{1:s}</IsInherited>
+ <Gateway>{2:s}</Gateway>
+ <Netmask>{3:s}</Netmask>
+ <Dns1>{4:s}</Dns1>{5:s}
+ <IsEnabled>{6:s}</IsEnabled>
+ <IpRanges>
+ <IpRange>
+ <StartAddress>{7:s}</StartAddress>
+ <EndAddress>{8:s}</EndAddress>
+ </IpRange>
+ </IpRanges>
+ </IpScope>
+ </IpScopes>
+ <FenceMode>{9:s}</FenceMode>
+ </Configuration>
+ <IsShared>{10:s}</IsShared>
+ </OrgVdcNetwork> """.format(escape(network_name), is_inherited, gateway_address,
+ subnet_address, dns1, dns2_text, dhcp_enabled,
+ dhcp_start_address, dhcp_end_address,
+ fence_mode, isshared)
+ else:
+ fence_mode = "bridged"
+ data = """ <OrgVdcNetwork name="{0:s}" xmlns="http://www.vmware.com/vcloud/v1.5">
+ <Description>Openmano created</Description>
+ <Configuration>
+ <IpScopes>
+ <IpScope>
+ <IsInherited>{1:s}</IsInherited>
+ <Gateway>{2:s}</Gateway>
+ <Netmask>{3:s}</Netmask>
+ <Dns1>{4:s}</Dns1>{5:s}
+ <IsEnabled>{6:s}</IsEnabled>
+ <IpRanges>
+ <IpRange>
+ <StartAddress>{7:s}</StartAddress>
+ <EndAddress>{8:s}</EndAddress>
+ </IpRange>
+ </IpRanges>
+ </IpScope>
+ </IpScopes>
+ <ParentNetwork href="{9:s}"/>
+ <FenceMode>{10:s}</FenceMode>
+ </Configuration>
+ <IsShared>{11:s}</IsShared>
+ </OrgVdcNetwork> """.format(escape(network_name), is_inherited, gateway_address,
+ subnet_address, dns1, dns2_text, dhcp_enabled,
+ dhcp_start_address, dhcp_end_address, available_networks,
+ fence_mode, isshared)
headers['Content-Type'] = 'application/vnd.vmware.vcloud.orgVdcNetwork+xml'
try:
namespaces["xmlns"] = "http://www.vmware.com/vcloud/v1.5"
nwcfglist = newelem.findall(".//xmlns:NetworkConfig", namespaces)
+ # VCD 9.7 returns an incorrect parentnetwork element. Fix it before PUT operation
+ parentnetworklist = newelem.findall(".//xmlns:ParentNetwork", namespaces)
+ if parentnetworklist:
+ for pn in parentnetworklist:
+ if "href" not in pn.keys():
+ id_val = pn.get("id")
+ href_val = "{}/api/network/{}".format(self.url, id_val)
+ pn.set("href", href_val)
+
newstr = """<NetworkConfig networkName="{}">
<Configuration>
<ParentNetwork href="{}/api/network/{}"/>
if iso_name and media_id:
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" xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/common" xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData" xmlns:ns6="http://www.vmware.com/vcloud/v1.5" xmlns:ns7="http://www.vmware.com/schema/ovf" xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1" xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">
+ xmlns="http://www.vmware.com/vcloud/versions" xmlns:ns2="http://schemas.dmtf.org/ovf/envelope/1"
+ xmlns:ns3="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_VirtualSystemSettingData"
+ xmlns:ns4="http://schemas.dmtf.org/wbem/wscim/1/common"
+ xmlns:ns5="http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData"
+ xmlns:ns6="http://www.vmware.com/vcloud/v1.5"
+ xmlns:ns7="http://www.vmware.com/schema/ovf"
+ xmlns:ns8="http://schemas.dmtf.org/ovf/environment/1"
+ xmlns:ns9="http://www.vmware.com/vcloud/extension/v1.5">
<ns6:Media
type="application/vnd.vmware.vcloud.media+xml"
- name="{}.iso"
+ name="{}"
id="urn:vcloud:media:{}"
href="https://{}/api/media/{}"/>
</ns6:MediaInsertOrEjectParams>""".format(iso_name, media_id,
headers=headers)
if response.status_code != 202:
- self.logger.error("Failed to insert CD-ROM to vm")
- raise vimconn.vimconnException("insert_media_to_vm() : Failed to insert"\
- "ISO image to vm")
+ 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.content)
result = self.client.get_task_monitor().wait_for_success(task=task)
self.org_name))
host = self.url
client = Client(host, verify_ssl_certs=False)
+ client.set_highest_supported_version()
client.set_credentials(BasicLoginCredentials(self.user, self.org_name, self.passwd))
# connection object
self.client = client