X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FRO.git;a=blobdiff_plain;f=RO-VIM-fos%2Fosm_rovim_fos%2Fvimconn_fos.py;h=21f1b9f1230ae291bd0f59caf9edfa6a1b3dfddb;hp=b2795d8123548f928ab7a5d19e12b2394e466a09;hb=refs%2Ftags%2Frelease-v8.0-start;hpb=17587e31d62b42076f347a884b83ccd889edc5a8 diff --git a/RO-VIM-fos/osm_rovim_fos/vimconn_fos.py b/RO-VIM-fos/osm_rovim_fos/vimconn_fos.py index b2795d81..21f1b9f1 100644 --- a/RO-VIM-fos/osm_rovim_fos/vimconn_fos.py +++ b/RO-VIM-fos/osm_rovim_fos/vimconn_fos.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- ## -# Copyright 2019 ADLINK Technology Inc.. +# Copyright 2020 ADLINK Technology Inc. # This file is part of ETSI OSM # All Rights Reserved. # @@ -20,7 +20,7 @@ # """ -Eclipse fog05 connector, implements methods to interact with fog05 using REST Client + REST Proxy +Eclipse fog05 connector, implements methods to interact with Eclipse fog05 Manages LXD containers on x86_64 by default, currently missing EPA and VF/PF Support config dict: @@ -31,21 +31,22 @@ Support config dict: for the selected hypervisor """ -__author__="Gabriele Baldoni" -__date__ ="$13-may-2019 10:35:12$" import uuid import socket import struct -from osm_ro import vimconn -import random -import yaml +from osm_ro_plugin import vimconn +# import json from functools import partial -from fog05rest import FIMAPI -from fog05rest import fimerrors +from fog05 import FIMAPI +from fog05 import fimapi +from fog05_sdk.interfaces.FDU import FDU +__author__ = "Gabriele Baldoni" +__date__ = "$2-june-2020 10:35:12$" -class vimconnector(vimconn.vimconnector): + +class vimconnector(vimconn.VimConnector): def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None, config={}, persistent_info={}): """Constructor of VIM @@ -66,7 +67,7 @@ class vimconnector(vimconn.vimconnector): check against the VIM """ - vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, + vimconn.VimConnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level, config, persistent_info) self.logger.debug('vimconn_fos init with config: {}'.format(config)) @@ -76,7 +77,6 @@ class vimconnector(vimconn.vimconnector): self.fdu_node_map = {} self.fos_api = FIMAPI(locator=self.url) - def __get_ip_range(self, first, count): int_first = struct.unpack('!L', socket.inet_aton(first))[0] int_last = int_first + count @@ -100,15 +100,15 @@ class vimconnector(vimconn.vimconnector): def check_vim_connectivity(self): """Checks VIM can be reached and user credentials are ok. - Returns None if success or raised vimconnConnectionException, vimconnAuthException, ... + Returns None if success or raised VimConnConnectionException, VimConnAuthException, ... """ try: - self.fos_api.check() + self.fos_api.node.list() return None - except fimerrors.FIMAuthExcetpion as fae: - raise vimconn.vimconnAuthException("Unable to authenticate to the VIM. Error {}".format(fae)) + except fimapi.FIMAuthExcetpion as fae: + raise vimconn.VimConnAuthException("Unable to authenticate to the VIM. Error {}".format(fae)) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) def new_network(self, net_name, net_type, ip_profile=None, shared=False, provider_network_profile=None): """Adds a tenant network to VIM @@ -130,52 +130,52 @@ class vimconnector(vimconn.vimconnector): Returns the network identifier on success or raises and exception on failure """ self.logger.debug('new_network: {}'.format(locals())) - if net_type in ['data','ptp']: - raise vimconn.vimconnNotImplemented('{} type of network not supported'.format(net_type)) + if net_type in ['data', 'ptp']: + raise vimconn.VimConnNotImplemented('{} type of network not supported'.format(net_type)) net_uuid = '{}'.format(uuid.uuid4()) desc = { - 'uuid':net_uuid, - 'name':net_name, - 'net_type':'ELAN', - 'is_mgmt':False - } + 'uuid': net_uuid, + 'name': net_name, + 'net_type': 'ELAN', + 'is_mgmt': False + } if ip_profile is not None: ip = {} if ip_profile.get('ip_version') == 'IPv4': ip_info = {} ip_range = self.__get_ip_range(ip_profile.get('dhcp_start_address'), ip_profile.get('dhcp_count')) - dhcp_range = '{},{}'.format(ip_range[0],ip_range[1]) - ip.update({'subnet':ip_profile.get('subnet_address')}) - ip.update({'dns':ip_profile.get('dns', None)}) - ip.update({'dhcp_enable':ip_profile.get('dhcp_enabled', False)}) - ip.update({'dhcp_range': dhcp_range}) - ip.update({'gateway':ip_profile.get('gateway_address', None)}) - desc.update({'ip_configuration':ip_info}) + dhcp_range = '{},{}'.format(ip_range[0], ip_range[1]) + ip['subnet'] = ip_profile.get('subnet_address') + ip['dns'] = ip_profile.get('dns', None) + ip['dhcp_enable'] = ip_profile.get('dhcp_enabled', False) + ip['dhcp_range'] = dhcp_range + ip['gateway'] = ip_profile.get('gateway_address', None) + desc['ip_configuration'] = ip_info else: - raise vimconn.vimconnNotImplemented('IPV6 network is not implemented at VIM') - desc.update({'ip_configuration':ip}) + raise vimconn.VimConnNotImplemented('IPV6 network is not implemented at VIM') + desc['ip_configuration'] = ip self.logger.debug('VIM new_network args: {} - Generated Eclipse fog05 Descriptor {}'.format(locals(), desc)) try: self.fos_api.network.add_network(desc) - except fimerrors.FIMAResouceExistingException as free: - raise vimconn.vimconnConflictException("Network already exists at VIM. Error {}".format(free)) + except fimapi.FIMAResouceExistingException as free: + raise vimconn.VimConnConflictException("Network already exists at VIM. Error {}".format(free)) except Exception as e: - raise vimconn.vimconnException("Unable to create network {}. Error {}".format(net_name, e)) - # No way from the current rest service to get the actual error, most likely it will be an already existing error - return net_uuid,{} + raise vimconn.VimConnException("Unable to create network {}. Error {}".format(net_name, e)) + # No way from the current rest service to get the actual error, most likely it will be an already + # existing error + return net_uuid, {} def get_network_list(self, filter_dict={}): """Obtain tenant networks of VIM - Params: - 'filter_dict' (optional) contains entries to return only networks that matches ALL entries: - name: string => returns only networks with this name - id: string => returns networks with this VIM id, this imply returns one network at most - shared: boolean >= returns only networks that are (or are not) shared - tenant_id: sting => returns only networks that belong to this tenant/project - ,#(not used yet) admin_state_up: boolean => returns only networks that are (or are not) in admin state active - #(not used yet) status: 'ACTIVE','ERROR',... => filter networks that are on this status + :param filter_dict: (optional) contains entries to return only networks that matches ALL entries: + name: string => returns only networks with this name + id: string => returns networks with this VIM id, this imply returns one network at most + shared: boolean >= returns only networks that are (or are not) shared + tenant_id: sting => returns only networks that belong to this tenant/project + (not used yet) admin_state_up: boolean => returns only networks that are (or are not) in admin state active + (not used yet) status: 'ACTIVE','ERROR',... => filter networks that are on this status Returns the network list of dictionaries. each dictionary contains: 'id': (mandatory) VIM network id 'name': (mandatory) VIM network name @@ -192,11 +192,12 @@ class vimconnector(vimconn.vimconnector): try: nets = self.fos_api.network.list() except Exception as e: - raise vimconn.vimconnConnectionException("Cannot get network list from VIM, connection error. Error {}".format(e)) + raise vimconn.VimConnConnectionException( + "Cannot get network list from VIM, connection error. Error {}".format(e)) filters = [ partial(self.__name_filter, filter_name=filter_dict.get('name')), - partial(self.__id_filter,filter_id=filter_dict.get('id')) + partial(self.__id_filter, filter_id=filter_dict.get('id')) ] r1 = [] @@ -210,9 +211,9 @@ class vimconnector(vimconn.vimconnector): for n in r1: osm_net = { - 'id':n.get('uuid'), - 'name':n.get('name'), - 'status':'ACTIVE' + 'id': n.get('uuid'), + 'name': n.get('name'), + 'status': 'ACTIVE' } res.append(osm_net) return res @@ -228,9 +229,9 @@ class vimconnector(vimconn.vimconnector): Raises an exception upon error or when network is not found """ self.logger.debug('get_network: {}'.format(net_id)) - res = self.get_network_list(filter_dict={'id':net_id}) + res = self.get_network_list(filter_dict={'id': net_id}) if len(res) == 0: - raise vimconn.vimconnNotFoundException("Network {} not found at VIM".format(net_id)) + raise vimconn.VimConnNotFoundException("Network {} not found at VIM".format(net_id)) return res[0] def delete_network(self, net_id, created_items=None): @@ -240,10 +241,11 @@ class vimconnector(vimconn.vimconnector): self.logger.debug('delete_network: {}'.format(net_id)) try: self.fos_api.network.remove_network(net_id) - except fimerrors.FIMNotFoundException as fnfe: - raise vimconn.vimconnNotFoundException("Network {} not found at VIM (already deleted?). Error {}".format(net_id, fnfe)) + except fimapi.FIMNotFoundException as fnfe: + raise vimconn.VimConnNotFoundException( + "Network {} not found at VIM (already deleted?). Error {}".format(net_id, fnfe)) except Exception as e: - raise vimconn.vimconnException("Cannot delete network {} from VIM. Error {}".format(net_id, e)) + raise vimconn.VimConnException("Cannot delete network {} from VIM. Error {}".format(net_id, e)) return net_id def refresh_nets_status(self, net_list): @@ -268,13 +270,9 @@ class vimconnector(vimconn.vimconnector): for n in net_list: try: osm_n = self.get_network(n) - r.update({ - osm_n.get('id'):{'status':osm_n.get('status')} - }) - except vimconn.vimconnNotFoundException: - r.update({ - n:{'status':'VIM_ERROR'} - }) + r[osm_n.get('id')] = {'status': osm_n.get('status')} + except vimconn.VimConnNotFoundException: + r[n] = {'status': 'VIM_ERROR'} return r def get_flavor(self, flavor_id): @@ -286,10 +284,10 @@ class vimconnector(vimconn.vimconnector): try: r = self.fos_api.flavor.get(flavor_id) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) if r is None: - raise vimconn.vimconnNotFoundException("Flavor not found at VIM") - return {'id':r.get('uuid'), 'name':r.get('name'), 'fos':r} + raise vimconn.VimConnNotFoundException("Flavor not found at VIM") + return {'id': r.get('uuid'), 'name': r.get('name'), 'fos': r} def get_flavor_id_from_data(self, flavor_dict): """Obtain flavor id that match the flavor description @@ -306,10 +304,12 @@ class vimconnector(vimconn.vimconnector): try: flvs = self.fos_api.flavor.list() except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) - r = [x.get('uuid') for x in flvs if (x.get('cpu_min_count') == flavor_dict.get('vcpus') and x.get('ram_size_mb') == flavor_dict.get('ram') and x.get('storage_size_gb') == flavor_dict.get('disk'))] + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) + r = [x.get('uuid') for x in flvs if (x.get('cpu_min_count') == flavor_dict.get('vcpus') and + x.get('ram_size_mb') == flavor_dict.get('ram') and + x.get('storage_size_gb') == flavor_dict.get('disk'))] if len(r) == 0: - raise vimconn.vimconnNotFoundException ( "No flavor found" ) + raise vimconn.VimConnNotFoundException("No flavor found") return r[0] def new_flavor(self, flavor_data): @@ -320,9 +320,9 @@ class vimconnector(vimconn.vimconnector): vpcus: cpus (cloud type) 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 - interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa + memory: number of 1G huge pages memory + 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 bandwidth: X Gbps; requested guarantee bandwidth @@ -334,32 +334,32 @@ class vimconnector(vimconn.vimconnector): self.logger.debug('VIM new_flavor with args: {}'.format(locals())) flv_id = '{}'.format(uuid.uuid4()) desc = { - 'uuid':flv_id, - 'name':flavor_data.get('name'), + 'uuid': flv_id, + 'name': flavor_data.get('name'), 'cpu_arch': self.arch, 'cpu_min_count': flavor_data.get('vcpus'), - 'cpu_min_freq': 0.0, - 'ram_size_mb':float(flavor_data.get('ram')), - 'storage_size_gb':float(flavor_data.get('disk')) + 'cpu_min_freq': 0, + 'ram_size_mb': float(flavor_data.get('ram')), + 'storage_size_gb': float(flavor_data.get('disk')) } try: self.fos_api.flavor.add(desc) - except fimerrors.FIMAResouceExistingException as free: - raise vimconn.vimconnConflictException("Flavor {} already exist at VIM. Error {}".format(flv_id, free)) + except fimapi.FIMAResouceExistingException as free: + raise vimconn.VimConnConflictException("Flavor {} already exist at VIM. Error {}".format(flv_id, free)) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) return flv_id - def delete_flavor(self, flavor_id): """Deletes a tenant flavor from VIM identify by its id Returns the used id or raise an exception""" try: self.fos_api.flavor.remove(flavor_id) - except fimerrors.FIMNotFoundException as fnfe: - raise vimconn.vimconnNotFoundException("Flavor {} not found at VIM (already deleted?). Error {}".format(flavor_id, fnfe)) + except fimapi.FIMNotFoundException as fnfe: + raise vimconn.VimConnNotFoundException( + "Flavor {} not found at VIM (already deleted?). Error {}".format(flavor_id, fnfe)) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) return flavor_id def new_image(self, image_dict): @@ -374,16 +374,17 @@ class vimconnector(vimconn.vimconnector): self.logger.debug('VIM new_image with args: {}'.format(locals())) img_id = '{}'.format(uuid.uuid4()) desc = { - 'name':image_dict.get('name'), - 'uuid':img_id, - 'uri':image_dict.get('location') + 'name': image_dict.get('name'), + 'uuid': img_id, + 'uri': image_dict.get('location'), + 'format': image_dict.get('disk_format') } try: self.fos_api.image.add(desc) - except fimerrors.FIMAResouceExistingException as free: - raise vimconn.vimconnConflictException("Image {} already exist at VIM. Error {}".format(img_id, free)) + except fimapi.FIMAResouceExistingException as free: + raise vimconn.VimConnConflictException("Image {} already exist at VIM. Error {}".format(img_id, free)) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) return img_id def get_image_id_from_path(self, path): @@ -395,10 +396,10 @@ class vimconnector(vimconn.vimconnector): try: imgs = self.fos_api.image.list() except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) - res = [x.get('uuid') for x in imgs if x.get('uri')==path] + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) + res = [x.get('uuid') for x in imgs if x.get('uri') == path] if len(res) == 0: - raise vimconn.vimconnNotFoundException("Image with this path was not found") + raise vimconn.VimConnNotFoundException("Image with this path was not found") return res[0] def get_image_list(self, filter_dict={}): @@ -417,12 +418,12 @@ class vimconnector(vimconn.vimconnector): try: fimgs = self.fos_api.image.list() except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) filters = [ partial(self.__name_filter, filter_name=filter_dict.get('name')), - partial(self.__id_filter,filter_id=filter_dict.get('id')), - partial(self.__checksum_filter,filter_checksum=filter_dict.get('checksum')) + partial(self.__id_filter, filter_id=filter_dict.get('id')), + partial(self.__checksum_filter, filter_checksum=filter_dict.get('checksum')) ] r1 = [] @@ -436,99 +437,100 @@ class vimconnector(vimconn.vimconnector): for i in r1: img_info = { - 'name':i.get('name'), - 'id':i.get('uuid'), - 'checksum':i.get('checksum'), - 'location':i.get('uri'), - 'fos':i + 'name': i.get('name'), + 'id': i.get('uuid'), + 'checksum': i.get('checksum'), + 'location': i.get('uri'), + 'fos': i } r.append(img_info) return r - #raise vimconnNotImplemented( "Should have implemented this" ) + # raise VimConnNotImplemented( "Should have implemented this" ) 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): + availability_zone_index=None, availability_zone_list=None): """Adds a VM instance to VIM - Params: - 'start': (boolean) indicates if VM must start or created in pause mode. - 'image_id','flavor_id': image and flavor VIM id to use for the VM - '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 - 'model': (optional and only have sense for type==virtual) interface model: virtio, e1000, ... - 'mac_address': (optional) mac address to assign to this interface - 'ip_address': (optional) IP 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 - '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 - '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 - 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS - 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing - or True, it must apply the default VIM behaviour - After execution the method will add the key: - 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this - interface. 'net_list' is modified - 'cloud_config': (optional) dictionary with: - 'key-pairs': (optional) list of strings with the public key to be inserted to the default user - 'users': (optional) list of users to be inserted, each item is a dict with: - 'name': (mandatory) user name, - 'key-pairs': (optional) list of strings with the public key to be inserted to the user - 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init, - or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file - 'config-files': (optional). List of files to be transferred. Each item is a dict with: - 'dest': (mandatory) string with the destination absolute path - 'encoding': (optional, by default text). Can be one of: - 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64' - 'content' (mandatory): string with the content of the file - 'permissions': (optional) string with file permissions, typically octal notation '0644' - 'owner': (optional) file owner, string with the format 'owner:group' - 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk) - 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with: - 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted - 'size': (mandatory) string with the size of the disk in GB - availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required - availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if - availability_zone_index is None + :param start: (boolean) indicates if VM must start or created in pause mode. + :param image_id: :param flavor_id: image and flavor VIM id to use for the VM + :param 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 + 'model': (optional and only have sense for type==virtual) interface model: virtio, e1000, ... + 'mac_address': (optional) mac address to assign to this interface + 'ip_address': (optional) IP 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 + '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 + '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 + 'bw': (optional) only for PF/VF/VFnotShared. Minimal Bandwidth required for the interface in GBPS + 'port_security': (optional) If False it must avoid any traffic filtering at this interface. If missing + or True, it must apply the default VIM behaviour + After execution the method will add the key: + 'vim_id': must be filled/added by this method with the VIM identifier generated by the VIM for this + interface. 'net_list' is modified + :param cloud_config: (optional) dictionary with: + 'key-pairs': (optional) list of strings with the public key to be inserted to the default user + 'users': (optional) list of users to be inserted, each item is a dict with: + 'name': (mandatory) user name, + 'key-pairs': (optional) list of strings with the public key to be inserted to the user + 'user-data': (optional) can be a string with the text script to be passed directly to cloud-init, + or a list of strings, each one contains a script to be passed, usually with a MIMEmultipart file + 'config-files': (optional). List of files to be transferred. Each item is a dict with: + 'dest': (mandatory) string with the destination absolute path + 'encoding': (optional, by default text). Can be one of: + 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64' + 'content' (mandatory): string with the content of the file + 'permissions': (optional) string with file permissions, typically octal notation '0644' + 'owner': (optional) file owner, string with the format 'owner:group' + 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk) + :param disk_list: (optional) list with additional disks to the VM. Each item is a dict with: + 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted + 'size': (mandatory) string with the size of the disk in GB + :param availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required + :param availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if + availability_zone_index is None 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 with rgs: {}'.format(locals())) + self.logger.debug('new_vminstance with args: {}'.format(locals())) fdu_uuid = '{}'.format(uuid.uuid4()) flv = self.fos_api.flavor.get(flavor_id) img = self.fos_api.image.get(image_id) if flv is None: - raise vimconn.vimconnNotFoundException("Flavor {} not found at VIM".format(flavor_id)) + raise vimconn.VimConnNotFoundException("Flavor {} not found at VIM".format(flavor_id)) if img is None: - raise vimconn.vimconnNotFoundException("Image {} not found at VIM".format(image_id)) + raise vimconn.VimConnNotFoundException("Image {} not found at VIM".format(image_id)) created_items = { - 'fdu_id':'', - 'node_id':'', - 'connection_points':[] - } + 'fdu_id': '', + 'node_id': '', + 'connection_points': [] + } fdu_desc = { - 'name':name, - 'uuid':fdu_uuid, - 'computation_requirements':flv, - 'image':img, - 'hypervisor':self.hv, - 'migration_kind':'LIVE', - 'interfaces':[], - 'io_ports':[], - 'connection_points':[], - 'depends_on':[] + 'name': name, + 'id': fdu_uuid, + 'uuid': fdu_uuid, + 'computation_requirements': flv, + 'image': img, + 'hypervisor': self.hv, + 'migration_kind': 'LIVE', + 'interfaces': [], + 'io_ports': [], + 'connection_points': [], + 'depends_on': [], + 'storage': [] } nets = [] @@ -536,22 +538,24 @@ class vimconnector(vimconn.vimconnector): intf_id = 0 for n in net_list: cp_id = '{}'.format(uuid.uuid4()) - n.update({'vim_id':cp_id}) + n['vim_id'] = cp_id pair_id = n.get('net_id') cp_d = { - 'uuid':cp_id, - 'pair_id':pair_id + 'id': cp_id, + 'name': cp_id, + 'vld_ref': pair_id } intf_d = { - 'name':n.get('name','eth{}'.format(intf_id)), - 'is_mgmt':False, - 'if_type':'INTERNAL', - 'virtual_interface':{ - 'intf_type':n.get('model','VIRTIO'), - 'vpci':n.get('vpci','0:0:0'), - 'bandwidth':int(n.get('bw', 100)) - } + 'name': n.get('name', 'eth{}'.format(intf_id)), + 'is_mgmt': False, + 'if_type': 'INTERNAL', + 'virtual_interface': { + 'intf_type': n.get('model', 'VIRTIO'), + 'vpci': n.get('vpci', '0:0:0'), + 'bandwidth': int(n.get('bw', 100)) + }, + 'cp_id': cp_id } if n.get('mac_address', None) is not None: intf_d['mac_address'] = n['mac_address'] @@ -563,110 +567,67 @@ class vimconnector(vimconn.vimconnector): intf_id = intf_id + 1 if cloud_config is not None: - configuration = { - 'conf_type':'CLOUD_INIT' - } + configuration = {'conf_type': 'CLOUD_INIT'} if cloud_config.get('user-data') is not None: - configuration.update({'script':cloud_config.get('user-data')}) + configuration['script'] = cloud_config.get('user-data') if cloud_config.get('key-pairs') is not None: - configuration.update({'ssh_keys':cloud_config.get('key-pairs')}) + configuration['ssh_keys'] = cloud_config.get('key-pairs') if 'script' in configuration: - fdu_desc.update({'configuration':configuration}) - - ### NODE Selection ### - # Infrastructure info - # nodes dict with - # uuid -> node uuid - # computational capabilities -> cpu, ram, and disk available - # hypervisors -> list of available hypervisors (eg. KVM, LXD, BARE) - # - # - - # UPDATING AVAILABLE INFRASTRUCTURE - - if len(self.nodes) == 0: - nodes_id = self.fos_api.node.list() - else: - nodes_id = self.nodes - nodes = [] - for n in nodes_id: - n_info = self.fos_api.node.info(n) - if n_info is None: - continue - n_plugs = [] - for p in self.fos_api.node.plugins(n): - n_plugs.append(self.fos_api.plugin.info(n,p)) - - n_cpu_number = len(n_info.get('cpu')) - n_cpu_arch = n_info.get('cpu')[0].get('arch') - n_cpu_freq = n_info.get('cpu')[0].get('frequency') - n_ram = n_info.get('ram').get('size') - n_disk_size = sorted(list(filter(lambda x: 'sda' in x['local_address'], n_info.get('disks'))), key= lambda k: k['dimension'])[-1].get('dimension') - - hvs = [] - for p in n_plugs: - if p.get('type') == 'runtime': - hvs.append(p.get('name')) - - ni = { - 'uuid':n, - 'computational_capabilities':{ - 'cpu_count':n_cpu_number, - 'cpu_arch':n_cpu_arch, - 'cpu_freq':n_cpu_freq, - 'ram_size':n_ram, - 'disk_size':n_disk_size - }, - 'hypervisors':hvs - } - nodes.append(ni) - - # NODE SELECTION - compatible_nodes = [] - for n in nodes: - if fdu_desc.get('hypervisor') in n.get('hypervisors'): - n_comp = n.get('computational_capabilities') - f_comp = fdu_desc.get('computation_requirements') - if f_comp.get('cpu_arch') == n_comp.get('cpu_arch'): - if f_comp.get('cpu_min_count') <= n_comp.get('cpu_count') and f_comp.get('ram_size_mb') <= n_comp.get('ram_size'): - if f_comp.get('disk_size_gb') <= n_comp.get('disk_size'): - compatible_nodes.append(n) + fdu_desc['configuration'] = configuration - if len(compatible_nodes) == 0: - raise vimconn.vimconnConflictException("No available nodes at VIM") - selected_node = random.choice(compatible_nodes) + self.logger.debug('Eclipse fog05 FDU Descriptor: {}'.format(fdu_desc)) - created_items.update({'fdu_id':fdu_uuid, 'node_id': selected_node.get('uuid')}) - - self.logger.debug('FOS Node {} FDU Descriptor: {}'.format(selected_node.get('uuid'), fdu_desc)) + fdu = FDU(fdu_desc) try: - self.fos_api.fdu.onboard(fdu_desc) - instanceid = self.fos_api.fdu.instantiate(fdu_uuid, selected_node.get('uuid')) - created_items.update({'instance_id':instanceid}) - - self.fdu_node_map.update({instanceid: selected_node.get('uuid')}) - self.logger.debug('new_vminstance return: {}'.format((fdu_uuid, created_items))) - return (instanceid, created_items) - except fimerrors.FIMAResouceExistingException as free: - raise vimconn.vimconnConflictException("VM already exists at VIM. Error {}".format(free)) + self.fos_api.fdu.onboard(fdu) + instance = self.fos_api.fdu.define(fdu_uuid) + instance_list = self.fos_api.fdu.instance_list(fdu_uuid) + selected_node = '' + for n in instance_list: + instances = instance_list[n] + if instance.uuid in instances: + selected_node = n + if selected_node == '': + raise ValueError("Unable to find node for network creation") + + self.logger.debug('Selected node by VIM: {}'.format(selected_node)) + created_items['fdu_id'] = fdu_uuid + created_items['node_id'] = selected_node + + for cp in fdu_desc['connection_points']: + nets = self.fos_api.network.list() + for net in nets: + if net.get('uuid') == cp['vld_ref']: + self.fos_api.network.add_network_to_node(net, selected_node) + + self.fos_api.fdu.configure(instance.uuid) + self.fos_api.fdu.start(instance.uuid) + + self.logger.debug('Eclipse fog05 FDU Started {}'.format(instance.uuid)) + + created_items['instance_id'] = str(instance.uuid) + + self.fdu_node_map[instance.uuid] = selected_node + self.logger.debug('new_vminstance returns: {} {}'.format(instance.uuid, created_items)) + return str(instance.uuid), created_items + except fimapi.FIMAResouceExistingException as free: + raise vimconn.VimConnConflictException("VM already exists at VIM. Error {}".format(free)) except Exception as e: - raise vimconn.vimconnException("Error while instantiating VM {}. Error {}".format(name, e)) - + raise vimconn.VimConnException("Error while instantiating VM {}. Error {}".format(name, e)) - def get_vminstance(self,vm_id): + def get_vminstance(self, vm_id): """Returns the VM instance information from VIM""" self.logger.debug('VIM get_vminstance with args: {}'.format(locals())) try: - intsinfo = self.fos_api.fdu.instance_info(vm_id) + instance = self.fos_api.fdu.instance_info(vm_id) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) - if intsinfo is None: - raise vimconn.vimconnNotFoundException('VM with id {} not found!'.format(vm_id)) - return intsinfo - + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) + if instance is None: + raise vimconn.VimConnNotFoundException('VM with id {} not found!'.format(vm_id)) + return instance.to_json() def delete_vminstance(self, vm_id, created_items=None): """ @@ -677,15 +638,35 @@ class vimconnector(vimconn.vimconnector): :return: None or the same vm_id. Raises an exception on fail """ self.logger.debug('FOS delete_vminstance with args: {}'.format(locals())) - fduid = created_items.get('fdu_id') + fduid = created_items.get('fdu_id') try: - self.fos_api.fdu.terminate(vm_id) + instance = self.fos_api.fdu.instance_info(vm_id) + instance_list = self.fos_api.fdu.instance_list(instance.fdu_id) + selected_node = '' + for n in instance_list: + instances = instance_list[n] + if instance.uuid in instances: + selected_node = n + if selected_node == '': + raise ValueError("Unable to find node for the given Instance") + + self.fos_api.fdu.stop(vm_id) + + for cp in instance.to_json()['connection_points']: + nets = self.fos_api.network.list() + for net in nets: + if net.get('uuid') == cp['vld_ref']: + self.fos_api.network.remove_network_from_node(net.get('uuid'), selected_node) + + self.fos_api.fdu.clean(vm_id) + self.fos_api.fdu.undefine(vm_id) + self.fos_api.fdu.offload(fduid) except Exception as e: - raise vimconn.vimconnException("Error on deletting VM with id {}. Error {}".format(vm_id,e)) + raise vimconn.VimConnException("Error on deleting VM with id {}. Error {}".format(vm_id, e)) return vm_id - #raise vimconnNotImplemented( "Should have implemented this" ) + # raise VimConnNotImplemented( "Should have implemented this" ) def refresh_vms_status(self, vm_list): """Get the status of the virtual machines and their interfaces/ports @@ -715,11 +696,11 @@ class vimconnector(vimconn.vimconnector): """ self.logger.debug('FOS refresh_vms_status with args: {}'.format(locals())) fos2osm_status = { - 'DEFINE':'OTHER', - 'CONFIGURE':'INACTIVE', - 'RUN':'ACTIVE', - 'PAUSE':'PAUSED', - 'ERROR':'ERROR' + 'DEFINE': 'OTHER', + 'CONFIGURE': 'INACTIVE', + 'RUN': 'ACTIVE', + 'PAUSE': 'PAUSED', + 'ERROR': 'ERROR' } r = {} @@ -730,42 +711,46 @@ class vimconnector(vimconn.vimconnector): info = {} nid = self.fdu_node_map.get(vm) if nid is None: - r.update({vm:{ - 'status':'VIM_ERROR', - 'error_msg':'Not compute node associated for VM' - }}) + r[vm] = { + 'status': 'VIM_ERROR', + 'error_msg': 'Not compute node associated for VM' + } continue try: vm_info = self.fos_api.fdu.instance_info(vm) - except: - r.update({vm:{ - 'status':'VIM_ERROR', - 'error_msg':'unable to connect to VIM' - }}) + except Exception: + r[vm] = { + 'status': 'VIM_ERROR', + 'error_msg': 'unable to connect to VIM' + } continue if vm_info is None: - r.update({vm:{'status':'DELETED'}}) + r[vm:] = {'status': 'DELETED'} continue + desc = self.fos_api.fdu.info(str(vm_info.fdu_id)) + + vm_info = vm_info.to_json() + desc = desc.to_json() - desc = self.fos_api.fdu.info(vm_info['fdu_uuid']) osm_status = fos2osm_status.get(vm_info.get('status')) self.logger.debug('FOS status info {}'.format(vm_info)) self.logger.debug('FOS status is {} <-> OSM Status {}'.format(vm_info.get('status'), osm_status)) - info.update({'status':osm_status}) + info['status'] = osm_status if vm_info.get('status') == 'ERROR': - info.update({'error_msg':vm_info.get('error_code')}) - info.update({'vim_info':yaml.safe_dump(vm_info)}) + info['error_msg'] = vm_info.get('error_code') + # yaml.safe_dump(json.loads(json.dumps(vm_info))) + # info['vim_info'] = '' faces = [] i = 0 - for intf_name in vm_info.get('hypervisor_info').get('network',[]): + for intf_name in vm_info.get('hypervisor_info').get('network', []): intf_info = vm_info.get('hypervisor_info').get('network').get(intf_name) face = {} face['compute_node'] = nid - face['vim_info'] = yaml.safe_dump(intf_info) + # face['vim_info'] = '' #yaml.safe_dump(json.loads(json.dumps(intf_info))) face['mac_address'] = intf_info.get('hwaddr') addrs = [] for a in intf_info.get('addresses'): @@ -775,18 +760,18 @@ class vimconnector(vimconn.vimconnector): else: face['ip_address'] = '' face['pci'] = '0:0:0.0' - # getting net id by CP + try: cp_info = vm_info.get('connection_points')[i] except IndexError: cp_info = None if cp_info is not None: - cp_id = cp_info['cp_uuid'] + cp_id = cp_info['cp_id'] cps_d = desc['connection_points'] - matches = [x for x in cps_d if x['uuid'] == cp_id] + matches = [x for x in cps_d if x['id'] == cp_id] if len(matches) > 0: cpd = matches[0] - face['vim_net_id'] = cpd.get('pair_id','') + face['vim_net_id'] = cpd.get('vld_ref', '') else: face['vim_net_id'] = '' face['vim_interface_id'] = cp_id @@ -797,17 +782,12 @@ class vimconnector(vimconn.vimconnector): faces.append(face) i += 1 - - - info.update({'interfaces':faces}) - r.update({vm:info}) + info['interfaces'] = faces + r[vm] = info self.logger.debug('FOS refresh_vms_status res for {} is {}'.format(vm, info)) self.logger.debug('FOS refresh_vms_status res is {}'.format(r)) return r - - #raise vimconnNotImplemented( "Should have implemented this" ) - def action_vminstance(self, vm_id, action_dict, created_items={}): """ Send and action over a VM instance. Returns created_items if the action was successfully sent to the VIM. @@ -823,56 +803,62 @@ class vimconnector(vimconn.vimconnector): self.logger.debug('VIM action_vminstance with args: {}'.format(locals())) nid = self.fdu_node_map.get(vm_id) if nid is None: - raise vimconn.vimconnNotFoundException('No node for this VM') + raise vimconn.VimConnNotFoundException('No node for this VM') try: - fdu_info = self.fos_api.fdu.instance_info(vm_id) + instance = self.fos_api.fdu.instance_info(vm_id) if "start" in action_dict: - if fdu_info.get('status') == 'CONFIGURE': + if instance.get('status') == 'CONFIGURE': self.fos_api.fdu.start(vm_id) - elif fdu_info.get('status') == 'PAUSE': + elif instance.get('status') == 'PAUSE': self.fos_api.fdu.resume(vm_id) else: - raise vimconn.vimconnConflictException("Cannot start from this state") + raise vimconn.VimConnConflictException('Cannot start from current state: {}'.format( + instance.get('status'))) elif "pause" in action_dict: - if fdu_info.get('status') == 'RUN': + if instance.get('status') == 'RUN': self.fos_api.fdu.pause(vm_id) else: - raise vimconn.vimconnConflictException("Cannot pause from this state") + raise vimconn.VimConnConflictException('Cannot pause from current state: {}'.format( + instance.get('status'))) elif "resume" in action_dict: - if fdu_info.get('status') == 'PAUSE': + if instance.get('status') == 'PAUSE': self.fos_api.fdu.resume(vm_id) else: - raise vimconn.vimconnConflictException("Cannot resume from this state") + raise vimconn.VimConnConflictException('Cannot resume from current state: {}'.format( + instance.get('status'))) elif "shutoff" in action_dict or "shutdown" or "forceOff" in action_dict: - if fdu_info.get('status') == 'RUN': + if instance.get('status') == 'RUN': self.fos_api.fdu.stop(vm_id) else: - raise vimconn.vimconnConflictException("Cannot shutoff from this state") + raise vimconn.VimConnConflictException('Cannot shutoff from current state: {}'.format( + instance.get('status'))) elif "terminate" in action_dict: - if fdu_info.get('status') == 'RUN': + if instance.get('status') == 'RUN': self.fos_api.fdu.stop(vm_id) self.fos_api.fdu.clean(vm_id) self.fos_api.fdu.undefine(vm_id) # self.fos_api.fdu.offload(vm_id) - elif fdu_info.get('status') == 'CONFIGURE': + elif instance.get('status') == 'CONFIGURE': self.fos_api.fdu.clean(vm_id) self.fos_api.fdu.undefine(vm_id) # self.fos_api.fdu.offload(vm_id) - elif fdu_info.get('status') == 'PAUSE': + elif instance.get('status') == 'PAUSE': self.fos_api.fdu.resume(vm_id) self.fos_api.fdu.stop(vm_id) self.fos_api.fdu.clean(vm_id) self.fos_api.fdu.undefine(vm_id) # self.fos_api.fdu.offload(vm_id) else: - raise vimconn.vimconnConflictException("Cannot terminate from this state") + raise vimconn.VimConnConflictException('Cannot terminate from current state: {}'.format( + instance.get('status'))) elif "rebuild" in action_dict: - raise vimconnNotImplemented("Rebuild not implememnted") + raise vimconn.VimConnNotImplemented("Rebuild not implemented") elif "reboot" in action_dict: - if fdu_info.get('status') == 'RUN': + if instance.get('status') == 'RUN': self.fos_api.fdu.stop(vm_id) self.fos_api.fdu.start(vm_id) else: - raise vimconn.vimconnConflictException("Cannot reboot from this state") + raise vimconn.VimConnConflictException('Cannot reboot from current state: {}'.format( + instance.get('status'))) except Exception as e: - raise vimconn.vimconnConnectionException("VIM not reachable. Error {}".format(e)) + raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e))