| # -*- 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 logging |
| 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 = logging.getLogger("ro.vim.fos") |
| 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) |
| ) |