vimconn.py: Better documentation.

Unify new_network method for all vimconns.
Add new parameter persistem_info at constructor.
New method check_vim_connectivity.

Change-Id: Ie2c7900fe12fd5ae01ef2bb4891b79a0f9173285
Signed-off-by: tierno <alfonso.tiernosepulveda@telefonica.com>

diff --git a/nfvo.py b/nfvo.py
index 4565f00..80a606b 100644 (file)
--- a/nfvo.py
+++ b/nfvo.py
@@ -2855,7 +2855,8 @@ def vim_action_create(mydb, tenant_id, datacenter, item, descriptor):
             net_type = net.pop("type", "bridge")
             net_public = net.pop("shared", False)
             net_ipprofile = net.pop("ip_profile", None)
             net_type = net.pop("type", "bridge")
             net_public = net.pop("shared", False)
             net_ipprofile = net.pop("ip_profile", None)

-            content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, **net)
+            net_vlan = net.pop("vlan", None)
+            content = myvim.new_network(net_name, net_type, net_ipprofile, shared=net_public, vlan=net_vlan) #, **net)

         elif item=="tenants":
             tenant = descriptor["tenant"]
             content = myvim.new_tenant(tenant["name"], tenant.get("description"))
         elif item=="tenants":
             tenant = descriptor["tenant"]
             content = myvim.new_tenant(tenant["name"], tenant.get("description"))

diff --git a/vimconn.py b/vimconn.py
index ad06dc8..c1721cd 100644 (file)
--- a/vimconn.py
+++ b/vimconn.py
@@ -21,10 +21,10 @@
 # contact with: nfvlabs@tid.es
 ##
 
 # contact with: nfvlabs@tid.es
 ##
 

-'''
+"""

 vimconn implement an Abstract class for the vim connector plugins
  with the definition of the method to be implemented.
 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$"
 
 __author__="Alfonso Tierno"
 __date__ ="$16-oct-2015 11:09:29$"
 


@@ -42,57 +42,69 @@ HTTP_Service_Unavailable = 503
 HTTP_Internal_Server_Error = 500 
 
 class vimconnException(Exception):
 HTTP_Internal_Server_Error = 500 
 
 class vimconnException(Exception):

-    '''Common and base class Exception for all vimconnector exceptions'''
+    """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):
     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'''
+    """Connectivity error with the VIM"""

     def __init__(self, message, http_code=HTTP_Service_Unavailable):
         vimconnException.__init__(self, message, http_code)
     
 class vimconnUnexpectedResponse(vimconnException):
     def __init__(self, message, http_code=HTTP_Service_Unavailable):
         vimconnException.__init__(self, message, http_code)
     
 class vimconnUnexpectedResponse(vimconnException):

-    '''Get an wrong response from VIM'''
+    """Get an wrong response from VIM"""

     def __init__(self, message, http_code=HTTP_Service_Unavailable):
         vimconnException.__init__(self, message, http_code)
 
 class vimconnAuthException(vimconnException):
     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'''
+    """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):
     def __init__(self, message, http_code=HTTP_Unauthorized):
         vimconnException.__init__(self, message, http_code)
 
 class vimconnNotFoundException(vimconnException):

-    '''The item is not found at VIM'''
+    """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):
     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'''
+    """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)
 
     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):
 class vimconnNotImplemented(vimconnException):

-    '''The method is not implemented by the connected'''
+    """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():
     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
+    """Abstract base class for all the VIM connector plugins

     These plugins must implement a vimconnector class derived from this 
     These plugins must implement a vimconnector class derived from this 

-    and all these methods
-    ''' 
-    def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None, log_level=None, config={}):
+    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
         """Constructor of VIM

-        "uuid": id asigned to this VIM
-        "name": name assigned to this VIM, can be used for logging
-        "tenant_id", tenant_name:  VIM tenant to be used
-        "url_admin": optional, url used for administrative tasks
-        "user", "passwd": credentials of the VIM user
-        "log_level": if must 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 create
-            and particular VIM config at attach
-        Returns can raise an exception if some check is done and fails
+        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.id        = uuid
         self.name      = name


@@ -151,6 +163,12 @@ class vimconnector():
         else:
             raise KeyError("Invalid key '%s'" %str(index))
         
         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
     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


@@ -167,90 +185,118 @@ class vimconnector():
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_tenant_list(self, filter_dict={}):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_tenant_list(self, filter_dict={}):

