X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_ro%2Fvimconn.py;h=957c41074889d3eec0faf92221672195d459f319;hb=1fa49b16e92ff2e4f512ccc466fdc3dff31559e4;hp=f1f6b2d8dbf11c49c736ee6b021255df85d3679c;hpb=862a60ae93454d1cb15feb25efa31f493e2f46d3;p=osm%2FRO.git diff --git a/osm_ro/vimconn.py b/osm_ro/vimconn.py index f1f6b2d8..957c4107 100644 --- a/osm_ro/vimconn.py +++ b/osm_ro/vimconn.py @@ -1,7 +1,7 @@ # -*- coding: utf-8 -*- ## -# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U. +# Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U. # This file is part of openmano # All Rights Reserved. # @@ -25,10 +25,19 @@ vimconn implement an Abstract class for the vim connector plugins with the definition of the method to be implemented. """ -__author__="Alfonso Tierno, Igor D.C." -__date__ ="$14-aug-2017 23:59:59$" import logging +import paramiko +import socket +import StringIO +import yaml +import sys +from email.mime.multipart import MIMEMultipart +from email.mime.text import MIMEText +from utils import deprecated + +__author__ = "Alfonso Tierno, Igor D.C." +__date__ = "$14-aug-2017 23:59:59$" #Error variables HTTP_Bad_Request = 400 @@ -41,47 +50,56 @@ HTTP_Not_Implemented = 501 HTTP_Service_Unavailable = 503 HTTP_Internal_Server_Error = 500 + 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 + 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""" def __init__(self, message, http_code=HTTP_Not_Implemented): 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 @@ -89,100 +107,213 @@ class vimconnector(): """ def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None, config={}, persitent_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 + """ + Constructor of VIM. Raise an exception is some needed parameter is missing, but it must not do any connectivity + checking against the VIM + :param uuid: internal id of this VIM + :param name: name assigned to this VIM, can be used for logging + :param tenant_id: 'tenant_id': (only one of them is mandatory) VIM tenant to be used + :param tenant_name: 'tenant_name': (only one of them is mandatory) VIM tenant to be used + :param url: url used for normal operations + :param url_admin: (optional), url used for administrative tasks + :param user: user to access + :param passwd: password + :param log_level: provided if it should use a different log_level than the general one + :param config: dictionary with extra VIM information. This contains a consolidate version of VIM config + at VIM_ACCOUNT (attach) + :param persitent_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 """ - self.id = uuid - self.name = name - self.url = url + self.id = uuid + self.name = name + self.url = url self.url_admin = url_admin self.tenant_id = tenant_id self.tenant_name = tenant_name - self.user = user - self.passwd = passwd - self.config = config + self.user = user + self.passwd = passwd + self.config = config or {} + self.availability_zone = None self.logger = logging.getLogger('openmano.vim') if log_level: - self.logger.setLevel( getattr(logging, log_level) ) - if not self.url_admin: #try to use normal url + self.logger.setLevel(getattr(logging, log_level)) + if not self.url_admin: # try to use normal url self.url_admin = self.url - def __getitem__(self,index): - if index=='tenant_id': + def __getitem__(self, index): + 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": + elif index == "config": return self.config else: - raise KeyError("Invalid key '%s'" %str(index)) + raise KeyError("Invalid key '{}'".format(index)) - def __setitem__(self,index, value): - if index=='tenant_id': + def __setitem__(self, index, value): + 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 '%s'" %str(index)) - + raise KeyError("Invalid key '{}'".format(index)) + + @staticmethod + def _create_mimemultipart(content_list): + """Creates a MIMEmultipart text combining the content_list + :param content_list: list of text scripts to be combined + :return: str of the created MIMEmultipart. If the list is empty returns None, if the list contains only one + element MIMEmultipart is not created and this content is returned + """ + if not content_list: + 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' + else: # by default + 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): + """ + Creates a script user database on cloud_config info + :param cloud_config: 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) + :return: config_drive, userdata. The first is a boolean or None, the second a string or None + """ + config_drive = None + userdata = None + userdata_list = [] + 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 "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) + elif isinstance(cloud_config, str): + userdata = cloud_config + return config_drive, userdata + 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 raises vimconnConnectionException, vimconnAuthException, ... """ - raise vimconnNotImplemented( "Should have implemented this" ) + # by default no checking until each connector implements it + return None - def new_tenant(self,tenant_name,tenant_description): + 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 "tenant_description": string max length 256 returns the tenant identifier or raise exception """ - raise vimconnNotImplemented( "Should have implemented this" ) + 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" ) + raise vimconnNotImplemented("Should have implemented this") def get_tenant_list(self, filter_dict={}): """Obtain tenants of VIM @@ -193,7 +324,7 @@ class vimconnector(): Returns the tenant list of dictionaries, and empty list if no tenant match all the filers: [{'name':', 'id':', ...}, ...] """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def new_network(self, net_name, net_type, ip_profile=None, shared=False, vlan=None): """Adds a tenant network to VIM @@ -203,20 +334,23 @@ class vimconnector(): '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 (Currently only IPv4 is implemented) - 'ip-version': can be one of ["IPv4","IPv6"] - '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) ip_schema, - 'dhcp': (Optional) dict containing - 'enabled': {"type": "boolean"}, - 'start-address': ip_schema, first IP to grant - 'count': number of IPs to grant. + '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 '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 + Returns a tuple with the network 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_network. Can be used to store created segments, created l2gw connections, etc. + Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same + as not present. """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def get_network_list(self, filter_dict={}): """Obtain tenant networks of VIM @@ -239,7 +373,7 @@ class 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 """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def get_network(self, net_id): """Obtain network details from the 'net_id' VIM network @@ -251,13 +385,16 @@ class 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 """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") - def delete_network(self, net_id): - """Deletes a tenant network from VIM + def delete_network(self, net_id, created_items=None): + """ + Removes a tenant network from VIM and its associated elements + :param net_id: VIM identifier of the network, provided by method new_network + :param created_items: dictionary with extra items to be deleted. provided by method new_network Returns the network identifier or raises an exception upon error or when network is not found """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def refresh_nets_status(self, net_list): """Get the status of the networks @@ -276,14 +413,14 @@ class vimconnector(): vim_info: #Text with plain information obtained from vim (yaml.safe_dump) 'net_id2': ... """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") 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 """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def get_flavor_id_from_data(self, flavor_dict): """Obtain flavor id that match the flavor description @@ -295,7 +432,7 @@ class vimconnector(): #TODO: complete parameters for EPA Returns the flavor_id or raises a vimconnNotFoundException """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def new_flavor(self, flavor_data): """Adds a tenant flavor to VIM @@ -316,29 +453,29 @@ class vimconnector(): is_public: #TODO to concrete Returns the flavor identifier""" - raise vimconnNotImplemented( "Should have implemented this" ) + 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""" - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def new_image(self, image_dict): """ Adds a tenant image to VIM Returns the image id or raises an exception if failed """ - raise vimconnNotImplemented( "Should have implemented this" ) + 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""" - raise vimconnNotImplemented( "Should have implemented this" ) + 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 """ - raise vimconnNotImplemented( "Should have implemented this" ) + raise vimconnNotImplemented("Should have implemented this") def get_image_list(self, filter_dict={}): """Obtain tenant images from VIM @@ -353,8 +490,8 @@ 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): + 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. @@ -363,15 +500,16 @@ class vimconnector(): '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, e2000, ... + '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' - 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it + 'PCI-PASSTHROUGH' or 'PF' (passthrough): depending on VIM capabilities it can be connected to a data/ptp network ot it can created unconnected - 'VF' (SRIOV with VLAN tag): same as PF for network connectivity. + '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 @@ -385,7 +523,8 @@ class vimconnector(): '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) string is a text script to be passed directly to cloud-init + '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: @@ -397,7 +536,14 @@ class vimconnector(): '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 - Returns the instance identifier or raises an exception on error + 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 + 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. """ raise vimconnNotImplemented( "Should have implemented this" ) @@ -405,9 +551,14 @@ class vimconnector(): """Returns the VM instance information from VIM""" raise vimconnNotImplemented( "Should have implemented this" ) - def delete_vminstance(self, vm_id): - """Removes a VM instance from VIM - Returns the instance identifier""" + def delete_vminstance(self, vm_id, created_items=None): + """ + Removes a VM instance from VIM and its associated 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 + """ raise vimconnNotImplemented( "Should have implemented this" ) def refresh_vms_status(self, vm_list): @@ -438,9 +589,18 @@ class vimconnector(): """ raise vimconnNotImplemented( "Should have implemented this" ) - def action_vminstance(self, vm_id, action_dict): - """Send and action over a VM instance from VIM - Returns the vm_id if the action was successfully sent to the VIM""" + 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 + """ raise vimconnNotImplemented( "Should have implemented this" ) def get_vminstance_console(self, vm_id, console_type="vnc"): @@ -459,6 +619,74 @@ 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): + """ + Inject a ssh public key in a VM + Params: + ip_addr: ip address of the VM + user: username (default-user) to enter in the VM + key: public key to be injected in the VM + ro_key: private key of the RO, used to enter in the VM if the password is not provided + password: password of the user to enter in the VM + The function doesn't return a value: + """ + if not ip_addr or not user: + 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'") + else: + commands = {'mkdir -p ~/.ssh/', 'echo "%s" >> ~/.ssh/authorized_keys' % key, + 'chmod 644 ~/.ssh/authorized_keys', 'chmod 700 ~/.ssh/'} + client = paramiko.SSHClient() + try: + if ro_key: + pkey = paramiko.RSAKey.from_private_key(StringIO.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) + for command in commands: + (i, o, e) = client.exec_command(command, timeout=10) + returncode = o.channel.recv_exit_status() + output = o.read() + outerror = e.read() + if returncode != 0: + text = "run_command='{}' Error='{}'".format(command, outerror) + raise vimconnUnexpectedResponse("Cannot inject ssh key in VM: '{}'".format(text)) + return + except (socket.error, paramiko.AuthenticationException, paramiko.SSHException) as message: + raise vimconnUnexpectedResponse( + "Cannot inject ssh key in VM: '{}' - {}".format(ip_addr, str(message))) + return + +# 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 + "tenant_description": string max length 256 + returns the tenant identifier or raise exception + """ + raise vimconnNotImplemented( "Should have implemented this" ) + + 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 get_tenant_list(self, filter_dict=None): + """Obtain tenants of VIM + filter_dict dictionary that can contain the following keys: + name: filter by tenant name + id: filter by tenant uuid/id + + Returns the tenant list of dictionaries, and empty list if no tenant match all the filers: + [{'name':', 'id':', ...}, ...] + """ + raise vimconnNotImplemented( "Should have implemented this" ) + def new_classification(self, name, ctype, definition): """Creates a traffic classification in the VIM Params: @@ -605,7 +833,6 @@ class vimconnector(): """ raise vimconnNotImplemented( "SFC support not implemented" ) - def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None): """Creates a service function path Params: @@ -656,49 +883,60 @@ class vimconnector(): """ raise vimconnNotImplemented( "SFC support not implemented" ) -#NOT USED METHODS in current version +# 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 + @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" ) +