X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=RO-plugin%2Fosm_ro_plugin%2Fvimconn.py;h=b251d5982e7e01d1fa39e7ec3a60bd333e96e2b9;hb=HEAD;hp=dd60e464c0e8cb23f09ad05e0daf234baf55dd95;hpb=7277486065c905f91477bb064da86855a8fa269a;p=osm%2FRO.git diff --git a/RO-plugin/osm_ro_plugin/vimconn.py b/RO-plugin/osm_ro_plugin/vimconn.py index dd60e464..a46f581a 100644 --- a/RO-plugin/osm_ro_plugin/vimconn.py +++ b/RO-plugin/osm_ro_plugin/vimconn.py @@ -26,17 +26,19 @@ vimconn implement an Abstract class for the vim connector plugins with the definition of the method to be implemented. """ -import logging -import paramiko -import socket -from io import StringIO -import yaml -import sys from email.mime.multipart import MIMEMultipart from email.mime.text import MIMEText from http import HTTPStatus +from io import StringIO +import logging +import socket +import sys +import traceback import warnings +import paramiko +import yaml + __author__ = "Alfonso Tierno, Igor D.C." __date__ = "$14-aug-2017 23:59:59$" @@ -44,12 +46,17 @@ __date__ = "$14-aug-2017 23:59:59$" def deprecated(message): def deprecated_decorator(func): def deprecated_func(*args, **kwargs): - warnings.warn("{} is a deprecated function. {}".format(func.__name__, message), - category=DeprecationWarning, - stacklevel=2) - warnings.simplefilter('default', DeprecationWarning) + warnings.warn( + "{} is a deprecated function. {}".format(func.__name__, message), + category=DeprecationWarning, + stacklevel=2, + ) + warnings.simplefilter("default", DeprecationWarning) + return func(*args, **kwargs) + return deprecated_func + return deprecated_decorator @@ -67,6 +74,7 @@ HTTP_Internal_Server_Error = HTTPStatus.INTERNAL_SERVER_ERROR.value class VimConnException(Exception): """Common and base class Exception for all VimConnector exceptions""" + def __init__(self, message, http_code=HTTP_Bad_Request): Exception.__init__(self, message) self.http_code = http_code @@ -74,53 +82,80 @@ class VimConnException(Exception): class VimConnConnectionException(VimConnException): """Connectivity error with the VIM""" + def __init__(self, message, http_code=HTTP_Service_Unavailable): VimConnException.__init__(self, message, http_code) class VimConnUnexpectedResponse(VimConnException): """Get an wrong response from VIM""" + def __init__(self, message, http_code=HTTP_Service_Unavailable): VimConnException.__init__(self, message, http_code) class VimConnAuthException(VimConnException): """Invalid credentials or authorization to perform this action over the VIM""" + def __init__(self, message, http_code=HTTP_Unauthorized): VimConnException.__init__(self, message, http_code) class VimConnNotFoundException(VimConnException): """The item is not found at VIM""" + def __init__(self, message, http_code=HTTP_Not_Found): VimConnException.__init__(self, message, http_code) class VimConnConflictException(VimConnException): """There is a conflict, e.g. more item found than one""" + def __init__(self, message, http_code=HTTP_Conflict): VimConnException.__init__(self, message, http_code) class VimConnNotSupportedException(VimConnException): """The request is not supported by connector""" + def __init__(self, message, http_code=HTTP_Service_Unavailable): VimConnException.__init__(self, message, http_code) class VimConnNotImplemented(VimConnException): - """The method is not implemented by the connected""" + """The method is not implemented by the connector""" + def __init__(self, message, http_code=HTTP_Not_Implemented): VimConnException.__init__(self, message, http_code) -class VimConnector(): +class VimConnInsufficientCredentials(VimConnException): + """The VIM account does not have efficient permissions to perform the requested operation.""" + + def __init__(self, message, http_code=HTTP_Unauthorized): + VimConnException.__init__(self, message, http_code) + + +class VimConnector: """Abstract base class for all the VIM connector plugins These plugins must implement a VimConnector class derived from this and all these privated methods """ - def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None, - config={}, persistent_info={}): + + 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. Raise an exception is some needed parameter is missing, but it must not do any connectivity checking against the VIM @@ -150,28 +185,31 @@ class VimConnector(): self.passwd = passwd self.config = config or {} self.availability_zone = None - self.logger = logging.getLogger('openmano.vim') + self.logger = logging.getLogger("ro.vim") + if log_level: self.logger.setLevel(getattr(logging, log_level)) - if not self.url_admin: # try to use normal url + + if not self.url_admin: # try to use normal url self.url_admin = self.url def __getitem__(self, index): - if index == 'tenant_id': + if index == "tenant_id": return self.tenant_id - if index == 'tenant_name': + + if index == "tenant_name": return self.tenant_name - elif index == 'id': + elif index == "id": return self.id - elif index == 'name': + elif index == "name": return self.name - elif index == 'user': + elif index == "user": return self.user - elif index == 'passwd': + elif index == "passwd": return self.passwd - elif index == 'url': + elif index == "url": return self.url - elif index == 'url_admin': + elif index == "url_admin": return self.url_admin elif index == "config": return self.config @@ -179,21 +217,22 @@ class VimConnector(): raise KeyError("Invalid key '{}'".format(index)) def __setitem__(self, index, value): - if index == 'tenant_id': + if index == "tenant_id": self.tenant_id = value - if index == 'tenant_name': + + if index == "tenant_name": self.tenant_name = value - elif index == 'id': + elif index == "id": self.id = value - elif index == 'name': + elif index == "name": self.name = value - elif index == 'user': + elif index == "user": self.user = value - elif index == 'passwd': + elif index == "passwd": self.passwd = value - elif index == 'url': + elif index == "url": self.url = value - elif index == 'url_admin': + elif index == "url_admin": self.url_admin = value else: raise KeyError("Invalid key '{}'".format(index)) @@ -209,28 +248,32 @@ class VimConnector(): return None elif len(content_list) == 1: return content_list[0] + combined_message = MIMEMultipart() + for content in content_list: - if content.startswith('#include'): - mime_format = 'text/x-include-url' - elif content.startswith('#include-once'): - mime_format = 'text/x-include-once-url' - elif content.startswith('#!'): - mime_format = 'text/x-shellscript' - elif content.startswith('#cloud-config'): - mime_format = 'text/cloud-config' - elif content.startswith('#cloud-config-archive'): - mime_format = 'text/cloud-config-archive' - elif content.startswith('#upstart-job'): - mime_format = 'text/upstart-job' - elif content.startswith('#part-handler'): - mime_format = 'text/part-handler' - elif content.startswith('#cloud-boothook'): - mime_format = 'text/cloud-boothook' + if content.startswith("#include"): + mime_format = "text/x-include-url" + elif content.startswith("#include-once"): + mime_format = "text/x-include-once-url" + elif content.startswith("#!"): + mime_format = "text/x-shellscript" + elif content.startswith("#cloud-config"): + mime_format = "text/cloud-config" + elif content.startswith("#cloud-config-archive"): + mime_format = "text/cloud-config-archive" + elif content.startswith("#upstart-job"): + mime_format = "text/upstart-job" + elif content.startswith("#part-handler"): + mime_format = "text/part-handler" + elif content.startswith("#cloud-boothook"): + mime_format = "text/cloud-boothook" else: # by default - mime_format = 'text/x-shellscript' + mime_format = "text/x-shellscript" + sub_message = MIMEText(content, mime_format, sys.getdefaultencoding()) combined_message.attach(sub_message) + return combined_message.as_string() def _create_user_data(self, cloud_config): @@ -256,55 +299,111 @@ class VimConnector(): config_drive = None userdata = None userdata_list = [] + + # For more information, check https://cloudinit.readthedocs.io/en/latest/reference/merging.html + # Basically, with this, we don't override the provider's cloud config + merge_how = yaml.safe_dump( + { + "merge_how": [ + { + "name": "list", + "settings": ["append", "recurse_dict", "recurse_list"], + }, + { + "name": "dict", + "settings": ["no_replace", "recurse_list", "recurse_dict"], + }, + ] + }, + indent=4, + default_flow_style=False, + ) + if isinstance(cloud_config, dict): - if cloud_config.get("user-data"): - if isinstance(cloud_config["user-data"], str): - userdata_list.append(cloud_config["user-data"]) - else: - for u in cloud_config["user-data"]: - userdata_list.append(u) if cloud_config.get("boot-data-drive") is not None: config_drive = cloud_config["boot-data-drive"] - if cloud_config.get("config-files") or cloud_config.get("users") or cloud_config.get("key-pairs"): - userdata_dict = {} - # default user - if cloud_config.get("key-pairs"): - userdata_dict["ssh-authorized-keys"] = cloud_config["key-pairs"] - userdata_dict["users"] = [{"default": None, "ssh-authorized-keys": cloud_config["key-pairs"]}] - if cloud_config.get("users"): - if "users" not in userdata_dict: - userdata_dict["users"] = ["default"] - for user in cloud_config["users"]: - user_info = { - "name": user["name"], - "sudo": "ALL = (ALL)NOPASSWD:ALL" + # If a config drive is needed, userdata is passed directly + if config_drive: + userdata = cloud_config.get("user-data") + # If a config drive is not necessary, then we process userdata and + # generate MIME multipart + else: + if cloud_config.get("user-data"): + if isinstance(cloud_config["user-data"], str): + userdata_list.append( + cloud_config["user-data"] + f"\n{merge_how}" + ) + else: + for u in cloud_config["user-data"]: + userdata_list.append(u + f"\n{merge_how}") + + if ( + cloud_config.get("config-files") + or cloud_config.get("users") + or cloud_config.get("key-pairs") + ): + userdata_dict = {} + + # default user + if cloud_config.get("key-pairs"): + userdata_dict["ssh-authorized-keys"] = cloud_config["key-pairs"] + userdata_dict["system_info"] = { + "default_user": { + "ssh_authorized_keys": cloud_config["key-pairs"], + } } - if "user-info" in user: - user_info["gecos"] = user["user-info"] - if user.get("key-pairs"): - user_info["ssh-authorized-keys"] = user["key-pairs"] - userdata_dict["users"].append(user_info) - - if cloud_config.get("config-files"): - userdata_dict["write_files"] = [] - for file in cloud_config["config-files"]: - file_info = { - "path": file["dest"], - "content": file["content"] - } - if file.get("encoding"): - file_info["encoding"] = file["encoding"] - if file.get("permissions"): - file_info["permissions"] = file["permissions"] - if file.get("owner"): - file_info["owner"] = file["owner"] - userdata_dict["write_files"].append(file_info) - userdata_list.append("#cloud-config\n" + yaml.safe_dump(userdata_dict, indent=4, - default_flow_style=False)) - userdata = self._create_mimemultipart(userdata_list) - self.logger.debug("userdata: %s", userdata) + userdata_dict["users"] = ["default"] + + if cloud_config.get("users"): + if "users" not in userdata_dict: + userdata_dict["users"] = ["default"] + + for user in cloud_config["users"]: + user_info = { + "name": user["name"], + "sudo": "ALL = (ALL)NOPASSWD:ALL", + } + + if "user-info" in user: + user_info["gecos"] = user["user-info"] + + if user.get("key-pairs"): + user_info["ssh-authorized-keys"] = user["key-pairs"] + + userdata_dict["users"].append(user_info) + + if cloud_config.get("config-files"): + userdata_dict["write_files"] = [] + for file in cloud_config["config-files"]: + file_info = { + "path": file["dest"], + "content": file["content"], + } + + if file.get("encoding"): + file_info["encoding"] = file["encoding"] + + if file.get("permissions"): + file_info["permissions"] = file["permissions"] + + if file.get("owner"): + file_info["owner"] = file["owner"] + + userdata_dict["write_files"].append(file_info) + + userdata_list.append( + "#cloud-config\n" + + yaml.safe_dump( + userdata_dict, indent=4, default_flow_style=False + ) + + f"\n{merge_how}" + ) + userdata = self._create_mimemultipart(userdata_list) + self.logger.debug("userdata: %s", userdata) + # End if config_drive elif isinstance(cloud_config, str): userdata = cloud_config + return config_drive, userdata def check_vim_connectivity(self): @@ -325,7 +424,14 @@ class VimConnector(): """ raise VimConnNotImplemented("Should have implemented this") - def new_network(self, net_name, net_type, ip_profile=None, shared=False, provider_network_profile=None): + 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 @@ -453,28 +559,54 @@ class VimConnector(): disk: disk size is_public: #TODO to concrete - Returns the flavor identifier""" + Returns the flavor identifier + """ raise VimConnNotImplemented("Should have implemented this") def delete_flavor(self, flavor_id): """Deletes a tenant flavor from VIM identify by its id - Returns the used id or raise an exception""" + Returns the used id or raise an exception + """ + raise VimConnNotImplemented("Should have implemented this") + + def get_affinity_group(self, affinity_group_id): + """Obtain affinity or anti affinity group details from the VIM + Returns the flavor dict details {'id':<>, 'name':<>, other vim specific } + Raises an exception upon error or if not found + """ + raise VimConnNotImplemented("Should have implemented this") + + def new_affinity_group(self, affinity_group_data): + """Adds an affinity or anti affinity group to VIM + affinity_group_data contains a dictionary with information, keys: + name: name in VIM for the affinity or anti-affinity group + type: affinity or anti-affinity + scope: Only nfvi-node allowed + Returns the affinity or anti affinity group identifier + """ + raise VimConnNotImplemented("Should have implemented this") + + def delete_affinity_group(self, affinity_group_id): + """Deletes an affinity or anti affinity group from the VIM identified by its id + Returns the used id or raise an exception + """ raise VimConnNotImplemented("Should have implemented this") def new_image(self, image_dict): - """ Adds a tenant image to VIM + """Adds a tenant image to VIM Returns the image id or raises an exception if failed """ raise VimConnNotImplemented("Should have implemented this") def delete_image(self, image_id): """Deletes a tenant image from VIM - Returns the image_id if image is deleted or raises an exception on error""" + Returns the image_id if image is deleted or raises an exception on error + """ raise VimConnNotImplemented("Should have implemented this") 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 """ raise VimConnNotImplemented("Should have implemented this") @@ -491,22 +623,36 @@ class VimConnector(): """ 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): + def new_vminstance( + self, + name, + description, + start, + image_id, + flavor_id, + affinity_group_list, + 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 + affinity_group_list: list of affinity groups, each one is a dictionary. + Ignore if empty. '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 + '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 + 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' @@ -555,7 +701,7 @@ class VimConnector(): """Returns the VM instance information from VIM""" raise VimConnNotImplemented("Should have implemented this") - def delete_vminstance(self, vm_id, created_items=None): + def delete_vminstance(self, vm_id, created_items=None, volumes_to_hold=None): """ Removes a VM instance from VIM and its associated elements :param vm_id: VIM identifier of the VM, provided by method new_vminstance @@ -567,29 +713,29 @@ class VimConnector(): 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 """ raise VimConnNotImplemented("Should have implemented this") @@ -623,7 +769,9 @@ class VimConnector(): """ raise VimConnNotImplemented("Should have implemented this") - def inject_user_key(self, ip_addr=None, user=None, key=None, ro_key=None, password=None): + def inject_user_key( + self, ip_addr=None, user=None, key=None, ro_key=None, password=None + ): """ Inject a ssh public key in a VM Params: @@ -635,35 +783,70 @@ class VimConnector(): The function doesn't return a value: """ if not ip_addr or not user: - raise VimConnNotSupportedException("All parameters should be different from 'None'") + raise VimConnNotSupportedException( + "All parameters should be different from 'None'" + ) elif not ro_key and not password: - raise VimConnNotSupportedException("All parameters should be different from 'None'") + raise VimConnNotSupportedException( + "All parameters should be different from 'None'" + ) else: - commands = {'mkdir -p ~/.ssh/', 'echo "{}" >> ~/.ssh/authorized_keys'.format(key), - 'chmod 644 ~/.ssh/authorized_keys', 'chmod 700 ~/.ssh/'} + commands = { + "mkdir -p ~/.ssh/", + 'echo "{}" >> ~/.ssh/authorized_keys'.format(key), + "chmod 644 ~/.ssh/authorized_keys", + "chmod 700 ~/.ssh/", + } + + logging.basicConfig( + format="%(asctime)s %(levelname)s %(name)s %(filename)s:%(lineno)s %(message)s" + ) + logging.getLogger("paramiko").setLevel(logging.DEBUG) client = paramiko.SSHClient() + try: if ro_key: pkey = paramiko.RSAKey.from_private_key(StringIO(ro_key)) else: pkey = None + client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) - client.connect(ip_addr, username=user, password=password, pkey=pkey, timeout=10) + + client.connect( + ip_addr, + username=user, + password=password, + pkey=pkey, + timeout=30, + auth_timeout=60, + ) + for command in commands: - (i, o, e) = client.exec_command(command, timeout=10) + (i, o, e) = client.exec_command(command, timeout=30) returncode = o.channel.recv_exit_status() outerror = e.read() + if returncode != 0: text = "run_command='{}' Error='{}'".format(command, outerror) - raise VimConnUnexpectedResponse("Cannot inject ssh key in VM: '{}'".format(text)) + self.logger.debug(traceback.format_tb(e.__traceback__)) + raise VimConnUnexpectedResponse( + "Cannot inject ssh key in VM: '{}'".format(text) + ) return - except (socket.error, paramiko.AuthenticationException, paramiko.SSHException) as message: + except ( + socket.error, + paramiko.AuthenticationException, + paramiko.SSHException, + ) as message: + self.logger.debug(traceback.format_exc()) raise VimConnUnexpectedResponse( - "Cannot inject ssh key in VM: '{}' - {}".format(ip_addr, str(message))) + "Cannot inject ssh key in VM: '{}' - {}".format( + ip_addr, str(message) + ) + ) return -# Optional methods - + # Optional methods def new_tenant(self, tenant_name, tenant_description): """Adds a new tenant to VIM with this name and description, this is done using admin_url if provided "tenant_name": string max lenght 64 @@ -672,332 +855,27 @@ class VimConnector(): """ raise VimConnNotImplemented("Should have implemented this") - def delete_tenant(self, tenant_id,): + def delete_tenant(self, tenant_id): """Delete a tenant from VIM tenant_id: returned VIM tenant_id on "new_tenant" Returns None on success. Raises and exception of failure. If tenant is not found raises VimConnNotFoundException """ raise VimConnNotImplemented("Should have implemented this") - def new_classification(self, name, ctype, definition): - """Creates a traffic classification in the VIM + def migrate_instance(self, vm_id, compute_host=None): + """Migrate a vdu Params: - 'name': name of this classification - 'ctype': type of this classification - 'definition': definition of this classification (type-dependent free-form text) - Returns the VIM's classification ID on success or raises an exception on failure - """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_classification(self, classification_id): - """Obtain classification details of the VIM's classification with ID='classification_id' - Return a dict that contains: - 'id': VIM's classification ID (same as classification_id) - 'name': VIM's classification name - 'type': type of this classification - 'definition': definition of the classification - 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER' - 'error_msg': (optional) text that explains the ERROR status - other VIM specific fields: (optional) whenever possible - Raises an exception upon error or when classification is not found - """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_classification_list(self, filter_dict={}): - """Obtain classifications from the VIM - Params: - 'filter_dict' (optional): contains the entries to filter the classifications on and only return those that - match ALL: - id: string => returns classifications with this VIM's classification ID, which implies a return of one - classification at most - name: string => returns only classifications with this name - type: string => returns classifications of this type - definition: string => returns classifications that have this definition - tenant_id: string => returns only classifications that belong to this tenant/project - Returns a list of classification dictionaries, each dictionary contains: - 'id': (mandatory) VIM's classification ID - 'name': (mandatory) VIM's classification name - 'type': type of this classification - 'definition': definition of the classification - other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param - List can be empty if no classification matches the filter_dict. Raise an exception only upon VIM connectivity, - authorization, or some other unspecific error + vm_id: ID of an instance + compute_host: Host to migrate the vdu to + Returns the vm state or raises an exception upon error """ - raise VimConnNotImplemented("SFC support not implemented") - - def refresh_classifications_status(self, classification_list): - '''Get the status of the classifications - Params: the list of classification identifiers - Returns a dictionary with: - vm_id: #VIM id of this classifier - 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, - # CREATING (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) - ''' raise VimConnNotImplemented("Should have implemented this") - def delete_classification(self, classification_id): - """Deletes a classification from the VIM - Returns the classification ID (classification_id) or raises an exception upon error or when classification is - not found + def resize_instance(self, vm_id, flavor_id=None): """ - raise VimConnNotImplemented("SFC support not implemented") - - def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True): - """Creates a service function instance in the VIM - Params: - 'name': name of this service function instance - 'ingress_ports': set of ingress ports (VIM's port IDs) - 'egress_ports': set of egress ports (VIM's port IDs) - 'sfc_encap': boolean stating whether this specific instance supports IETF SFC Encapsulation - Returns the VIM's service function instance ID on success or raises an exception on failure + resize a vdu + param: + vm_id: ID of an instance + flavor_id: flavor_id to resize the vdu to """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_sfi(self, sfi_id): - """Obtain service function instance details of the VIM's service function instance with ID='sfi_id' - Return a dict that contains: - 'id': VIM's sfi ID (same as sfi_id) - 'name': VIM's sfi name - 'ingress_ports': set of ingress ports (VIM's port IDs) - 'egress_ports': set of egress ports (VIM's port IDs) - 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER' - 'error_msg': (optional) text that explains the ERROR status - other VIM specific fields: (optional) whenever possible - Raises an exception upon error or when service function instance is not found - """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_sfi_list(self, filter_dict={}): - """Obtain service function instances from the VIM - Params: - 'filter_dict' (optional): contains the entries to filter the sfis on and only return those that match ALL: - id: string => returns sfis with this VIM's sfi ID, which implies a return of one sfi at most - name: string => returns only service function instances with this name - tenant_id: string => returns only service function instances that belong to this tenant/project - Returns a list of service function instance dictionaries, each dictionary contains: - 'id': (mandatory) VIM's sfi ID - 'name': (mandatory) VIM's sfi name - 'ingress_ports': set of ingress ports (VIM's port IDs) - 'egress_ports': set of egress ports (VIM's port IDs) - other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param - List can be empty if no sfi matches the filter_dict. Raise an exception only upon VIM connectivity, - authorization, or some other unspecific error - """ - raise VimConnNotImplemented("SFC support not implemented") - - def delete_sfi(self, sfi_id): - """Deletes a service function instance from the VIM - Returns the service function instance ID (sfi_id) or raises an exception upon error or when sfi is not found - """ - raise VimConnNotImplemented("SFC support not implemented") - - def refresh_sfis_status(self, sfi_list): - '''Get the status of the service function instances - Params: the list of sfi identifiers - Returns a dictionary with: - vm_id: #VIM id of this service function instance - 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, - # CREATING (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) - ''' - raise VimConnNotImplemented("Should have implemented this") - - def new_sf(self, name, sfis, sfc_encap=True): - """Creates (an abstract) service function in the VIM - Params: - 'name': name of this service function - 'sfis': set of service function instances of this (abstract) service function - 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation - Returns the VIM's service function ID on success or raises an exception on failure - """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_sf(self, sf_id): - """Obtain service function details of the VIM's service function with ID='sf_id' - Return a dict that contains: - 'id': VIM's sf ID (same as sf_id) - 'name': VIM's sf name - 'sfis': VIM's sf's set of VIM's service function instance IDs - 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation - 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER' - 'error_msg': (optional) text that explains the ERROR status - other VIM specific fields: (optional) whenever possible - Raises an exception upon error or when sf is not found - """ - - def get_sf_list(self, filter_dict={}): - """Obtain service functions from the VIM - Params: - 'filter_dict' (optional): contains the entries to filter the sfs on and only return those that match ALL: - id: string => returns sfs with this VIM's sf ID, which implies a return of one sf at most - name: string => returns only service functions with this name - tenant_id: string => returns only service functions that belong to this tenant/project - Returns a list of service function dictionaries, each dictionary contains: - 'id': (mandatory) VIM's sf ID - 'name': (mandatory) VIM's sf name - 'sfis': VIM's sf's set of VIM's service function instance IDs - 'sfc_encap': boolean stating whether this service function supports IETF SFC Encapsulation - other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param - List can be empty if no sf matches the filter_dict. Raise an exception only upon VIM connectivity, - authorization, or some other unspecific error - """ - raise VimConnNotImplemented("SFC support not implemented") - - def delete_sf(self, sf_id): - """Deletes (an abstract) service function from the VIM - Returns the service function ID (sf_id) or raises an exception upon error or when sf is not found - """ - raise VimConnNotImplemented("SFC support not implemented") - - def refresh_sfs_status(self, sf_list): - '''Get the status of the service functions - Params: the list of sf identifiers - Returns a dictionary with: - vm_id: #VIM id of this service function - 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, - # CREATING (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) - ''' - raise VimConnNotImplemented("Should have implemented this") - - def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None): - """Creates a service function path - Params: - 'name': name of this service function path - 'classifications': set of traffic classifications that should be matched on to get into this sfp - 'sfs': list of every service function that constitutes this path , from first to last - 'sfc_encap': whether this is an SFC-Encapsulated chain (i.e using NSH), True by default - 'spi': (optional) the Service Function Path identifier (SPI: Service Path Identifier) for this path - Returns the VIM's sfp ID on success or raises an exception on failure - """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_sfp(self, sfp_id): - """Obtain service function path details of the VIM's sfp with ID='sfp_id' - Return a dict that contains: - 'id': VIM's sfp ID (same as sfp_id) - 'name': VIM's sfp name - 'classifications': VIM's sfp's list of VIM's classification IDs - 'sfs': VIM's sfp's list of VIM's service function IDs - 'status': 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER' - 'error_msg': (optional) text that explains the ERROR status - other VIM specific fields: (optional) whenever possible - Raises an exception upon error or when sfp is not found - """ - raise VimConnNotImplemented("SFC support not implemented") - - def get_sfp_list(self, filter_dict={}): - """Obtain service function paths from VIM - Params: - 'filter_dict' (optional): contains the entries to filter the sfps on, and only return those that match ALL: - id: string => returns sfps with this VIM's sfp ID , which implies a return of one sfp at most - name: string => returns only sfps with this name - tenant_id: string => returns only sfps that belong to this tenant/project - Returns a list of service function path dictionaries, each dictionary contains: - 'id': (mandatory) VIM's sfp ID - 'name': (mandatory) VIM's sfp name - 'classifications': VIM's sfp's list of VIM's classification IDs - 'sfs': VIM's sfp's list of VIM's service function IDs - other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param - List can be empty if no sfp matches the filter_dict. Raise an exception only upon VIM connectivity, - authorization, or some other unspecific error - """ - raise VimConnNotImplemented("SFC support not implemented") - - def refresh_sfps_status(self, sfp_list): - '''Get the status of the service function path - Params: the list of sfp identifiers - Returns a dictionary with: - vm_id: #VIM id of this service function path - 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, - # CREATING (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)F - ''' - raise VimConnNotImplemented("Should have implemented this") - - def delete_sfp(self, sfp_id): - """Deletes a service function path from the VIM - Returns the sfp ID (sfp_id) or raises an exception upon error or when sf is not found - """ - raise VimConnNotImplemented("SFC support not implemented") - -# NOT USED METHODS in current version. Deprecated - - @deprecated - def host_vim2gui(self, host, server_dict): - """Transform host dictionary from VIM format to GUI format, - and append to the server_dict - """ - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def get_hosts_info(self): - """Get the information of deployed hosts - Returns the hosts content""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def get_hosts(self, vim_tenant): - """Get the hosts and deployed instances - Returns the hosts content""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def get_processor_rankings(self): - """Get the processor rankings in the VIM database""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def new_host(self, host_data): - """Adds a new host to VIM""" - """Returns status code of the VIM response""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def new_external_port(self, port_data): - """Adds a external port to VIM""" - """Returns the port identifier""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def new_external_network(self, net_name, net_type): - """Adds a external network to VIM (shared)""" - """Returns the network identifier""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def connect_port_network(self, port_id, network_id, admin=False): - """Connects a external port to a network""" - """Returns status code of the VIM response""" - raise VimConnNotImplemented("Should have implemented this") - - @deprecated - def new_vminstancefromJSON(self, vm_data): - """Adds a VM instance to VIM""" - """Returns the instance identifier""" raise VimConnNotImplemented("Should have implemented this")