-        '''Obtain tenants of VIM
+        """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>, ...}, ...]
         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" )
 
         raise vimconnNotImplemented( "Should have implemented this" )
 

-    def new_network(self,net_name, net_type, ip_profile=None, shared=False):
+    def new_network(self, net_name, net_type, ip_profile=None, shared=False, vlan=None):

         """Adds a tenant network to VIM
         """Adds a tenant network to VIM

-            net_name is the name
-            net_type can be 'bridge','data'.'ptp'.  TODO: this need to be revised
-            ip_profile is a dict containing the IP parameters of the network
-                "ip-version": {"type":"string", "enum":["IPv4","IPv6"]},
-                "subnet-address": ip_prefix_schema,
-                "gateway-address": ip_schema,
-                "dns-address": ip_schema,
-                "dhcp": dhcp_schema
-
-            shared is a boolean
-        Returns the network identifier on success or raises and exeption on failure
+        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={}):
         """
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_network_list(self, filter_dict={}):

-        '''Obtain tenant networks of VIM
-        Filter_dict can be:
-            name: network name
-            id: network uuid
-            shared: boolean
-            tenant_id: tenant
-            admin_state_up: boolean
-            status: 'ACTIVE'
-        Returns the network list of dictionaries:
-            [{<the fields at Filter_dict plus some VIM specific>}, ...]
-            List can be empty
-        '''
+        """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):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_network(self, net_id):

-        '''Obtain network details of net_id VIM network'
-           Return a dict with  the fields at filter_dict (see get_network_list) plus some VIM specific>}, ...]'''
+        """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):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def delete_network(self, net_id):

-        '''Deletes a tenant network from VIM, provide the network id.
-        Returns the network identifier or raise an exception'''
+        """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):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def refresh_nets_status(self, net_list):

-        '''Get the status of the networks
-           Params: the list of network identifiers
-           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, 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)
-
-        '''
+        """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):
         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 } #TODO to concrete
-        '''
+        """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
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_flavor_id_from_data(self, flavor_dict):
         """Obtain flavor id that match the flavor description

-           Returns the flavor_id or raises a vimconnNotFoundException
+        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):
         """
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def new_flavor(self, flavor_data):

-        '''Adds a tenant flavor to VIM
+        """Adds a tenant flavor to VIM

             flavor_data contains a dictionary with information, keys:
                 name: flavor name
                 ram: memory (cloud type) in MBytes
             flavor_data contains a dictionary with information, keys:
                 name: flavor name
                 ram: memory (cloud type) in MBytes


@@ -266,30 +312,24 @@ class vimconnector():
                             vpci: requested virtual PCI address   
                 disk: disk size
                 is_public:
                             vpci: requested virtual PCI address   
                 disk: disk size
                 is_public:

-                       
-                
-                    

                  #TODO to concrete
                  #TODO to concrete

-        Returns the flavor identifier'''
+        Returns the flavor identifier"""

         raise vimconnNotImplemented( "Should have implemented this" )
 
     def delete_flavor(self, flavor_id):
         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'''
+        """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:
-            200, image-id        if the image is created
-            <0, message          if there is an error
-        '''
+    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):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def delete_image(self, image_id):

-        '''Deletes a tenant image from VIM'''
-        '''Returns the HTTP response code and a message indicating details of the success or fail'''
+        """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):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_image_id_from_path(self, path):


@@ -299,7 +339,7 @@ class vimconnector():
         raise vimconnNotImplemented( "Should have implemented this" )
         
     def get_image_list(self, filter_dict={}):
         raise vimconnNotImplemented( "Should have implemented this" )
         
     def get_image_list(self, filter_dict={}):

-        '''Obtain tenant images from VIM
+        """Obtain tenant images from VIM

         Filter_dict can be:
             name: image name
             id: image uuid
         Filter_dict can be:
             name: image name
             id: image uuid


@@ -308,44 +348,66 @@ class vimconnector():
         Returns the image list of dictionaries:
             [{<the fields at Filter_dict plus some VIM specific>}, ...]
             List can be empty
         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" )
 
         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
+    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:
         Params:

-            start: indicates if VM must start or boot in pause mode. Ignored
-            image_id,flavor_id: image and flavor uuid
-            net_list: list of interfaces, each one is a dictionary with:
-                name:
-                net_id: network uuid to connect
-                vpci: virtual vcpi to assign
-                model: interface model, virtio, e2000, ...
-                mac_address: 
-                use: 'data', 'bridge',  'mgmt'
-                type: 'virtual', 'PF', 'VF', 'VFnotShared'
-                vim_id: filled/added by this function
-                cloud_config: can be a text script to be passed directly to cloud-init,
-                    or an object to inject users and ssh keys with format:
-                        key-pairs: [] list of keys to install to the default user
-                        users: [{ name, key-pairs: []}] list of users to add with their key-pair 
-                #TODO ip, security groups
-        Returns >=0, the instance identifier
-                <0, error_text
-        '''
+            '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
+                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):
         raise vimconnNotImplemented( "Should have implemented this" )
         
     def get_vminstance(self,vm_id):

-        '''Returns the VM instance information from VIM'''
+        """Returns the VM instance information from VIM"""

         raise vimconnNotImplemented( "Should have implemented this" )
         
     def delete_vminstance(self, vm_id):
         raise vimconnNotImplemented( "Should have implemented this" )
         
     def delete_vminstance(self, vm_id):

