+++ /dev/null
-# -*- coding: utf-8 -*-
-
-##
-# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
-# This file is part of openmano
-# All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-#
-# For those usages not covered by the Apache License, Version 2.0 please
-# contact with: nfvlabs@tid.es
-##
-
-"""
-vimconn implement an Abstract class for the vim connector plugins
- with the definition of the method to be implemented.
-"""
-__author__="Alfonso Tierno"
-__date__ ="$16-oct-2015 11:09:29$"
-
-import logging
-
-#Error variables
-HTTP_Bad_Request = 400
-HTTP_Unauthorized = 401
-HTTP_Not_Found = 404
-HTTP_Method_Not_Allowed = 405
-HTTP_Request_Timeout = 408
-HTTP_Conflict = 409
-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
- 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={}, 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
- 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.url_admin = url_admin
- self.tenant_id = tenant_id
- self.tenant_name = tenant_name
- self.user = user
- self.passwd = passwd
- self.config = config
- 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.url_admin = self.url
-
- def __getitem__(self,index):
- if index=='tenant_id':
- return self.tenant_id
- if index=='tenant_name':
- return self.tenant_name
- elif index=='id':
- return self.id
- elif index=='name':
- return self.name
- elif index=='user':
- return self.user
- elif index=='passwd':
- return self.passwd
- elif index=='url':
- return self.url
- elif index=='url_admin':
- return self.url_admin
- elif index=="config":
- return self.config
- else:
- raise KeyError("Invalid key '%s'" %str(index))
-
- def __setitem__(self,index, value):
- if index=='tenant_id':
- self.tenant_id = value
- if index=='tenant_name':
- self.tenant_name = value
- elif index=='id':
- self.id = value
- elif index=='name':
- self.name = value
- elif index=='user':
- self.user = value
- elif index=='passwd':
- self.passwd = value
- elif index=='url':
- self.url = value
- elif index=='url_admin':
- self.url_admin = value
- else:
- raise KeyError("Invalid key '%s'" %str(index))
-
- def check_vim_connectivity(self):
- """Checks VIM can be reached and user credentials are ok.
- Returns None if success or raised vimconnConnectionException, vimconnAuthException, ...
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- 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={}):
- """Obtain tenants of VIM
- filter_dict dictionary that can contain the following keys:
- name: filter by tenant name
- id: filter by tenant uuid/id
- <other VIM specific>
- Returns the tenant list of dictionaries, and empty list if no tenant match all the filers:
- [{'name':'<name>, 'id':'<id>, ...}, ...]
- """
- 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
- Params:
- 'net_name': name of the network
- 'net_type': one of:
- 'bridge': overlay isolated network
- 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
- 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
- 'ip_profile': is a dict containing the IP parameters of the network (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.
- '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
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- 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
- Returns the network list of dictionaries. each dictionary contains:
- 'id': (mandatory) VIM network id
- 'name': (mandatory) VIM network name
- 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
- 'error_msg': (optional) text that explains the ERROR status
- other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
- List can be empty if no network map the filter_dict. Raise an exception only upon VIM connectivity,
- authorization, or some other unspecific error
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def get_network(self, net_id):
- """Obtain network details from the 'net_id' VIM network
- Return a dict that contains:
- 'id': (mandatory) VIM network id, that is, net_id
- 'name': (mandatory) VIM network name
- 'status': (mandatory) can be 'ACTIVE', 'INACTIVE', 'DOWN', 'BUILD', 'ERROR', 'VIM_ERROR', 'OTHER'
- 'error_msg': (optional) text that explains the ERROR status
- other VIM specific fields: (optional) whenever possible using the same naming of filter_dict param
- Raises an exception upon error or when network is not found
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def delete_network(self, net_id):
- """Deletes a tenant network from VIM
- Returns the network identifier or raises an exception upon error or when network is not found
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def refresh_nets_status(self, net_list):
- """Get the status of the networks
- Params:
- 'net_list': a list with the VIM network id to be get the status
- Returns a dictionary with:
- 'net_id': #VIM id of this network
- status: #Mandatory. Text with one of:
- # DELETED (not found at vim)
- # VIM_ERROR (Cannot connect to VIM, authentication problems, VIM response error, ...)
- # OTHER (Vim reported other status not understood)
- # ERROR (VIM indicates an ERROR status)
- # ACTIVE, INACTIVE, DOWN (admin down),
- # BUILD (on building process)
- error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
- vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
- 'net_id2': ...
- """
- 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" )
-
- def get_flavor_id_from_data(self, flavor_dict):
- """Obtain flavor id that match the flavor description
- Params:
- 'flavor_dict': dictionary that contains:
- 'disk': main hard disk in GB
- 'ram': meomry in MB
- 'vcpus': number of virtual cpus
- #TODO: complete parameters for EPA
- Returns the flavor_id or raises a vimconnNotFoundException
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def new_flavor(self, flavor_data):
- """Adds a tenant flavor to VIM
- flavor_data contains a dictionary with information, keys:
- name: flavor name
- ram: memory (cloud type) in MBytes
- vpcus: cpus (cloud type)
- extended: EPA parameters
- - numas: #items requested in same NUMA
- memory: number of 1G huge pages memory
- paired-threads|cores|threads: number of paired hyperthreads, complete cores OR individual threads
- interfaces: # passthrough(PT) or SRIOV interfaces attached to this numa
- - name: interface name
- dedicated: yes|no|yes:sriov; for PT, SRIOV or only one SRIOV for the physical NIC
- bandwidth: X Gbps; requested guarantee bandwidth
- vpci: requested virtual PCI address
- disk: disk size
- is_public:
- #TODO to concrete
- Returns the flavor identifier"""
- 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" )
-
- 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" )
-
- 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" )
-
- 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" )
-
- def get_image_list(self, filter_dict={}):
- """Obtain tenant images from VIM
- Filter_dict can be:
- name: image name
- id: image uuid
- checksum: image checksum
- location: image path
- Returns the image list of dictionaries:
- [{<the fields at Filter_dict plus some VIM specific>}, ...]
- List can be empty
- """
- 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):
- """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, e2000, ...
- 'mac_address': (optional) mac 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
- can created unconnected
- '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) string is a text script to be passed directly to cloud-init
- '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
- Returns the instance identifier or raises an exception on error
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def get_vminstance(self,vm_id):
- """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"""
- 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
- physical_compute: #identification of compute node where PF,VF interface is allocated
- physical_pci: #PCI address of the NIC that hosts the PF,VF
- physical_vlan: #physical VLAN used for VF
- """
- 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"""
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def get_vminstance_console(self, vm_id, console_type="vnc"):
- """
- Get a console for the virtual machine
- Params:
- vm_id: uuid of the VM
- console_type, can be:
- "novnc" (by default), "xvpvnc" for VNC types,
- "rdp-html5" for RDP types, "spice-html5" for SPICE types
- Returns dict with the console parameters:
- protocol: ssh, ftp, http, https, ...
- server: usually ip address
- port: the http, ssh, ... port
- suffix: extra text, e.g. the http path and query string
- """
- raise vimconnNotImplemented( "Should have implemented this" )
-
-#NOT USED METHODS in current version
-
- 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" )
-
- def get_hosts_info(self):
- """Get the information of deployed hosts
- Returns the hosts content"""
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def get_hosts(self, vim_tenant):
- """Get the hosts and deployed instances
- Returns the hosts content"""
- raise vimconnNotImplemented( "Should have implemented this" )
-
- def get_processor_rankings(self):
- """Get the processor rankings in the VIM database"""
- raise vimconnNotImplemented( "Should have implemented this" )
-
- 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" )
-
- def new_external_port(self, port_data):
- """Adds a external port to VIM"""
- """Returns the port identifier"""
- raise vimconnNotImplemented( "Should have implemented this" )
-
- 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" )
-
- 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" )
-
- def new_vminstancefromJSON(self, vm_data):
- """Adds a VM instance to VIM"""
- """Returns the instance identifier"""
- raise vimconnNotImplemented( "Should have implemented this" )
-
projects / osm / RO.git / blobdiff