X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=RO-VIM-fos%2Fosm_rovim_fos%2Fvimconn_fos.py;h=8f946338f79db61f1a679529735cf1a1b3e4585a;hb=0ee9fdb5561e12852cc93a6b13ed237cee039e07;hp=90b0e7ecf0f56b0f86e0fb242a2341fc87dd41b2;hpb=7d782eff123e5b44d41437377ccca66ad1e8b21b;p=osm%2FRO.git diff --git a/RO-VIM-fos/osm_rovim_fos/vimconn_fos.py b/RO-VIM-fos/osm_rovim_fos/vimconn_fos.py index 90b0e7ec..8f946338 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,23 +31,38 @@ Support config dict: for the selected hypervisor """ -__author__="Gabriele Baldoni" -__date__ ="$13-may-2019 10:35:12$" +import logging import uuid import socket import struct -from . import vimconn -import random -import yaml -from functools import partial -from fog05rest import FIMAPI -from fog05rest import fimerrors - +from osm_ro_plugin import vimconn -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={}): +# 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 @@ -65,52 +80,79 @@ class vimconnector(vimconn.vimconnector): 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', []) + 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_first = struct.unpack("!L", socket.inet_aton(first))[0] int_last = int_first + count - last = socket.inet_ntoa(struct.pack('!L', int_last)) + 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 + + 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 + + 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 + + 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, ... + 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)) - - def new_network(self, net_name, net_type, ip_profile=None, shared=False, vlan=None): + 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 @@ -127,56 +169,74 @@ class vimconnector(vimconn.vimconnector): 'dhcp_start_address': ip_schema, first IP to grant 'dhcp_count': number of IPs to grant. 'shared': if this network can be seen/use by other tenants/organization - 'vlan': in case of a data or ptp net_type, the intended vlan tag to be used for the network 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)) + self.logger.debug("new_network: {}".format(locals())) - net_uuid = '{}'.format(uuid.uuid4()) + 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': + 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}) + 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.update({'ip_configuration':ip}) - self.logger.debug('VIM new_network args: {} - Generated Eclipse fog05 Descriptor {}'.format(locals(), desc)) + 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 @@ -188,34 +248,36 @@ class vimconnector(vimconn.vimconnector): 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)) + 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)) + 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.__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' - } + osm_net = {"id": n.get("uuid"), "name": n.get("name"), "status": "ACTIVE"} res.append(osm_net) + return res def get_network(self, net_id): @@ -228,23 +290,35 @@ class vimconnector(vimconn.vimconnector): 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}) + 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)) + raise vimconn.VimConnNotFoundException( + "Network {} not found at VIM".format(net_id) + ) + return res[0] - def delete_network(self, net_id): + 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)) + 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): @@ -264,18 +338,16 @@ class vimconnector(vimconn.vimconnector): vim_info: #Text with plain information obtained from vim (yaml.safe_dump) 'net_id2': ... """ - self.logger.debug('Refeshing network status with args: {}'.format(locals())) + self.logger.debug("Refeshing network status with args: {}".format(locals())) r = {} + 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): @@ -283,14 +355,19 @@ class vimconnector(vimconn.vimconnector): 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())) + 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)) + 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 @@ -302,15 +379,28 @@ class vimconnector(vimconn.vimconnector): #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())) + 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'))] + 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): @@ -321,9 +411,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 @@ -332,39 +422,51 @@ class vimconnector(vimconn.vimconnector): is_public: #TODO to concrete Returns the flavor identifier""" - self.logger.debug('VIM new_flavor with args: {}'.format(locals())) - flv_id = '{}'.format(uuid.uuid4()) + 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.0, - 'ram_size_mb':float(flavor_data.get('ram')), - 'storage_size_gb':float(flavor_data.get('disk')) + "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 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)) - return flv_id + 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): - """ Adds a tenant image to VIM. imge_dict is a dictionary with: + """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 @@ -372,34 +474,46 @@ class vimconnector(vimconn.vimconnector): 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()) + 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): - """Get the image id from image path in the VIM database. - Returns the image_id or raises a vimconnNotFoundException + Returns the image_id or raises a vimconnNotFoundException """ - self.logger.debug('VIM get_image_id_from_path with args: {}'.format(locals())) + 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] + 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={}): @@ -413,261 +527,261 @@ class vimconnector(vimconn.vimconnector): [{}, ...] List can be empty """ - self.logger.debug('VIM get_image_list args: {}'.format(locals())) + 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)) + 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.__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 + "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): + 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 - 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())) - fdu_uuid = '{}'.format(uuid.uuid4()) + 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 = [] cps = [] intf_id = 0 for n in net_list: - cp_id = '{}'.format(uuid.uuid4()) - n.update({'vim_id':cp_id}) - pair_id = n.get('net_id') + cp_id = "{}".format(uuid.uuid4()) + 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'] + 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) + 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.update({'script':cloud_config.get('user-data')}) - if cloud_config.get('key-pairs') is not None: - configuration.update({'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) + configuration = {"conf_type": "CLOUD_INIT"} + if cloud_config.get("user-data") is not None: + configuration["script"] = cloud_config.get("user-data") - # 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) + if cloud_config.get("key-pairs") is not None: + configuration["ssh_keys"] = cloud_config.get("key-pairs") - if len(compatible_nodes) == 0: - raise vimconn.vimconnConflictException("No available nodes at VIM") - selected_node = random.choice(compatible_nodes) + if "script" in configuration: + fdu_desc["configuration"] = configuration - created_items.update({'fdu_id':fdu_uuid, 'node_id': selected_node.get('uuid')}) + self.logger.debug("Eclipse fog05 FDU Descriptor: {}".format(fdu_desc)) - 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())) + 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,138 +791,179 @@ class vimconnector(vimconn.vimconnector): 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') + self.logger.debug("FOS delete_vminstance with args: {}".format(locals())) + 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 - 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 + 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())) + 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 = {} for vm in vm_list: - self.logger.debug('FOS refresh_vms_status for {}'.format(vm)) + self.logger.debug("FOS refresh_vms_status for {}".format(vm)) 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')) + 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}) - if vm_info.get('status') == 'ERROR': - info.update({'error_msg':vm_info.get('error_code')}) - info.update({'vim_info':yaml.safe_dump(vm_info)}) + 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) + 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['mac_address'] = intf_info.get('hwaddr') + 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')) + + for a in intf_info.get("addresses"): + addrs.append(a.get("address")) + if len(addrs) >= 0: - face['ip_address'] = ','.join(addrs) + face["ip_address"] = ",".join(addrs) else: - face['ip_address'] = '' - face['pci'] = '0:0:0.0' - # getting net id by CP + face["ip_address"] = "" + + face["pci"] = "0:0:0.0" + try: - cp_info = vm_info.get('connection_points')[i] + 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'] - cps_d = desc['connection_points'] - matches = [x for x in cps_d if x['uuid'] == cp_id] + 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('pair_id','') + face["vim_net_id"] = cpd.get("vld_ref", "") else: - face['vim_net_id'] = '' - face['vim_interface_id'] = cp_id - # cp_info.get('uuid') + 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 + 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)) - info.update({'interfaces':faces}) - r.update({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. @@ -821,59 +976,87 @@ class vimconnector(vimconn.vimconnector): method can modify this value :return: None, or a console dict """ - self.logger.debug('VIM action_vminstance with args: {}'.format(locals())) + 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) + )