-        '''Removes a VM instance from VIM'''
-        '''Returns the instance identifier'''
+        """Removes a VM instance from VIM
+        Returns the instance identifier"""

         raise vimconnNotImplemented( "Should have implemented this" )
 
     def refresh_vms_status(self, vm_list):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def refresh_vms_status(self, vm_list):

-        '''Get the status of the virtual machines and their interfaces/ports
+        """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
            Params: the list of VM identifiers
            Returns a dictionary with:
                 vm_id:          #VIM id of this Virtual Machine


@@ -355,27 +417,30 @@ class vimconnector():
                                 #  OTHER (Vim reported other status not understood)
                                 #  ERROR (VIM indicates an ERROR status)
                                 #  ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running), 
                                 #  OTHER (Vim reported other status not understood)
                                 #  ERROR (VIM indicates an ERROR status)
                                 #  ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running), 

-                                #  CREATING (on building process), ERROR
+                                #  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)
                                 #  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:
-                     -  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
                         mac_address:      #Text format XX:XX:XX:XX:XX:XX

-                        vim_net_id:       #network id where this interface is connected
+                        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
                         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):
         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'''
+        """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" )
     
         raise vimconnNotImplemented( "Should have implemented this" )
     

-    def get_vminstance_console(self,vm_id, console_type="vnc"):
-        '''
+    def get_vminstance_console(self, vm_id, console_type="vnc"):
+        """

         Get a console for the virtual machine
         Params:
             vm_id: uuid of the VM
         Get a console for the virtual machine
         Params:
             vm_id: uuid of the VM


@@ -387,53 +452,53 @@ class vimconnector():
                 server:   usually ip address 
                 port:     the http, ssh, ... port 
                 suffix:   extra text, e.g. the http path and query string   
                 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):
         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,
+        """Transform host dictionary from VIM format to GUI format,

         and append to the server_dict
         and append to the server_dict

-        '''
+        """

         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_hosts_info(self):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_hosts_info(self):

-        '''Get the information of deployed hosts
-        Returns the hosts content'''
+        """Get the information of deployed hosts
+        Returns the hosts content"""

         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_hosts(self, vim_tenant):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_hosts(self, vim_tenant):

-        '''Get the hosts and deployed instances
-        Returns the hosts content'''
+        """Get the hosts and deployed instances
+        Returns the hosts content"""

         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_processor_rankings(self):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def get_processor_rankings(self):

-        '''Get the processor rankings in the VIM database'''
+        """Get the processor rankings in the VIM database"""

         raise vimconnNotImplemented( "Should have implemented this" )
     
     def new_host(self, host_data):
         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'''
+        """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):
         raise vimconnNotImplemented( "Should have implemented this" )
     
     def new_external_port(self, port_data):

-        '''Adds a external port to VIM'''
-        '''Returns the port identifier'''
+        """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):
         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'''
+        """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):
         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'''
+        """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):
         raise vimconnNotImplemented( "Should have implemented this" )
 
     def new_vminstancefromJSON(self, vm_data):

-        '''Adds a VM instance to VIM'''
-        '''Returns the instance identifier'''
+        """Adds a VM instance to VIM"""
+        """Returns the instance identifier"""

         raise vimconnNotImplemented( "Should have implemented this" )
 
         raise vimconnNotImplemented( "Should have implemented this" )
 

diff --git a/vimconn_openvim.py b/vimconn_openvim.py
index fb59ecc..9d6748a 100644 (file)
--- a/vimconn_openvim.py
+++ b/vimconn_openvim.py
@@ -481,7 +481,7 @@ class vimconnector(vimconn.vimconnector):
         except requests.exceptions.RequestException as e:
             self._format_request_exception(e)
 
         except requests.exceptions.RequestException as e:
             self._format_request_exception(e)
 

-    def new_network(self,net_name, net_type, ip_profile=None, shared=False, **vim_specific):
+    def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None): #, **vim_specific):

         '''Adds a tenant network to VIM'''
         '''Returns the network identifier'''
         try:
         '''Adds a tenant network to VIM'''
         '''Returns the network identifier'''
         try:


@@ -489,7 +489,9 @@ class vimconnector(vimconn.vimconnector):
             if net_type=="bridge":
                 net_type="bridge_data"
             payload_req = {"name": net_name, "type": net_type, "tenant_id": self.tenant, "shared": shared}
             if net_type=="bridge":
                 net_type="bridge_data"
             payload_req = {"name": net_name, "type": net_type, "tenant_id": self.tenant, "shared": shared}

-            payload_req.update(vim_specific)
+            if vlan:
+                payload_req["provider:vlan"] = vlan
+            # payload_req.update(vim_specific)

             url = self.url+'/networks'
             self.logger.info("Adding a new network POST: %s  DATA: %s", url, str(payload_req))
             vim_response = requests.post(url, headers = self.headers_req, data=json.dumps({"network": payload_req}) )
             url = self.url+'/networks'
             self.logger.info("Adding a new network POST: %s  DATA: %s", url, str(payload_req))
             vim_response = requests.post(url, headers = self.headers_req, data=json.dumps({"network": payload_req}) )