| # -*- coding: utf-8 -*- |
| |
| ## |
| # Copyright 2020 ADLINK Technology Inc. |
| # This file is part of ETSI OSM |
| # All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may |
| # not use this file except in compliance with the License. You may obtain |
| # a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations |
| # under the License. |
| # |
| # |
| |
| """ |
| 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: |
| - arch : cpu architecture for the VIM |
| - hypervisor: virtualization technology supported by the VIM, can |
| can be one of: LXD, KVM, BARE, XEN, DOCKER, MCU |
| the selected VIM need to have at least a node with support |
| for the selected hypervisor |
| |
| """ |
| |
| import uuid |
| import socket |
| import struct |
| from osm_ro_plugin import vimconn |
| # import json |
| from functools import partial |
| 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): |
| 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 |
| Params: |
| 'uuid': id asigned to this VIM |
| 'name': name assigned to this VIM, can be used for logging |
| 'tenant_id', 'tenant_name': (only one of them is mandatory) VIM tenant to be used |
| 'url_admin': (optional), url used for administrative tasks |
| 'user', 'passwd': credentials of the VIM user |
| 'log_level': provider if it should use a different log_level than the general one |
| 'config': dictionary with extra VIM information. This contains a consolidate version of general VIM config |
| at creation and particular VIM config at teh attachment |
| 'persistent_info': dict where the class can store information that will be available among class |
| destroy/creation cycles. This info is unique per VIM/credential. At first call it will contain an |
| empty dict. Useful to store login/tokens information for speed up communication |
| |
| Returns: Raise an exception is some needed parameter is missing, but it must not do any connectivity |
| check against the VIM |
| """ |
| |
| 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)) |
| self.arch = config.get('arch', 'x86_64') |
| self.hv = config.get('hypervisor', 'LXD') |
| self.nodes = config.get('nodes', []) |
| 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 |
| last = socket.inet_ntoa(struct.pack('!L', int_last)) |
| return (first, last) |
| |
| def __name_filter(self, desc, filter_name=None): |
| if filter_name is None: |
| return True |
| return desc.get('name') == filter_name |
| |
| def __id_filter(self, desc, filter_id=None): |
| if filter_id is None: |
| return True |
| return desc.get('uuid') == filter_id |
| |
| def __checksum_filter(self, desc, filter_checksum=None): |
| if filter_checksum is None: |
| return True |
| return desc.get('checksum') == filter_checksum |
| |
| def check_vim_connectivity(self): |
| """Checks VIM can be reached and user credentials are ok. |
| Returns None if success or raised VimConnConnectionException, VimConnAuthException, ... |
| """ |
| try: |
| self.fos_api.node.list() |
| return None |
| 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)) |
| |
| 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 |
| 'net_type': one of: |
| 'bridge': overlay isolated network |
| 'data': underlay E-LAN network for Passthrough and SRIOV interfaces |
| 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces. |
| 'ip_profile': is a dict containing the IP parameters of the network |
| 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented) |
| 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y |
| 'gateway_address': (Optional) ip_schema, that is X.X.X.X |
| 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X] |
| 'dhcp_enabled': True or False |
| '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 |
| 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)) |
| |
| net_uuid = '{}'.format(uuid.uuid4()) |
| desc = { |
| '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['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['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 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, {} |
| |
| def get_network_list(self, filter_dict={}): |
| """Obtain tenant networks of VIM |
| :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 |
| 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER' |
| 'network_type': (optional) can be 'vxlan', 'vlan' or 'flat' |
| 'segmentation_id': (optional) in case network_type is vlan or vxlan this field contains the segmentation id |
| 'error_msg': (optional) text that explains the ERROR status |
| other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param |
| List can be empty if no network map the filter_dict. Raise an exception only upon VIM connectivity, |
| authorization, or some other unspecific error |
| """ |
| self.logger.debug('get_network_list: {}'.format(filter_dict)) |
| res = [] |
| 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)) |
| |
| filters = [ |
| partial(self.__name_filter, filter_name=filter_dict.get('name')), |
| partial(self.__id_filter, filter_id=filter_dict.get('id')) |
| ] |
| |
| r1 = [] |
| |
| for n in nets: |
| match = True |
| for f in filters: |
| match = match and f(n) |
| if match: |
| r1.append(n) |
| |
| for n in r1: |
| osm_net = { |
| 'id': n.get('uuid'), |
| 'name': n.get('name'), |
| 'status': 'ACTIVE' |
| } |
| res.append(osm_net) |
| return res |
| |
| def get_network(self, net_id): |
| """Obtain network details from the 'net_id' VIM network |
| Return a dict that contains: |
| 'id': (mandatory) VIM network id, that is, net_id |
| 'name': (mandatory) VIM network name |
| 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER' |
| 'error_msg': (optional) text that explains the ERROR status |
| other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param |
| 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}) |
| if len(res) == 0: |
| raise vimconn.VimConnNotFoundException("Network {} not found at VIM".format(net_id)) |
| return res[0] |
| |
| def delete_network(self, net_id, created_items=None): |
| """Deletes a tenant network from VIM |
| Returns the network identifier or raises an exception upon error or when network is not found |
| """ |
| self.logger.debug('delete_network: {}'.format(net_id)) |
| try: |
| self.fos_api.network.remove_network(net_id) |
| 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)) |
| return net_id |
| |
| def refresh_nets_status(self, net_list): |
| """Get the status of the networks |
| Params: |
| 'net_list': a list with the VIM network id to be get the status |
| Returns a dictionary with: |
| 'net_id': #VIM id of this network |
| status: #Mandatory. Text with one of: |
| # DELETED (not found at vim) |
| # VIM_ERROR (Cannot connect to VIM, authentication problems, VIM response error, ...) |
| # OTHER (Vim reported other status not understood) |
| # ERROR (VIM indicates an ERROR status) |
| # ACTIVE, INACTIVE, DOWN (admin down), |
| # BUILD (on building process) |
| 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_id2': ... |
| """ |
| self.logger.debug('Refeshing network status with args: {}'.format(locals())) |
| r = {} |
| for n in net_list: |
| try: |
| osm_n = self.get_network(n) |
| 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): |
| """Obtain flavor details from the VIM |
| Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } |
| Raises an exception upon error or if not found |
| """ |
| self.logger.debug('VIM get_flavor with args: {}'.format(locals())) |
| try: |
| r = self.fos_api.flavor.get(flavor_id) |
| except Exception as 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} |
| |
| def get_flavor_id_from_data(self, flavor_dict): |
| """Obtain flavor id that match the flavor description |
| Params: |
| 'flavor_dict': dictionary that contains: |
| 'disk': main hard disk in GB |
| 'ram': meomry in MB |
| 'vcpus': number of virtual cpus |
| #TODO: complete parameters for EPA |
| Returns the flavor_id or raises a vimconnNotFoundException |
| """ |
| self.logger.debug('VIM get_flavor_id_from_data with args : {}'.format(locals())) |
| |
| 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'))] |
| if len(r) == 0: |
| raise vimconn.VimConnNotFoundException("No flavor found") |
| return r[0] |
| |
| def new_flavor(self, flavor_data): |
| """Adds a tenant flavor to VIM |
| flavor_data contains a dictionary with information, keys: |
| name: flavor name |
| ram: memory (cloud type) in MBytes |
| 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 |
| - 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 |
| vpci: requested virtual PCI address |
| disk: disk size |
| is_public: |
| #TODO to concrete |
| Returns the flavor identifier""" |
| self.logger.debug('VIM new_flavor with args: {}'.format(locals())) |
| flv_id = '{}'.format(uuid.uuid4()) |
| desc = { |
| 'uuid': flv_id, |
| 'name': flavor_data.get('name'), |
| 'cpu_arch': self.arch, |
| 'cpu_min_count': flavor_data.get('vcpus'), |
| '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 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)) |
| 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 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)) |
| return flavor_id |
| |
| def new_image(self, image_dict): |
| """ Adds a tenant image to VIM. imge_dict is a dictionary with: |
| name: name |
| disk_format: qcow2, vhd, vmdk, raw (by default), ... |
| location: path or URI |
| public: "yes" or "no" |
| metadata: metadata of the image |
| Returns the image id or raises an exception if failed |
| """ |
| 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'), |
| 'format': image_dict.get('disk_format') |
| } |
| try: |
| self.fos_api.image.add(desc) |
| 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)) |
| return img_id |
| |
| def get_image_id_from_path(self, path): |
| |
| """Get the image id from image path in the VIM database. |
| Returns the image_id or raises a vimconnNotFoundException |
| """ |
| self.logger.debug('VIM get_image_id_from_path with args: {}'.format(locals())) |
| 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] |
| if len(res) == 0: |
| raise vimconn.VimConnNotFoundException("Image with this path was not found") |
| return res[0] |
| |
| def get_image_list(self, filter_dict={}): |
| """Obtain tenant images from VIM |
| Filter_dict can be: |
| name: image name |
| id: image uuid |
| checksum: image checksum |
| location: image path |
| Returns the image list of dictionaries: |
| [{<the fields at Filter_dict plus some VIM specific>}, ...] |
| List can be empty |
| """ |
| self.logger.debug('VIM get_image_list args: {}'.format(locals())) |
| r = [] |
| try: |
| fimgs = self.fos_api.image.list() |
| except Exception as 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')) |
| ] |
| |
| r1 = [] |
| |
| for i in fimgs: |
| match = True |
| for f in filters: |
| match = match and f(i) |
| if match: |
| r1.append(i) |
| |
| for i in r1: |
| img_info = { |
| '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" ) |
| |
| 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 |
| :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 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)) |
| if img is None: |
| raise vimconn.VimConnNotFoundException("Image {} not found at VIM".format(image_id)) |
| |
| created_items = { |
| 'fdu_id': '', |
| 'node_id': '', |
| 'connection_points': [] |
| } |
| |
| fdu_desc = { |
| '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 = [] |
| cps = [] |
| intf_id = 0 |
| for n in net_list: |
| cp_id = '{}'.format(uuid.uuid4()) |
| n['vim_id'] = cp_id |
| pair_id = n.get('net_id') |
| |
| cp_d = { |
| '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)) |
| }, |
| 'cp_id': cp_id |
| } |
| if n.get('mac_address', None) is not None: |
| intf_d['mac_address'] = n['mac_address'] |
| |
| created_items['connection_points'].append(cp_id) |
| fdu_desc['connection_points'].append(cp_d) |
| fdu_desc['interfaces'].append(intf_d) |
| |
| intf_id = intf_id + 1 |
| |
| if cloud_config is not None: |
| configuration = {'conf_type': 'CLOUD_INIT'} |
| if cloud_config.get('user-data') is not None: |
| configuration['script'] = cloud_config.get('user-data') |
| if cloud_config.get('key-pairs') is not None: |
| configuration['ssh_keys'] = cloud_config.get('key-pairs') |
| |
| if 'script' in configuration: |
| fdu_desc['configuration'] = configuration |
| |
| self.logger.debug('Eclipse fog05 FDU Descriptor: {}'.format(fdu_desc)) |
| |
| fdu = FDU(fdu_desc) |
| |
| try: |
| 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)) |
| |
| def get_vminstance(self, vm_id): |
| """Returns the VM instance information from VIM""" |
| self.logger.debug('VIM get_vminstance with args: {}'.format(locals())) |
| |
| try: |
| instance = self.fos_api.fdu.instance_info(vm_id) |
| except Exception as e: |
| 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): |
| """ |
| Removes a VM instance from VIM and each associate elements |
| :param vm_id: VIM identifier of the VM, provided by method new_vminstance |
| :param created_items: dictionary with extra items to be deleted. provided by method new_vminstance and/or method |
| action_vminstance |
| :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') |
| try: |
| 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 deleting VM with id {}. Error {}".format(vm_id, e)) |
| return vm_id |
| |
| # raise VimConnNotImplemented( "Should have implemented this" ) |
| |
| def refresh_vms_status(self, vm_list): |
| """Get the status of the virtual machines and their interfaces/ports |
| Params: the list of VM identifiers |
| Returns a dictionary with: |
| vm_id: #VIM id of this Virtual Machine |
| status: #Mandatory. Text with one of: |
| # DELETED (not found at vim) |
| # VIM_ERROR (Cannot connect to VIM, VIM response error, ...) |
| # OTHER (Vim reported other status not understood) |
| # ERROR (VIM indicates an ERROR status) |
| # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running), |
| # BUILD (on building process), ERROR |
| # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address |
| # |
| 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) |
| interfaces: list with interface info. Each item a dictionary with: |
| vim_info: #Text with plain information obtained from vim (yaml.safe_dump) |
| mac_address: #Text format XX:XX:XX:XX:XX:XX |
| vim_net_id: #network id where this interface is connected, if provided at creation |
| vim_interface_id: #interface/port VIM id |
| ip_address: #null, or text with IPv4, IPv6 address |
| compute_node: #identification of compute node where PF,VF interface is allocated |
| pci: #PCI address of the NIC that hosts the PF,VF |
| vlan: #physical VLAN used for VF |
| """ |
| self.logger.debug('FOS refresh_vms_status with args: {}'.format(locals())) |
| fos2osm_status = { |
| 'DEFINE': 'OTHER', |
| 'CONFIGURE': 'INACTIVE', |
| 'RUN': 'ACTIVE', |
| 'PAUSE': 'PAUSED', |
| 'ERROR': 'ERROR' |
| } |
| |
| r = {} |
| |
| for vm in vm_list: |
| self.logger.debug('FOS refresh_vms_status for {}'.format(vm)) |
| |
| info = {} |
| nid = self.fdu_node_map.get(vm) |
| if nid is None: |
| 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 Exception: |
| r[vm] = { |
| 'status': 'VIM_ERROR', |
| 'error_msg': 'unable to connect to VIM' |
| } |
| continue |
| |
| if vm_info is None: |
| 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() |
| |
| 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['status'] = osm_status |
| if vm_info.get('status') == 'ERROR': |
| 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', []): |
| intf_info = vm_info.get('hypervisor_info').get('network').get(intf_name) |
| face = {} |
| face['compute_node'] = nid |
| # 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'): |
| addrs.append(a.get('address')) |
| if len(addrs) >= 0: |
| face['ip_address'] = ','.join(addrs) |
| else: |
| face['ip_address'] = '' |
| face['pci'] = '0:0:0.0' |
| |
| 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_id'] |
| cps_d = desc['connection_points'] |
| 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('vld_ref', '') |
| else: |
| face['vim_net_id'] = '' |
| face['vim_interface_id'] = cp_id |
| # cp_info.get('uuid') |
| else: |
| face['vim_net_id'] = '' |
| face['vim_interface_id'] = intf_name |
| faces.append(face) |
| i += 1 |
| |
| 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 |
| |
| 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. |
| created_items is a dictionary with items that |
| :param vm_id: VIM identifier of the VM, provided by method new_vminstance |
| :param action_dict: dictionary with the action to perform |
| :param created_items: provided by method new_vminstance is a dictionary with key-values that will be passed to |
| the method delete_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. This |
| method can modify this value |
| :return: None, or a console dict |
| """ |
| 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') |
| try: |
| instance = self.fos_api.fdu.instance_info(vm_id) |
| if "start" in action_dict: |
| if instance.get('status') == 'CONFIGURE': |
| self.fos_api.fdu.start(vm_id) |
| elif instance.get('status') == 'PAUSE': |
| self.fos_api.fdu.resume(vm_id) |
| else: |
| raise vimconn.VimConnConflictException('Cannot start from current state: {}'.format( |
| instance.get('status'))) |
| elif "pause" in action_dict: |
| if instance.get('status') == 'RUN': |
| self.fos_api.fdu.pause(vm_id) |
| else: |
| raise vimconn.VimConnConflictException('Cannot pause from current state: {}'.format( |
| instance.get('status'))) |
| elif "resume" in action_dict: |
| if instance.get('status') == 'PAUSE': |
| self.fos_api.fdu.resume(vm_id) |
| else: |
| 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 instance.get('status') == 'RUN': |
| self.fos_api.fdu.stop(vm_id) |
| else: |
| raise vimconn.VimConnConflictException('Cannot shutoff from current state: {}'.format( |
| instance.get('status'))) |
| elif "terminate" in action_dict: |
| 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 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 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 current state: {}'.format( |
| instance.get('status'))) |
| elif "rebuild" in action_dict: |
| raise vimconn.VimConnNotImplemented("Rebuild not implemented") |
| elif "reboot" in action_dict: |
| 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 current state: {}'.format( |
| instance.get('status'))) |
| except Exception as e: |
| raise vimconn.VimConnConnectionException("VIM not reachable. Error {}".format(e)) |