##
'''
-osconnector implements all the methods to interact with openstack using the python-client.
+osconnector implements all the methods to interact with openstack using the python-neutronclient.
+
+For the VNF forwarding graph, The OpenStack VIM connector calls the
+networking-sfc Neutron extension methods, whose resources are mapped
+to the VIM connector's SFC resources as follows:
+- Classification (OSM) -> Flow Classifier (Neutron)
+- Service Function Instance (OSM) -> Port Pair (Neutron)
+- Service Function (OSM) -> Port Pair Group (Neutron)
+- Service Function Path (OSM) -> Port Chain (Neutron)
'''
-__author__="Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research"
-__date__ ="$22-jun-2014 11:19:29$"
+__author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C."
+__date__ = "$22-sep-2017 23:59:59$"
import vimconn
import json
-import yaml
import logging
import netaddr
import time
import yaml
import random
-import sys
import re
+import copy
from novaclient import client as nClient, exceptions as nvExceptions
from keystoneauth1.identity import v2, v3
from neutronclient.neutron import client as neClient
from neutronclient.common import exceptions as neExceptions
from requests.exceptions import ConnectionError
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
"""contain the openstack virtual machine status to openmano status"""
netStatus2manoFormat={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
}
+supportedClassificationTypes = ['legacy_flow_classifier']
+
#global var to have a timeout creating and deleting volumes
volume_timeout = 60
server_timeout = 300
self.insecure = self.config.get("insecure", False)
if not url:
- raise TypeError, 'url param can not be NoneType'
+ raise TypeError('url param can not be NoneType')
self.persistent_info = persistent_info
self.availability_zone = persistent_info.get('availability_zone', None)
self.session = persistent_info.get('session', {'reload_client': True})
if self.config.get('APIversion'):
self.api_version3 = self.config['APIversion'] == 'v3.3' or self.config['APIversion'] == '3'
else: # get from ending auth_url that end with v3 or with v2.0
- self.api_version3 = self.url.split("/")[-1] == "v3"
+ self.api_version3 = self.url.endswith("/v3") or self.url.endswith("/v3/")
self.session['api_version3'] = self.api_version3
if self.api_version3:
+ if self.config.get('project_domain_id') or self.config.get('project_domain_name'):
+ project_domain_id_default = None
+ else:
+ project_domain_id_default = 'default'
+ if self.config.get('user_domain_id') or self.config.get('user_domain_name'):
+ user_domain_id_default = None
+ else:
+ user_domain_id_default = 'default'
auth = v3.Password(auth_url=self.url,
username=self.user,
password=self.passwd,
project_name=self.tenant_name,
project_id=self.tenant_id,
- project_domain_id=self.config.get('project_domain_id', 'default'),
- user_domain_id=self.config.get('user_domain_id', 'default'))
+ project_domain_id=self.config.get('project_domain_id', project_domain_id_default),
+ user_domain_id=self.config.get('user_domain_id', user_domain_id_default),
+ project_domain_name=self.config.get('project_domain_name'),
+ user_domain_name=self.config.get('user_domain_name'))
else:
auth = v2.Password(auth_url=self.url,
username=self.user,
else:
net['type']='bridge'
+ def __classification_os2mano(self, class_list_dict):
+ """Transform the openstack format (Flow Classifier) to mano format
+ (Classification) class_list_dict can be a list of dict or a single dict
+ """
+ if isinstance(class_list_dict, dict):
+ class_list_ = [class_list_dict]
+ elif isinstance(class_list_dict, list):
+ class_list_ = class_list_dict
+ else:
+ raise TypeError(
+ "param class_list_dict must be a list or a dictionary")
+ for classification in class_list_:
+ id = classification.pop('id')
+ name = classification.pop('name')
+ description = classification.pop('description')
+ project_id = classification.pop('project_id')
+ tenant_id = classification.pop('tenant_id')
+ original_classification = copy.deepcopy(classification)
+ classification.clear()
+ classification['ctype'] = 'legacy_flow_classifier'
+ classification['definition'] = original_classification
+ classification['id'] = id
+ classification['name'] = name
+ classification['description'] = description
+ classification['project_id'] = project_id
+ classification['tenant_id'] = tenant_id
+
+ def __sfi_os2mano(self, sfi_list_dict):
+ """Transform the openstack format (Port Pair) to mano format (SFI)
+ sfi_list_dict can be a list of dict or a single dict
+ """
+ if isinstance(sfi_list_dict, dict):
+ sfi_list_ = [sfi_list_dict]
+ elif isinstance(sfi_list_dict, list):
+ sfi_list_ = sfi_list_dict
+ else:
+ raise TypeError(
+ "param sfi_list_dict must be a list or a dictionary")
+ for sfi in sfi_list_:
+ sfi['ingress_ports'] = []
+ sfi['egress_ports'] = []
+ if sfi.get('ingress'):
+ sfi['ingress_ports'].append(sfi['ingress'])
+ if sfi.get('egress'):
+ sfi['egress_ports'].append(sfi['egress'])
+ del sfi['ingress']
+ del sfi['egress']
+ params = sfi.get('service_function_parameters')
+ sfc_encap = False
+ if params:
+ correlation = params.get('correlation')
+ if correlation:
+ sfc_encap = True
+ sfi['sfc_encap'] = sfc_encap
+ del sfi['service_function_parameters']
+
+ def __sf_os2mano(self, sf_list_dict):
+ """Transform the openstack format (Port Pair Group) to mano format (SF)
+ sf_list_dict can be a list of dict or a single dict
+ """
+ if isinstance(sf_list_dict, dict):
+ sf_list_ = [sf_list_dict]
+ elif isinstance(sf_list_dict, list):
+ sf_list_ = sf_list_dict
+ else:
+ raise TypeError(
+ "param sf_list_dict must be a list or a dictionary")
+ for sf in sf_list_:
+ del sf['port_pair_group_parameters']
+ sf['sfis'] = sf['port_pairs']
+ del sf['port_pairs']
+
+ def __sfp_os2mano(self, sfp_list_dict):
+ """Transform the openstack format (Port Chain) to mano format (SFP)
+ sfp_list_dict can be a list of dict or a single dict
+ """
+ if isinstance(sfp_list_dict, dict):
+ sfp_list_ = [sfp_list_dict]
+ elif isinstance(sfp_list_dict, list):
+ sfp_list_ = sfp_list_dict
+ else:
+ raise TypeError(
+ "param sfp_list_dict must be a list or a dictionary")
+ for sfp in sfp_list_:
+ params = sfp.pop('chain_parameters')
+ sfc_encap = False
+ if params:
+ correlation = params.get('correlation')
+ if correlation:
+ sfc_encap = True
+ sfp['sfc_encap'] = sfc_encap
+ sfp['spi'] = sfp.pop('chain_id')
+ sfp['classifications'] = sfp.pop('flow_classifiers')
+ sfp['service_functions'] = sfp.pop('port_pair_groups')
+
+ # placeholder for now; read TODO note below
+ def _validate_classification(self, type, definition):
+ # only legacy_flow_classifier Type is supported at this point
+ return True
+ # TODO(igordcard): this method should be an abstract method of an
+ # abstract Classification class to be implemented by the specific
+ # Types. Also, abstract vimconnector should call the validation
+ # method before the implemented VIM connectors are called.
+
def _format_exception(self, exception):
'''Transform a keystone, nova, neutron exception into a vimconn exception'''
if isinstance(exception, (HTTPException, gl1Exceptions.HTTPException, gl1Exceptions.CommunicationError,
ConnectionError, ksExceptions.ConnectionError, neExceptions.ConnectionFailed
)):
- raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + str(exception))
- elif isinstance(exception, (nvExceptions.ClientException, ksExceptions.ClientException,
+ raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + str(exception))
+ elif isinstance(exception, (nvExceptions.ClientException, ksExceptions.ClientException,
neExceptions.NeutronException, nvExceptions.BadRequest)):
raise vimconn.vimconnUnexpectedResponse(type(exception).__name__ + ": " + str(exception))
elif isinstance(exception, (neExceptions.NetworkNotFoundClient, nvExceptions.NotFound)):
#Fake subnet is required
subnet_rand = random.randint(0, 255)
ip_profile['subnet_address'] = "192.168.{}.0/24".format(subnet_rand)
- if 'ip_version' not in ip_profile:
+ if 'ip_version' not in ip_profile:
ip_profile['ip_version'] = "IPv4"
subnet = {"name":net_name+"-subnet",
"network_id": new_net["network"]["id"],
error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- '''
+ '''
net_dict={}
for net_id in net_list:
net = {}
else:
net["status"] = "OTHER"
net["error_msg"] = "VIM status reported " + net_vim['status']
-
+
if net['status'] == "ACTIVE" and not net_vim['admin_state_up']:
net['status'] = 'DOWN'
try:
except (nvExceptions.NotFound, nvExceptions.ClientException, ksExceptions.ClientException, ConnectionError) as e:
self._format_exception(e)
-
def new_flavor(self, flavor_data, change_name_if_used=True):
'''Adds a tenant flavor to openstack VIM
if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
# if interface["dedicated"]=="yes":
# raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
# #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
-
+
#create flavor
- new_flavor=self.nova.flavors.create(name,
- ram,
- vcpus,
+ new_flavor=self.nova.flavors.create(name,
+ ram,
+ vcpus,
flavor_data.get('disk',1),
is_public=flavor_data.get('is_public', True)
)
except IOError as e: #can not open the file
raise vimconn.vimconnConnectionException(type(e).__name__ + ": " + str(e)+ " for " + image_dict['location'],
http_code=vimconn.HTTP_Bad_Request)
-
+
def delete_image(self, image_id):
'''Deletes a tenant image from openstack VIM. Returns the old id
'''
self._format_exception(e)
def get_image_id_from_path(self, path):
- '''Get the image id from image path in the VIM database. Returns the image_id'''
+ '''Get the image id from image path in the VIM database. Returns the image_id'''
try:
self._reload_connection()
images = self.nova.images.list()
raise vimconn.vimconnNotFoundException("image with location '{}' not found".format( path))
except (ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e:
self._format_exception(e)
-
+
def get_image_list(self, filter_dict={}):
'''Obtain tenant images from VIM
Filter_dict can be:
filter_dict_os=filter_dict.copy()
#First we filter by the available filter fields: name, id. The others are removed.
filter_dict_os.pop('checksum',None)
- image_list=self.nova.images.findall(**filter_dict_os)
- if len(image_list)==0:
+ image_list = self.nova.images.findall(**filter_dict_os)
+ if len(image_list) == 0:
return []
#Then we filter by the rest of filter fields: checksum
filtered_list = []
for image in image_list:
- image_class=self.glance.images.get(image.id)
- if 'checksum' not in filter_dict or image_class['checksum']==filter_dict.get('checksum'):
- filtered_list.append(image_class.copy())
+ try:
+ image_class = self.glance.images.get(image.id)
+ if 'checksum' not in filter_dict or image_class['checksum']==filter_dict.get('checksum'):
+ filtered_list.append(image_class.copy())
+ except gl1Exceptions.HTTPNotFound:
+ pass
return filtered_list
except (ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e:
self._format_exception(e)
- @staticmethod
- def _create_mimemultipart(content_list):
- """Creates a MIMEmultipart text combining the content_list
- :param content_list: list of text scripts to be combined
- :return: str of the created MIMEmultipart. If the list is empty returns None, if the list contains only one
- element MIMEmultipart is not created and this content is returned
- """
- if not content_list:
- return None
- elif len(content_list) == 1:
- return content_list[0]
- combined_message = MIMEMultipart()
- for content in content_list:
- if content.startswith('#include'):
- format = 'text/x-include-url'
- elif content.startswith('#include-once'):
- format = 'text/x-include-once-url'
- elif content.startswith('#!'):
- format = 'text/x-shellscript'
- elif content.startswith('#cloud-config'):
- format = 'text/cloud-config'
- elif content.startswith('#cloud-config-archive'):
- format = 'text/cloud-config-archive'
- elif content.startswith('#upstart-job'):
- format = 'text/upstart-job'
- elif content.startswith('#part-handler'):
- format = 'text/part-handler'
- elif content.startswith('#cloud-boothook'):
- format = 'text/cloud-boothook'
- else: # by default
- format = 'text/x-shellscript'
- sub_message = MIMEText(content, format, sys.getdefaultencoding())
- combined_message.attach(sub_message)
- return combined_message.as_string()
-
def __wait_for_vm(self, vm_id, status):
"""wait until vm is in the desired status and return True.
If the VM gets in ERROR status, return false.
def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
availability_zone_index=None, availability_zone_list=None):
- '''Adds a VM instance to VIM
+ """Adds a VM instance to VIM
Params:
start: indicates if VM must start or boot in pause mode. Ignored
image_id,flavor_id: iamge and flavor uuid
model: interface model, ignored #TODO
mac_address: used for SR-IOV ifaces #TODO for other types
use: 'data', 'bridge', 'mgmt'
- type: 'virtual', 'PF', 'VF', 'VFnotShared'
+ type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
vim_id: filled/added by this function
floating_ip: True/False (or it can be None)
'cloud_config': (optional) dictionary with:
availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
availability_zone_index is None
#TODO ip, security groups
- Returns the instance identifier
- '''
+ Returns a tuple with the instance 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_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
+ Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
+ as not present.
+ """
self.logger.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id, flavor_id,str(net_list))
try:
server = None
- metadata={}
- net_list_vim=[]
- external_network=[] # list of external networks to be connected to instance, later on used to create floating_ip
+ created_items = {}
+ # metadata = {}
+ net_list_vim = []
+ external_network = [] # list of external networks to be connected to instance, later on used to create floating_ip
no_secured_ports = [] # List of port-is with port-security disabled
self._reload_connection()
- metadata_vpci={} # For a specific neutron plugin
+ # metadata_vpci = {} # For a specific neutron plugin
block_device_mapping = None
for net in net_list:
- if not net.get("net_id"): #skip non connected iface
+ if not net.get("net_id"): # skip non connected iface
continue
port_dict={
"admin_state_up": True
}
if net["type"]=="virtual":
- if "vpci" in net:
- metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
- elif net["type"]=="VF": # for VF
- if "vpci" in net:
- if "VF" not in metadata_vpci:
- metadata_vpci["VF"]=[]
- metadata_vpci["VF"].append([ net["vpci"], "" ])
+ pass
+ # if "vpci" in net:
+ # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
+ elif net["type"] == "VF" or net["type"] == "SR-IOV": # for VF
+ # if "vpci" in net:
+ # if "VF" not in metadata_vpci:
+ # metadata_vpci["VF"]=[]
+ # metadata_vpci["VF"].append([ net["vpci"], "" ])
port_dict["binding:vnic_type"]="direct"
- ########## VIO specific Changes #######
+ # VIO specific Changes
if self.vim_type == "VIO":
- #Need to create port with port_security_enabled = False and no-security-groups
+ # Need to create port with port_security_enabled = False and no-security-groups
port_dict["port_security_enabled"]=False
port_dict["provider_security_groups"]=[]
port_dict["security_groups"]=[]
- else: #For PT
- ########## VIO specific Changes #######
- #Current VIO release does not support port with type 'direct-physical'
- #So no need to create virtual port in case of PCI-device.
- #Will update port_dict code when support gets added in next VIO release
+ else: # For PT PCI-PASSTHROUGH
+ # VIO specific Changes
+ # Current VIO release does not support port with type 'direct-physical'
+ # So no need to create virtual port in case of PCI-device.
+ # Will update port_dict code when support gets added in next VIO release
if self.vim_type == "VIO":
- raise vimconn.vimconnNotSupportedException("Current VIO release does not support full passthrough (PT)")
- if "vpci" in net:
- if "PF" not in metadata_vpci:
- metadata_vpci["PF"]=[]
- metadata_vpci["PF"].append([ net["vpci"], "" ])
+ raise vimconn.vimconnNotSupportedException(
+ "Current VIO release does not support full passthrough (PT)")
+ # if "vpci" in net:
+ # if "PF" not in metadata_vpci:
+ # metadata_vpci["PF"]=[]
+ # metadata_vpci["PF"].append([ net["vpci"], "" ])
port_dict["binding:vnic_type"]="direct-physical"
if not port_dict["name"]:
port_dict["name"]=name
if net.get("mac_address"):
port_dict["mac_address"]=net["mac_address"]
new_port = self.neutron.create_port({"port": port_dict })
+ created_items[("port", str(new_port["port"]["id"]))] = True
net["mac_adress"] = new_port["port"]["mac_address"]
net["vim_id"] = new_port["port"]["id"]
# if try to use a network without subnetwork, it will return a emtpy list
if net.get("port_security") == False:
no_secured_ports.append(new_port["port"]["id"])
- if metadata_vpci:
- metadata = {"pci_assignement": json.dumps(metadata_vpci)}
- if len(metadata["pci_assignement"]) >255:
- #limit the metadata size
- #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
- self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
- metadata = {}
-
- self.logger.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
- name, image_id, flavor_id, str(net_list_vim), description, str(metadata))
-
- security_groups = self.config.get('security_groups')
+ # if metadata_vpci:
+ # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
+ # if len(metadata["pci_assignement"]) >255:
+ # #limit the metadata size
+ # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
+ # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
+ # metadata = {}
+
+ self.logger.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
+ name, image_id, flavor_id, str(net_list_vim), description)
+
+ security_groups = self.config.get('security_groups')
if type(security_groups) is str:
security_groups = ( security_groups, )
- #cloud config
- userdata=None
- config_drive = None
- userdata_list = []
- if isinstance(cloud_config, dict):
- if cloud_config.get("user-data"):
- if isinstance(cloud_config["user-data"], str):
- userdata_list.append(cloud_config["user-data"])
- else:
- for u in cloud_config["user-data"]:
- userdata_list.append(u)
- if cloud_config.get("boot-data-drive") != None:
- config_drive = cloud_config["boot-data-drive"]
- if cloud_config.get("config-files") or cloud_config.get("users") or cloud_config.get("key-pairs"):
- userdata_dict={}
- #default user
- if cloud_config.get("key-pairs"):
- userdata_dict["ssh-authorized-keys"] = cloud_config["key-pairs"]
- userdata_dict["users"] = [{"default": None, "ssh-authorized-keys": cloud_config["key-pairs"] }]
- if cloud_config.get("users"):
- if "users" not in userdata_dict:
- userdata_dict["users"] = [ "default" ]
- for user in cloud_config["users"]:
- user_info = {
- "name" : user["name"],
- "sudo": "ALL = (ALL)NOPASSWD:ALL"
- }
- if "user-info" in user:
- user_info["gecos"] = user["user-info"]
- if user.get("key-pairs"):
- user_info["ssh-authorized-keys"] = user["key-pairs"]
- userdata_dict["users"].append(user_info)
-
- if cloud_config.get("config-files"):
- userdata_dict["write_files"] = []
- for file in cloud_config["config-files"]:
- file_info = {
- "path" : file["dest"],
- "content": file["content"]
- }
- if file.get("encoding"):
- file_info["encoding"] = file["encoding"]
- if file.get("permissions"):
- file_info["permissions"] = file["permissions"]
- if file.get("owner"):
- file_info["owner"] = file["owner"]
- userdata_dict["write_files"].append(file_info)
- userdata_list.append("#cloud-config\n" + yaml.safe_dump(userdata_dict, indent=4,
- default_flow_style=False))
- userdata = self._create_mimemultipart(userdata_list)
- self.logger.debug("userdata: %s", userdata)
- elif isinstance(cloud_config, str):
- userdata = cloud_config
-
- #Create additional volumes in case these are present in disk_list
+ # cloud config
+ config_drive, userdata = self._create_user_data(cloud_config)
+
+ # Create additional volumes in case these are present in disk_list
base_disk_index = ord('b')
if disk_list != None:
block_device_mapping = {}
else:
volume = self.cinder.volumes.create(size=disk['size'], name=name + '_vd' +
chr(base_disk_index))
+ created_items[("volume", str(volume.id))] = True
block_device_mapping['_vd' + chr(base_disk_index)] = volume.id
base_disk_index += 1
- #wait until volumes are with status available
+ # Wait until volumes are with status available
keep_waiting = True
elapsed_time = 0
while keep_waiting and elapsed_time < volume_timeout:
time.sleep(1)
elapsed_time += 1
- #if we exceeded the timeout rollback
+ # If we exceeded the timeout rollback
if elapsed_time >= volume_timeout:
- #delete the volumes we just created
- for volume_id in block_device_mapping.itervalues():
- self.cinder.volumes.delete(volume_id)
-
- #delete ports we just created
- for net_item in net_list_vim:
- if 'port-id' in net_item:
- self.neutron.delete_port(net_item['port-id'])
-
raise vimconn.vimconnException('Timeout creating volumes for instance ' + name,
http_code=vimconn.HTTP_Request_Timeout)
# get availability Zone
vm_av_zone = self._get_vm_availability_zone(availability_zone_index, availability_zone_list)
- self.logger.debug("nova.servers.create({}, {}, {}, nics={}, meta={}, security_groups={}, "
+ self.logger.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
"availability_zone={}, key_name={}, userdata={}, config_drive={}, "
- "block_device_mapping={})".format(name, image_id, flavor_id, net_list_vim, metadata,
+ "block_device_mapping={})".format(name, image_id, flavor_id, net_list_vim,
security_groups, vm_av_zone, self.config.get('keypair'),
- userdata, config_drive, block_device_mapping))
- server = self.nova.servers.create(name, image_id, flavor_id, nics=net_list_vim, meta=metadata,
+ userdata, config_drive, block_device_mapping))
+ server = self.nova.servers.create(name, image_id, flavor_id, nics=net_list_vim,
security_groups=security_groups,
availability_zone=vm_av_zone,
key_name=self.config.get('keypair'),
for port_id in no_secured_ports:
try:
self.neutron.update_port(port_id, {"port": {"port_security_enabled": False, "security_groups": None} })
-
except Exception as e:
self.logger.error("It was not possible to disable port security for port {}".format(port_id))
- self.delete_vminstance(server.id)
raise
- #print "DONE :-)", server
- pool_id = None
- floating_ips = self.neutron.list_floatingips().get("floatingips", ())
+ # print "DONE :-)", server
+ pool_id = None
if external_network:
+ floating_ips = self.neutron.list_floatingips().get("floatingips", ())
self.__wait_for_vm(server.id, 'ACTIVE')
for floating_network in external_network:
try:
assigned = False
- while(assigned == False):
+ while not assigned:
if floating_ips:
ip = floating_ips.pop(0)
if not ip.get("port_id", False) and ip.get('tenant_id') == server.tenant_id:
continue
raise
- return server.id
+ return server.id, created_items
# except nvExceptions.NotFound as e:
# error_value=-vimconn.HTTP_Not_Found
# error_text= "vm instance %s not found" % vm_id
# raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
except Exception as e:
- # delete the volumes we just created
- if block_device_mapping:
- for volume_id in block_device_mapping.itervalues():
- self.cinder.volumes.delete(volume_id)
-
- # Delete the VM
- if server != None:
- self.delete_vminstance(server.id)
- else:
- # delete ports we just created
- for net_item in net_list_vim:
- if 'port-id' in net_item:
- self.neutron.delete_port(net_item['port-id'])
+ server_id = None
+ if server:
+ server_id = server.id
+ try:
+ self.delete_vminstance(server_id, created_items)
+ except Exception as e2:
+ self.logger.error("new_vminstance rollback fail {}".format(e2))
self._format_exception(e)
console_dict = server.get_spice_console(console_type)
else:
raise vimconn.vimconnException("console type '{}' not allowed".format(console_type), http_code=vimconn.HTTP_Bad_Request)
-
+
console_dict1 = console_dict.get("console")
if console_dict1:
console_url = console_dict1.get("url")
if protocol_index < 0 or port_index<0 or suffix_index<0:
return -vimconn.HTTP_Internal_Server_Error, "Unexpected response from VIM"
console_dict={"protocol": console_url[0:protocol_index],
- "server": console_url[protocol_index+2:port_index],
- "port": console_url[port_index:suffix_index],
- "suffix": console_url[suffix_index+1:]
+ "server": console_url[protocol_index+2:port_index],
+ "port": console_url[port_index:suffix_index],
+ "suffix": console_url[suffix_index+1:]
}
protocol_index += 2
return console_dict
raise vimconn.vimconnUnexpectedResponse("Unexpected response from VIM")
-
+
except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.BadRequest, ConnectionError) as e:
self._format_exception(e)
- def delete_vminstance(self, vm_id):
+ def delete_vminstance(self, vm_id, created_items=None):
'''Removes a VM instance from VIM. Returns the old identifier
'''
#print "osconnector: Getting VM from VIM"
+ if created_items == None:
+ created_items = {}
try:
self._reload_connection()
- #delete VM ports attached to this networks before the virtual machine
- ports = self.neutron.list_ports(device_id=vm_id)
- for p in ports['ports']:
+ # delete VM ports attached to this networks before the virtual machine
+ for k, v in created_items.items():
+ if not v: # skip already deleted
+ continue
try:
- self.neutron.delete_port(p["id"])
+ if k[0] == "port":
+ self.neutron.delete_port(k[1])
except Exception as e:
self.logger.error("Error deleting port: " + type(e).__name__ + ": "+ str(e))
- #commented because detaching the volumes makes the servers.delete not work properly ?!?
- #dettach volumes attached
- server = self.nova.servers.get(vm_id)
- volumes_attached_dict = server._info['os-extended-volumes:volumes_attached']
- #for volume in volumes_attached_dict:
- # self.cinder.volumes.detach(volume['id'])
+ # #commented because detaching the volumes makes the servers.delete not work properly ?!?
+ # #dettach volumes attached
+ # server = self.nova.servers.get(vm_id)
+ # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
+ # #for volume in volumes_attached_dict:
+ # # self.cinder.volumes.detach(volume['id'])
- self.nova.servers.delete(vm_id)
+ if vm_id:
+ self.nova.servers.delete(vm_id)
- #delete volumes.
- #Although having detached them should have them in active status
- #we ensure in this loop
+ # delete volumes. Although having detached, they should have in active status before deleting
+ # we ensure in this loop
keep_waiting = True
elapsed_time = 0
while keep_waiting and elapsed_time < volume_timeout:
keep_waiting = False
- for volume in volumes_attached_dict:
- if self.cinder.volumes.get(volume['id']).status != 'available':
- keep_waiting = True
- else:
- self.cinder.volumes.delete(volume['id'])
+ for k, v in created_items.items():
+ if not v: # skip already deleted
+ continue
+ try:
+ if k[0] == "volume":
+ if self.cinder.volumes.get(k[1]).status != 'available':
+ keep_waiting = True
+ else:
+ self.cinder.volumes.delete(k[1])
+ except Exception as e:
+ self.logger.error("Error deleting volume: " + type(e).__name__ + ": " + str(e))
if keep_waiting:
time.sleep(1)
elapsed_time += 1
-
- return vm_id
+ return None
except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
self._format_exception(e)
- #TODO insert exception vimconn.HTTP_Unauthorized
- #if reaching here is because an exception
def refresh_vms_status(self, vm_list):
'''Get the status of the virtual machines and their interfaces/ports
vm['error_msg'] = str(e)
vm_dict[vm_id] = vm
return vm_dict
-
- def action_vminstance(self, vm_id, action_dict):
+
+ def action_vminstance(self, vm_id, action_dict, created_items={}):
'''Send and action over a VM instance from VIM
- Returns the vm_id if the action was successfully sent to the VIM'''
+ Returns None or the console dict if the action was successfully sent to the VIM'''
self.logger.debug("Action over VM '%s': %s", vm_id, str(action_dict))
try:
self._reload_connection()
server = self.nova.servers.find(id=vm_id)
if "start" in action_dict:
- if action_dict["start"]=="rebuild":
+ if action_dict["start"]=="rebuild":
server.rebuild()
else:
if server.status=="PAUSED":
elif console_type == "spice-html5":
console_dict = server.get_spice_console(console_type)
else:
- raise vimconn.vimconnException("console type '{}' not allowed".format(console_type),
+ raise vimconn.vimconnException("console type '{}' not allowed".format(console_type),
http_code=vimconn.HTTP_Bad_Request)
try:
console_url = console_dict["console"]["url"]
if protocol_index < 0 or port_index<0 or suffix_index<0:
raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
console_dict2={"protocol": console_url[0:protocol_index],
- "server": console_url[protocol_index+2 : port_index],
- "port": int(console_url[port_index+1 : suffix_index]),
- "suffix": console_url[suffix_index+1:]
+ "server": console_url[protocol_index+2 : port_index],
+ "port": int(console_url[port_index+1 : suffix_index]),
+ "suffix": console_url[suffix_index+1:]
}
- return console_dict2
+ return console_dict2
except Exception as e:
raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
-
- return vm_id
+
+ return None
except (ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.NotFound, ConnectionError) as e:
self._format_exception(e)
#TODO insert exception vimconn.HTTP_Unauthorized
"start_ID < end_ID ".format(vlanID_range))
#NOT USED FUNCTIONS
-
+
def new_external_port(self, port_data):
#TODO openstack if needed
'''Adds a external port to VIM'''
'''Returns the port identifier'''
- return -vimconn.HTTP_Internal_Server_Error, "osconnector.new_external_port() not implemented"
-
+ return -vimconn.HTTP_Internal_Server_Error, "osconnector.new_external_port() not implemented"
+
def connect_port_network(self, port_id, network_id, admin=False):
#TODO openstack if needed
'''Connects a external port to a network'''
'''Returns status code of the VIM response'''
- return -vimconn.HTTP_Internal_Server_Error, "osconnector.connect_port_network() not implemented"
-
+ return -vimconn.HTTP_Internal_Server_Error, "osconnector.connect_port_network() not implemented"
+
def new_user(self, user_name, user_passwd, tenant_id=None):
'''Adds a new user to openstack VIM'''
'''Returns the user identifier'''
#if reaching here is because an exception
if self.debug:
self.logger.debug("new_user " + error_text)
- return error_value, error_text
+ return error_value, error_text
def delete_user(self, user_id):
'''Delete a user from openstack VIM'''
'''Returns the user identifier'''
if self.debug:
- print "osconnector: Deleting a user from VIM"
+ print("osconnector: Deleting a user from VIM")
try:
self._reload_connection()
self.keystone.users.delete(user_id)
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
- print "delete_tenant " + error_text
+ print("delete_tenant " + error_text)
return error_value, error_text
-
+
def get_hosts_info(self):
'''Get the information of deployed hosts
Returns the hosts content'''
if self.debug:
- print "osconnector: Getting Host info from VIM"
+ print("osconnector: Getting Host info from VIM")
try:
h_list=[]
self._reload_connection()
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
- print "get_hosts_info " + error_text
- return error_value, error_text
+ print("get_hosts_info " + error_text)
+ return error_value, error_text
def get_hosts(self, vim_tenant):
'''Get the hosts and deployed instances
#TODO insert exception vimconn.HTTP_Unauthorized
#if reaching here is because an exception
if self.debug:
- print "get_hosts " + error_text
- return error_value, error_text
-
+ print("get_hosts " + error_text)
+ return error_value, error_text
+
+ def new_classification(self, name, ctype, definition):
+ self.logger.debug(
+ 'Adding a new (Traffic) Classification to VIM, named %s', name)
+ try:
+ new_class = None
+ self._reload_connection()
+ if ctype not in supportedClassificationTypes:
+ raise vimconn.vimconnNotSupportedException(
+ 'OpenStack VIM connector doesn\'t support provided '
+ 'Classification Type {}, supported ones are: '
+ '{}'.format(ctype, supportedClassificationTypes))
+ if not self._validate_classification(ctype, definition):
+ raise vimconn.vimconnException(
+ 'Incorrect Classification definition '
+ 'for the type specified.')
+ classification_dict = definition
+ classification_dict['name'] = name
+
+ new_class = self.neutron.create_flow_classifier(
+ {'flow_classifier': classification_dict})
+ return new_class['flow_classifier']['id']
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ self.logger.error(
+ 'Creation of Classification failed.')
+ self._format_exception(e)
+
+ def get_classification(self, class_id):
+ self.logger.debug(" Getting Classification %s from VIM", class_id)
+ filter_dict = {"id": class_id}
+ class_list = self.get_classification_list(filter_dict)
+ if len(class_list) == 0:
+ raise vimconn.vimconnNotFoundException(
+ "Classification '{}' not found".format(class_id))
+ elif len(class_list) > 1:
+ raise vimconn.vimconnConflictException(
+ "Found more than one Classification with this criteria")
+ classification = class_list[0]
+ return classification
+
+ def get_classification_list(self, filter_dict={}):
+ self.logger.debug("Getting Classifications from VIM filter: '%s'",
+ str(filter_dict))
+ try:
+ self._reload_connection()
+ if self.api_version3 and "tenant_id" in filter_dict:
+ filter_dict['project_id'] = filter_dict.pop('tenant_id')
+ classification_dict = self.neutron.list_flow_classifier(
+ **filter_dict)
+ classification_list = classification_dict["flow_classifiers"]
+ self.__classification_os2mano(classification_list)
+ return classification_list
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ self._format_exception(e)
+
+ def delete_classification(self, class_id):
+ self.logger.debug("Deleting Classification '%s' from VIM", class_id)
+ try:
+ self._reload_connection()
+ self.neutron.delete_flow_classifier(class_id)
+ return class_id
+ except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
+ ksExceptions.ClientException, neExceptions.NeutronException,
+ ConnectionError) as e:
+ self._format_exception(e)
+
+ def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True):
+ self.logger.debug(
+ "Adding a new Service Function Instance to VIM, named '%s'", name)
+ try:
+ new_sfi = None
+ self._reload_connection()
+ correlation = None
+ if sfc_encap:
+ # TODO(igordc): must be changed to NSH in Queens
+ # (MPLS is a workaround)
+ correlation = 'mpls'
+ if len(ingress_ports) != 1:
+ raise vimconn.vimconnNotSupportedException(
+ "OpenStack VIM connector can only have "
+ "1 ingress port per SFI")
+ if len(egress_ports) != 1:
+ raise vimconn.vimconnNotSupportedException(
+ "OpenStack VIM connector can only have "
+ "1 egress port per SFI")
+ sfi_dict = {'name': name,
+ 'ingress': ingress_ports[0],
+ 'egress': egress_ports[0],
+ 'service_function_parameters': {
+ 'correlation': correlation}}
+ new_sfi = self.neutron.create_port_pair({'port_pair': sfi_dict})
+ return new_sfi['port_pair']['id']
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ if new_sfi:
+ try:
+ self.neutron.delete_port_pair_group(
+ new_sfi['port_pair']['id'])
+ except Exception:
+ self.logger.error(
+ 'Creation of Service Function Instance failed, with '
+ 'subsequent deletion failure as well.')
+ self._format_exception(e)
+
+ def get_sfi(self, sfi_id):
+ self.logger.debug(
+ 'Getting Service Function Instance %s from VIM', sfi_id)
+ filter_dict = {"id": sfi_id}
+ sfi_list = self.get_sfi_list(filter_dict)
+ if len(sfi_list) == 0:
+ raise vimconn.vimconnNotFoundException(
+ "Service Function Instance '{}' not found".format(sfi_id))
+ elif len(sfi_list) > 1:
+ raise vimconn.vimconnConflictException(
+ 'Found more than one Service Function Instance '
+ 'with this criteria')
+ sfi = sfi_list[0]
+ return sfi
+
+ def get_sfi_list(self, filter_dict={}):
+ self.logger.debug("Getting Service Function Instances from "
+ "VIM filter: '%s'", str(filter_dict))
+ try:
+ self._reload_connection()
+ if self.api_version3 and "tenant_id" in filter_dict:
+ filter_dict['project_id'] = filter_dict.pop('tenant_id')
+ sfi_dict = self.neutron.list_port_pair(**filter_dict)
+ sfi_list = sfi_dict["port_pairs"]
+ self.__sfi_os2mano(sfi_list)
+ return sfi_list
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ self._format_exception(e)
+
+ def delete_sfi(self, sfi_id):
+ self.logger.debug("Deleting Service Function Instance '%s' "
+ "from VIM", sfi_id)
+ try:
+ self._reload_connection()
+ self.neutron.delete_port_pair(sfi_id)
+ return sfi_id
+ except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
+ ksExceptions.ClientException, neExceptions.NeutronException,
+ ConnectionError) as e:
+ self._format_exception(e)
+
+ def new_sf(self, name, sfis, sfc_encap=True):
+ self.logger.debug("Adding a new Service Function to VIM, "
+ "named '%s'", name)
+ try:
+ new_sf = None
+ self._reload_connection()
+ correlation = None
+ if sfc_encap:
+ # TODO(igordc): must be changed to NSH in Queens
+ # (MPLS is a workaround)
+ correlation = 'mpls'
+ for instance in sfis:
+ sfi = self.get_sfi(instance)
+ if sfi.get('sfc_encap') != correlation:
+ raise vimconn.vimconnNotSupportedException(
+ "OpenStack VIM connector requires all SFIs of the "
+ "same SF to share the same SFC Encapsulation")
+ sf_dict = {'name': name,
+ 'port_pairs': sfis}
+ new_sf = self.neutron.create_port_pair_group({
+ 'port_pair_group': sf_dict})
+ return new_sf['port_pair_group']['id']
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ if new_sf:
+ try:
+ self.neutron.delete_port_pair_group(
+ new_sf['port_pair_group']['id'])
+ except Exception:
+ self.logger.error(
+ 'Creation of Service Function failed, with '
+ 'subsequent deletion failure as well.')
+ self._format_exception(e)
+
+ def get_sf(self, sf_id):
+ self.logger.debug("Getting Service Function %s from VIM", sf_id)
+ filter_dict = {"id": sf_id}
+ sf_list = self.get_sf_list(filter_dict)
+ if len(sf_list) == 0:
+ raise vimconn.vimconnNotFoundException(
+ "Service Function '{}' not found".format(sf_id))
+ elif len(sf_list) > 1:
+ raise vimconn.vimconnConflictException(
+ "Found more than one Service Function with this criteria")
+ sf = sf_list[0]
+ return sf
+
+ def get_sf_list(self, filter_dict={}):
+ self.logger.debug("Getting Service Function from VIM filter: '%s'",
+ str(filter_dict))
+ try:
+ self._reload_connection()
+ if self.api_version3 and "tenant_id" in filter_dict:
+ filter_dict['project_id'] = filter_dict.pop('tenant_id')
+ sf_dict = self.neutron.list_port_pair_group(**filter_dict)
+ sf_list = sf_dict["port_pair_groups"]
+ self.__sf_os2mano(sf_list)
+ return sf_list
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ self._format_exception(e)
+
+ def delete_sf(self, sf_id):
+ self.logger.debug("Deleting Service Function '%s' from VIM", sf_id)
+ try:
+ self._reload_connection()
+ self.neutron.delete_port_pair_group(sf_id)
+ return sf_id
+ except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
+ ksExceptions.ClientException, neExceptions.NeutronException,
+ ConnectionError) as e:
+ self._format_exception(e)
+
+ def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
+ self.logger.debug("Adding a new Service Function Path to VIM, "
+ "named '%s'", name)
+ try:
+ new_sfp = None
+ self._reload_connection()
+ if not sfc_encap:
+ raise vimconn.vimconnNotSupportedException(
+ "OpenStack VIM connector only supports "
+ "SFC-Encapsulated chains")
+ # TODO(igordc): must be changed to NSH in Queens
+ # (MPLS is a workaround)
+ correlation = 'mpls'
+ sfp_dict = {'name': name,
+ 'flow_classifiers': classifications,
+ 'port_pair_groups': sfs,
+ 'chain_parameters': {'correlation': correlation}}
+ if spi:
+ sfp_dict['chain_id'] = spi
+ new_sfp = self.neutron.create_port_chain({'port_chain': sfp_dict})
+ return new_sfp["port_chain"]["id"]
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ if new_sfp:
+ try:
+ self.neutron.delete_port_chain(new_sfp['port_chain']['id'])
+ except Exception:
+ self.logger.error(
+ 'Creation of Service Function Path failed, with '
+ 'subsequent deletion failure as well.')
+ self._format_exception(e)
+ def get_sfp(self, sfp_id):
+ self.logger.debug(" Getting Service Function Path %s from VIM", sfp_id)
+ filter_dict = {"id": sfp_id}
+ sfp_list = self.get_sfp_list(filter_dict)
+ if len(sfp_list) == 0:
+ raise vimconn.vimconnNotFoundException(
+ "Service Function Path '{}' not found".format(sfp_id))
+ elif len(sfp_list) > 1:
+ raise vimconn.vimconnConflictException(
+ "Found more than one Service Function Path with this criteria")
+ sfp = sfp_list[0]
+ return sfp
+
+ def get_sfp_list(self, filter_dict={}):
+ self.logger.debug("Getting Service Function Paths from VIM filter: "
+ "'%s'", str(filter_dict))
+ try:
+ self._reload_connection()
+ if self.api_version3 and "tenant_id" in filter_dict:
+ filter_dict['project_id'] = filter_dict.pop('tenant_id')
+ sfp_dict = self.neutron.list_port_chain(**filter_dict)
+ sfp_list = sfp_dict["port_chains"]
+ self.__sfp_os2mano(sfp_list)
+ return sfp_list
+ except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
+ neExceptions.NeutronException, ConnectionError) as e:
+ self._format_exception(e)
+ def delete_sfp(self, sfp_id):
+ self.logger.debug(
+ "Deleting Service Function Path '%s' from VIM", sfp_id)
+ try:
+ self._reload_connection()
+ self.neutron.delete_port_chain(sfp_id)
+ return sfp_id
+ except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
+ ksExceptions.ClientException, neExceptions.NeutronException,
+ ConnectionError) as e:
+ self._format_exception(e)
projects / osm / RO.git / blobdiff