osm_ro/vimconn_openstack.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
   5 # This file is part of openmano
   6 # All Rights Reserved.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   9 # not use this file except in compliance with the License. You may obtain
  10 # a copy of the License at
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  17 # License for the specific language governing permissions and limitations
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact with: nfvlabs@tid.es
  22 ##
  23
  24 '''
  25 osconnector implements all the methods to interact with openstack using the python-neutronclient.
  26
  27 For the VNF forwarding graph, The OpenStack VIM connector calls the
  28 networking-sfc Neutron extension methods, whose resources are mapped
  29 to the VIM connector's SFC resources as follows:
  30 - Classification (OSM) -> Flow Classifier (Neutron)
  31 - Service Function Instance (OSM) -> Port Pair (Neutron)
  32 - Service Function (OSM) -> Port Pair Group (Neutron)
  33 - Service Function Path (OSM) -> Port Chain (Neutron)
  34 '''
  35 __author__ = "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C."
  36 __date__  = "$22-sep-2017 23:59:59$"
  37
  38 import vimconn
  39 # import json
  40 import logging
  41 import netaddr
  42 import time
  43 import yaml
  44 import random
  45 import re
  46 import copy
  47
  48 from novaclient import client as nClient, exceptions as nvExceptions
  49 from keystoneauth1.identity import v2, v3
  50 from keystoneauth1 import session
  51 import keystoneclient.exceptions as ksExceptions
  52 import keystoneclient.v3.client as ksClient_v3
  53 import keystoneclient.v2_0.client as ksClient_v2
  54 from glanceclient import client as glClient
  55 import glanceclient.client as gl1Client
  56 import glanceclient.exc as gl1Exceptions
  57 from  cinderclient import client as cClient
  58 from httplib import HTTPException
  59 from neutronclient.neutron import client as neClient
  60 from neutronclient.common import exceptions as neExceptions
  61 from requests.exceptions import ConnectionError
  62
  63
  64 """contain the openstack virtual machine status to openmano status"""
  65 vmStatus2manoFormat={'ACTIVE':'ACTIVE',
  66                      'PAUSED':'PAUSED',
  67                      'SUSPENDED': 'SUSPENDED',
  68                      'SHUTOFF':'INACTIVE',
  69                      'BUILD':'BUILD',
  70                      'ERROR':'ERROR','DELETED':'DELETED'
  71                      }
  72 netStatus2manoFormat={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
  73                      }
  74
  75 supportedClassificationTypes = ['legacy_flow_classifier']
  76
  77 #global var to have a timeout creating and deleting volumes
  78 volume_timeout = 600
  79 server_timeout = 600
  80
  81 class vimconnector(vimconn.vimconnector):
  82     def __init__(self, uuid, name, tenant_id, tenant_name, url, url_admin=None, user=None, passwd=None,
  83                  log_level=None, config={}, persistent_info={}):
  84         '''using common constructor parameters. In this case
  85         'url' is the keystone authorization url,
  86         'url_admin' is not use
  87         '''
  88         api_version = config.get('APIversion')
  89         if api_version and api_version not in ('v3.3', 'v2.0', '2', '3'):
  90             raise vimconn.vimconnException("Invalid value '{}' for config:APIversion. "
  91                                            "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version))
  92         vim_type = config.get('vim_type')
  93         if vim_type and vim_type not in ('vio', 'VIO'):
  94             raise vimconn.vimconnException("Invalid value '{}' for config:vim_type."
  95                             "Allowed values are 'vio' or 'VIO'".format(vim_type))
  96
  97         if config.get('dataplane_net_vlan_range') is not None:
  98             #validate vlan ranges provided by user
  99             self._validate_vlan_ranges(config.get('dataplane_net_vlan_range'))
 100
 101         vimconn.vimconnector.__init__(self, uuid, name, tenant_id, tenant_name, url, url_admin, user, passwd, log_level,
 102                                       config)
 103
 104         self.insecure = self.config.get("insecure", False)
 105         if not url:
 106             raise TypeError('url param can not be NoneType')
 107         self.persistent_info = persistent_info
 108         self.availability_zone = persistent_info.get('availability_zone', None)
 109         self.session = persistent_info.get('session', {'reload_client': True})
 110         self.nova = self.session.get('nova')
 111         self.neutron = self.session.get('neutron')
 112         self.cinder = self.session.get('cinder')
 113         self.glance = self.session.get('glance')
 114         self.glancev1 = self.session.get('glancev1')
 115         self.keystone = self.session.get('keystone')
 116         self.api_version3 = self.session.get('api_version3')
 117         self.vim_type = self.config.get("vim_type")
 118         if self.vim_type:
 119             self.vim_type = self.vim_type.upper()
 120         if self.config.get("use_internal_endpoint"):
 121             self.endpoint_type = "internalURL"
 122         else:
 123             self.endpoint_type = None
 124
 125         self.logger = logging.getLogger('openmano.vim.openstack')
 126
 127         ####### VIO Specific Changes #########
 128         if self.vim_type == "VIO":
 129             self.logger = logging.getLogger('openmano.vim.vio')
 130
 131         if log_level:
 132             self.logger.setLevel( getattr(logging, log_level))
 133
 134     def __getitem__(self, index):
 135         """Get individuals parameters.
 136         Throw KeyError"""
 137         if index == 'project_domain_id':
 138             return self.config.get("project_domain_id")
 139         elif index == 'user_domain_id':
 140             return self.config.get("user_domain_id")
 141         else:
 142             return vimconn.vimconnector.__getitem__(self, index)
 143
 144     def __setitem__(self, index, value):
 145         """Set individuals parameters and it is marked as dirty so to force connection reload.
 146         Throw KeyError"""
 147         if index == 'project_domain_id':
 148             self.config["project_domain_id"] = value
 149         elif index == 'user_domain_id':
 150                 self.config["user_domain_id"] = value
 151         else:
 152             vimconn.vimconnector.__setitem__(self, index, value)
 153         self.session['reload_client'] = True
 154
 155     def _reload_connection(self):
 156         '''Called before any operation, it check if credentials has changed
 157         Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
 158         '''
 159         #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
 160         if self.session['reload_client']:
 161             if self.config.get('APIversion'):
 162                 self.api_version3 = self.config['APIversion'] == 'v3.3' or self.config['APIversion'] == '3'
 163             else:  # get from ending auth_url that end with v3 or with v2.0
 164                 self.api_version3 =  self.url.endswith("/v3") or self.url.endswith("/v3/")
 165             self.session['api_version3'] = self.api_version3
 166             if self.api_version3:
 167                 if self.config.get('project_domain_id') or self.config.get('project_domain_name'):
 168                     project_domain_id_default = None
 169                 else:
 170                     project_domain_id_default = 'default'
 171                 if self.config.get('user_domain_id') or self.config.get('user_domain_name'):
 172                     user_domain_id_default = None
 173                 else:
 174                     user_domain_id_default = 'default'
 175                 auth = v3.Password(auth_url=self.url,
 176                                    username=self.user,
 177                                    password=self.passwd,
 178                                    project_name=self.tenant_name,
 179                                    project_id=self.tenant_id,
 180                                    project_domain_id=self.config.get('project_domain_id', project_domain_id_default),
 181                                    user_domain_id=self.config.get('user_domain_id', user_domain_id_default),
 182                                    project_domain_name=self.config.get('project_domain_name'),
 183                                    user_domain_name=self.config.get('user_domain_name'))
 184             else:
 185                 auth = v2.Password(auth_url=self.url,
 186                                    username=self.user,
 187                                    password=self.passwd,
 188                                    tenant_name=self.tenant_name,
 189                                    tenant_id=self.tenant_id)
 190             sess = session.Session(auth=auth, verify=not self.insecure)
 191             if self.api_version3:
 192                 self.keystone = ksClient_v3.Client(session=sess, endpoint_type=self.endpoint_type)
 193             else:
 194                 self.keystone = ksClient_v2.Client(session=sess, endpoint_type=self.endpoint_type)
 195             self.session['keystone'] = self.keystone
 196             # In order to enable microversion functionality an explicit microversion must be specified in 'config'.
 197             # This implementation approach is due to the warning message in
 198             # https://developer.openstack.org/api-guide/compute/microversions.html
 199             # where it is stated that microversion backwards compatibility is not guaranteed and clients should
 200             # always require an specific microversion.
 201             # To be able to use 'device role tagging' functionality define 'microversion: 2.32' in datacenter config
 202             version = self.config.get("microversion")
 203             if not version:
 204                 version = "2.1"
 205             self.nova = self.session['nova'] = nClient.Client(str(version), session=sess, endpoint_type=self.endpoint_type)
 206             self.neutron = self.session['neutron'] = neClient.Client('2.0', session=sess, endpoint_type=self.endpoint_type)
 207             self.cinder = self.session['cinder'] = cClient.Client(2, session=sess, endpoint_type=self.endpoint_type)
 208             if self.endpoint_type == "internalURL":
 209                 glance_service_id = self.keystone.services.list(name="glance")[0].id
 210                 glance_endpoint = self.keystone.endpoints.list(glance_service_id, interface="internal")[0].url
 211             else:
 212                 glance_endpoint = None
 213             self.glance = self.session['glance'] = glClient.Client(2, session=sess, endpoint=glance_endpoint)
 214             #using version 1 of glance client in new_image()
 215             self.glancev1 = self.session['glancev1'] = glClient.Client('1', session=sess,
 216                                                                        endpoint=glance_endpoint)
 217             self.session['reload_client'] = False
 218             self.persistent_info['session'] = self.session
 219             # add availablity zone info inside  self.persistent_info
 220             self._set_availablity_zones()
 221             self.persistent_info['availability_zone'] = self.availability_zone
 222
 223     def __net_os2mano(self, net_list_dict):
 224         '''Transform the net openstack format to mano format
 225         net_list_dict can be a list of dict or a single dict'''
 226         if type(net_list_dict) is dict:
 227             net_list_=(net_list_dict,)
 228         elif type(net_list_dict) is list:
 229             net_list_=net_list_dict
 230         else:
 231             raise TypeError("param net_list_dict must be a list or a dictionary")
 232         for net in net_list_:
 233             if net.get('provider:network_type') == "vlan":
 234                 net['type']='data'
 235             else:
 236                 net['type']='bridge'
 237
 238     def __classification_os2mano(self, class_list_dict):
 239         """Transform the openstack format (Flow Classifier) to mano format
 240         (Classification) class_list_dict can be a list of dict or a single dict
 241         """
 242         if isinstance(class_list_dict, dict):
 243             class_list_ = [class_list_dict]
 244         elif isinstance(class_list_dict, list):
 245             class_list_ = class_list_dict
 246         else:
 247             raise TypeError(
 248                 "param class_list_dict must be a list or a dictionary")
 249         for classification in class_list_:
 250             id = classification.pop('id')
 251             name = classification.pop('name')
 252             description = classification.pop('description')
 253             project_id = classification.pop('project_id')
 254             tenant_id = classification.pop('tenant_id')
 255             original_classification = copy.deepcopy(classification)
 256             classification.clear()
 257             classification['ctype'] = 'legacy_flow_classifier'
 258             classification['definition'] = original_classification
 259             classification['id'] = id
 260             classification['name'] = name
 261             classification['description'] = description
 262             classification['project_id'] = project_id
 263             classification['tenant_id'] = tenant_id
 264
 265     def __sfi_os2mano(self, sfi_list_dict):
 266         """Transform the openstack format (Port Pair) to mano format (SFI)
 267         sfi_list_dict can be a list of dict or a single dict
 268         """
 269         if isinstance(sfi_list_dict, dict):
 270             sfi_list_ = [sfi_list_dict]
 271         elif isinstance(sfi_list_dict, list):
 272             sfi_list_ = sfi_list_dict
 273         else:
 274             raise TypeError(
 275                 "param sfi_list_dict must be a list or a dictionary")
 276         for sfi in sfi_list_:
 277             sfi['ingress_ports'] = []
 278             sfi['egress_ports'] = []
 279             if sfi.get('ingress'):
 280                 sfi['ingress_ports'].append(sfi['ingress'])
 281             if sfi.get('egress'):
 282                 sfi['egress_ports'].append(sfi['egress'])
 283             del sfi['ingress']
 284             del sfi['egress']
 285             params = sfi.get('service_function_parameters')
 286             sfc_encap = False
 287             if params:
 288                 correlation = params.get('correlation')
 289                 if correlation:
 290                     sfc_encap = True
 291             sfi['sfc_encap'] = sfc_encap
 292             del sfi['service_function_parameters']
 293
 294     def __sf_os2mano(self, sf_list_dict):
 295         """Transform the openstack format (Port Pair Group) to mano format (SF)
 296         sf_list_dict can be a list of dict or a single dict
 297         """
 298         if isinstance(sf_list_dict, dict):
 299             sf_list_ = [sf_list_dict]
 300         elif isinstance(sf_list_dict, list):
 301             sf_list_ = sf_list_dict
 302         else:
 303             raise TypeError(
 304                 "param sf_list_dict must be a list or a dictionary")
 305         for sf in sf_list_:
 306             del sf['port_pair_group_parameters']
 307             sf['sfis'] = sf['port_pairs']
 308             del sf['port_pairs']
 309
 310     def __sfp_os2mano(self, sfp_list_dict):
 311         """Transform the openstack format (Port Chain) to mano format (SFP)
 312         sfp_list_dict can be a list of dict or a single dict
 313         """
 314         if isinstance(sfp_list_dict, dict):
 315             sfp_list_ = [sfp_list_dict]
 316         elif isinstance(sfp_list_dict, list):
 317             sfp_list_ = sfp_list_dict
 318         else:
 319             raise TypeError(
 320                 "param sfp_list_dict must be a list or a dictionary")
 321         for sfp in sfp_list_:
 322             params = sfp.pop('chain_parameters')
 323             sfc_encap = False
 324             if params:
 325                 correlation = params.get('correlation')
 326                 if correlation:
 327                     sfc_encap = True
 328             sfp['sfc_encap'] = sfc_encap
 329             sfp['spi'] = sfp.pop('chain_id')
 330             sfp['classifications'] = sfp.pop('flow_classifiers')
 331             sfp['service_functions'] = sfp.pop('port_pair_groups')
 332
 333     # placeholder for now; read TODO note below
 334     def _validate_classification(self, type, definition):
 335         # only legacy_flow_classifier Type is supported at this point
 336         return True
 337         # TODO(igordcard): this method should be an abstract method of an
 338         # abstract Classification class to be implemented by the specific
 339         # Types. Also, abstract vimconnector should call the validation
 340         # method before the implemented VIM connectors are called.
 341
 342     def _format_exception(self, exception):
 343         '''Transform a keystone, nova, neutron  exception into a vimconn exception'''
 344         if isinstance(exception, (HTTPException, gl1Exceptions.HTTPException, gl1Exceptions.CommunicationError,
 345                                   ConnectionError, ksExceptions.ConnectionError, neExceptions.ConnectionFailed
 346                                   )):
 347             raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + str(exception))
 348         elif isinstance(exception, (nvExceptions.ClientException, ksExceptions.ClientException,
 349                                     neExceptions.NeutronException, nvExceptions.BadRequest)):
 350             raise vimconn.vimconnUnexpectedResponse(type(exception).__name__ + ": " + str(exception))
 351         elif isinstance(exception, (neExceptions.NetworkNotFoundClient, nvExceptions.NotFound)):
 352             raise vimconn.vimconnNotFoundException(type(exception).__name__ + ": " + str(exception))
 353         elif isinstance(exception, nvExceptions.Conflict):
 354             raise vimconn.vimconnConflictException(type(exception).__name__ + ": " + str(exception))
 355         elif isinstance(exception, vimconn.vimconnException):
 356             raise
 357         else:  # ()
 358             self.logger.error("General Exception " + str(exception), exc_info=True)
 359             raise vimconn.vimconnConnectionException(type(exception).__name__ + ": " + str(exception))
 360
 361     def get_tenant_list(self, filter_dict={}):
 362         '''Obtain tenants of VIM
 363         filter_dict can contain the following keys:
 364             name: filter by tenant name
 365             id: filter by tenant uuid/id
 366             <other VIM specific>
 367         Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
 368         '''
 369         self.logger.debug("Getting tenants from VIM filter: '%s'", str(filter_dict))
 370         try:
 371             self._reload_connection()
 372             if self.api_version3:
 373                 project_class_list = self.keystone.projects.list(name=filter_dict.get("name"))
 374             else:
 375                 project_class_list = self.keystone.tenants.findall(**filter_dict)
 376             project_list=[]
 377             for project in project_class_list:
 378                 if filter_dict.get('id') and filter_dict["id"] != project.id:
 379                     continue
 380                 project_list.append(project.to_dict())
 381             return project_list
 382         except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError) as e:
 383             self._format_exception(e)
 384
 385     def new_tenant(self, tenant_name, tenant_description):
 386         '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
 387         self.logger.debug("Adding a new tenant name: %s", tenant_name)
 388         try:
 389             self._reload_connection()
 390             if self.api_version3:
 391                 project = self.keystone.projects.create(tenant_name, self.config.get("project_domain_id", "default"),
 392                                                         description=tenant_description, is_domain=False)
 393             else:
 394                 project = self.keystone.tenants.create(tenant_name, tenant_description)
 395             return project.id
 396         except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError)  as e:
 397             self._format_exception(e)
 398
 399     def delete_tenant(self, tenant_id):
 400         '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
 401         self.logger.debug("Deleting tenant %s from VIM", tenant_id)
 402         try:
 403             self._reload_connection()
 404             if self.api_version3:
 405                 self.keystone.projects.delete(tenant_id)
 406             else:
 407                 self.keystone.tenants.delete(tenant_id)
 408             return tenant_id
 409         except (ksExceptions.ConnectionError, ksExceptions.ClientException, ConnectionError)  as e:
 410             self._format_exception(e)
 411
 412     def new_network(self,net_name, net_type, ip_profile=None, shared=False, vlan=None):
 413         '''Adds a tenant network to VIM. Returns the network identifier'''
 414         self.logger.debug("Adding a new network to VIM name '%s', type '%s'", net_name, net_type)
 415         #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
 416         try:
 417             new_net = None
 418             self._reload_connection()
 419             network_dict = {'name': net_name, 'admin_state_up': True}
 420             if net_type=="data" or net_type=="ptp":
 421                 if self.config.get('dataplane_physical_net') == None:
 422                     raise vimconn.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
 423                 network_dict["provider:physical_network"] = self.config['dataplane_physical_net'] #"physnet_sriov" #TODO physical
 424                 network_dict["provider:network_type"]     = "vlan"
 425                 if vlan!=None:
 426                     network_dict["provider:network_type"] = vlan
 427
 428                 ####### VIO Specific Changes #########
 429                 if self.vim_type == "VIO":
 430                     if vlan is not None:
 431                         network_dict["provider:segmentation_id"] = vlan
 432                     else:
 433                         if self.config.get('dataplane_net_vlan_range') is None:
 434                             raise vimconn.vimconnConflictException("You must provide "\
 435                                 "'dataplane_net_vlan_range' in format [start_ID - end_ID]"\
 436                                 "at config value before creating sriov network with vlan tag")
 437
 438                         network_dict["provider:segmentation_id"] = self._genrate_vlanID()
 439
 440             network_dict["shared"]=shared
 441             new_net=self.neutron.create_network({'network':network_dict})
 442             #print new_net
 443             #create subnetwork, even if there is no profile
 444             if not ip_profile:
 445                 ip_profile = {}
 446             if 'subnet_address' not in ip_profile:
 447                 #Fake subnet is required
 448                 subnet_rand = random.randint(0, 255)
 449                 ip_profile['subnet_address'] = "192.168.{}.0/24".format(subnet_rand)
 450             if 'ip_version' not in ip_profile:
 451                 ip_profile['ip_version'] = "IPv4"
 452             subnet = {"name":net_name+"-subnet",
 453                     "network_id": new_net["network"]["id"],
 454                     "ip_version": 4 if ip_profile['ip_version']=="IPv4" else 6,
 455                     "cidr": ip_profile['subnet_address']
 456                     }
 457             # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
 458             subnet['gateway_ip'] = ip_profile.get('gateway_address')
 459             if ip_profile.get('dns_address'):
 460                 subnet['dns_nameservers'] = ip_profile['dns_address'].split(";")
 461             if 'dhcp_enabled' in ip_profile:
 462                 subnet['enable_dhcp'] = False if ip_profile['dhcp_enabled']=="false" else True
 463             if 'dhcp_start_address' in ip_profile:
 464                 subnet['allocation_pools'] = []
 465                 subnet['allocation_pools'].append(dict())
 466                 subnet['allocation_pools'][0]['start'] = ip_profile['dhcp_start_address']
 467             if 'dhcp_count' in ip_profile:
 468                 #parts = ip_profile['dhcp_start_address'].split('.')
 469                 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
 470                 ip_int = int(netaddr.IPAddress(ip_profile['dhcp_start_address']))
 471                 ip_int += ip_profile['dhcp_count'] - 1
 472                 ip_str = str(netaddr.IPAddress(ip_int))
 473                 subnet['allocation_pools'][0]['end'] = ip_str
 474             #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
 475             self.neutron.create_subnet({"subnet": subnet} )
 476             return new_net["network"]["id"]
 477         except (neExceptions.ConnectionFailed, ksExceptions.ClientException, neExceptions.NeutronException, ConnectionError) as e:
 478             if new_net:
 479                 self.neutron.delete_network(new_net['network']['id'])
 480             self._format_exception(e)
 481
 482     def get_network_list(self, filter_dict={}):
 483         '''Obtain tenant networks of VIM
 484         Filter_dict can be:
 485             name: network name
 486             id: network uuid
 487             shared: boolean
 488             tenant_id: tenant
 489             admin_state_up: boolean
 490             status: 'ACTIVE'
 491         Returns the network list of dictionaries
 492         '''
 493         self.logger.debug("Getting network from VIM filter: '%s'", str(filter_dict))
 494         try:
 495             self._reload_connection()
 496             filter_dict_os = filter_dict.copy()
 497             if self.api_version3 and "tenant_id" in filter_dict_os:
 498                 filter_dict_os['project_id'] = filter_dict_os.pop('tenant_id')  #T ODO check
 499             net_dict = self.neutron.list_networks(**filter_dict_os)
 500             net_list = net_dict["networks"]
 501             self.__net_os2mano(net_list)
 502             return net_list
 503         except (neExceptions.ConnectionFailed, ksExceptions.ClientException, neExceptions.NeutronException, ConnectionError) as e:
 504             self._format_exception(e)
 505
 506     def get_network(self, net_id):
 507         '''Obtain details of network from VIM
 508         Returns the network information from a network id'''
 509         self.logger.debug(" Getting tenant network %s from VIM", net_id)
 510         filter_dict={"id": net_id}
 511         net_list = self.get_network_list(filter_dict)
 512         if len(net_list)==0:
 513             raise vimconn.vimconnNotFoundException("Network '{}' not found".format(net_id))
 514         elif len(net_list)>1:
 515             raise vimconn.vimconnConflictException("Found more than one network with this criteria")
 516         net = net_list[0]
 517         subnets=[]
 518         for subnet_id in net.get("subnets", () ):
 519             try:
 520                 subnet = self.neutron.show_subnet(subnet_id)
 521             except Exception as e:
 522                 self.logger.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id, str(e)))
 523                 subnet = {"id": subnet_id, "fault": str(e)}
 524             subnets.append(subnet)
 525         net["subnets"] = subnets
 526         net["encapsulation"] = net.get('provider:network_type')
 527         net["segmentation_id"] = net.get('provider:segmentation_id')
 528         return net
 529
 530     def delete_network(self, net_id):
 531         '''Deletes a tenant network from VIM. Returns the old network identifier'''
 532         self.logger.debug("Deleting network '%s' from VIM", net_id)
 533         try:
 534             self._reload_connection()
 535             #delete VM ports attached to this networks before the network
 536             ports = self.neutron.list_ports(network_id=net_id)
 537             for p in ports['ports']:
 538                 try:
 539                     self.neutron.delete_port(p["id"])
 540                 except Exception as e:
 541                     self.logger.error("Error deleting port %s: %s", p["id"], str(e))
 542             self.neutron.delete_network(net_id)
 543             return net_id
 544         except (neExceptions.ConnectionFailed, neExceptions.NetworkNotFoundClient, neExceptions.NeutronException,
 545                 ksExceptions.ClientException, neExceptions.NeutronException, ConnectionError) as e:
 546             self._format_exception(e)
 547
 548     def refresh_nets_status(self, net_list):
 549         '''Get the status of the networks
 550            Params: the list of network identifiers
 551            Returns a dictionary with:
 552                 net_id:         #VIM id of this network
 553                     status:     #Mandatory. Text with one of:
 554                                 #  DELETED (not found at vim)
 555                                 #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
 556                                 #  OTHER (Vim reported other status not understood)
 557                                 #  ERROR (VIM indicates an ERROR status)
 558                                 #  ACTIVE, INACTIVE, DOWN (admin down),
 559                                 #  BUILD (on building process)
 560                                 #
 561                     error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
 562                     vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
 563
 564         '''
 565         net_dict={}
 566         for net_id in net_list:
 567             net = {}
 568             try:
 569                 net_vim = self.get_network(net_id)
 570                 if net_vim['status'] in netStatus2manoFormat:
 571                     net["status"] = netStatus2manoFormat[ net_vim['status'] ]
 572                 else:
 573                     net["status"] = "OTHER"
 574                     net["error_msg"] = "VIM status reported " + net_vim['status']
 575
 576                 if net['status'] == "ACTIVE" and not net_vim['admin_state_up']:
 577                     net['status'] = 'DOWN'
 578                 try:
 579                     net['vim_info'] = yaml.safe_dump(net_vim, default_flow_style=True, width=256)
 580                 except yaml.representer.RepresenterError:
 581                     net['vim_info'] = str(net_vim)
 582                 if net_vim.get('fault'):  #TODO
 583                     net['error_msg'] = str(net_vim['fault'])
 584             except vimconn.vimconnNotFoundException as e:
 585                 self.logger.error("Exception getting net status: %s", str(e))
 586                 net['status'] = "DELETED"
 587                 net['error_msg'] = str(e)
 588             except vimconn.vimconnException as e:
 589                 self.logger.error("Exception getting net status: %s", str(e))
 590                 net['status'] = "VIM_ERROR"
 591                 net['error_msg'] = str(e)
 592             net_dict[net_id] = net
 593         return net_dict
 594
 595     def get_flavor(self, flavor_id):
 596         '''Obtain flavor details from the  VIM. Returns the flavor dict details'''
 597         self.logger.debug("Getting flavor '%s'", flavor_id)
 598         try:
 599             self._reload_connection()
 600             flavor = self.nova.flavors.find(id=flavor_id)
 601             #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
 602             return flavor.to_dict()
 603         except (nvExceptions.NotFound, nvExceptions.ClientException, ksExceptions.ClientException, ConnectionError) as e:
 604             self._format_exception(e)
 605
 606     def get_flavor_id_from_data(self, flavor_dict):
 607         """Obtain flavor id that match the flavor description
 608            Returns the flavor_id or raises a vimconnNotFoundException
 609            flavor_dict: contains the required ram, vcpus, disk
 610            If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
 611                 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
 612                 vimconnNotFoundException is raised
 613         """
 614         exact_match = False if self.config.get('use_existing_flavors') else True
 615         try:
 616             self._reload_connection()
 617             flavor_candidate_id = None
 618             flavor_candidate_data = (10000, 10000, 10000)
 619             flavor_target = (flavor_dict["ram"], flavor_dict["vcpus"], flavor_dict["disk"])
 620             # numa=None
 621             numas = flavor_dict.get("extended", {}).get("numas")
 622             if numas:
 623                 #TODO
 624                 raise vimconn.vimconnNotFoundException("Flavor with EPA still not implemted")
 625                 # if len(numas) > 1:
 626                 #     raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
 627                 # numa=numas[0]
 628                 # numas = extended.get("numas")
 629             for flavor in self.nova.flavors.list():
 630                 epa = flavor.get_keys()
 631                 if epa:
 632                     continue
 633                     # TODO
 634                 flavor_data = (flavor.ram, flavor.vcpus, flavor.disk)
 635                 if flavor_data == flavor_target:
 636                     return flavor.id
 637                 elif not exact_match and flavor_target < flavor_data < flavor_candidate_data:
 638                     flavor_candidate_id = flavor.id
 639                     flavor_candidate_data = flavor_data
 640             if not exact_match and flavor_candidate_id:
 641                 return flavor_candidate_id
 642             raise vimconn.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict)))
 643         except (nvExceptions.NotFound, nvExceptions.ClientException, ksExceptions.ClientException, ConnectionError) as e:
 644             self._format_exception(e)
 645
 646     def new_flavor(self, flavor_data, change_name_if_used=True):
 647         '''Adds a tenant flavor to openstack VIM
 648         if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
 649         Returns the flavor identifier
 650         '''
 651         self.logger.debug("Adding flavor '%s'", str(flavor_data))
 652         retry=0
 653         max_retries=3
 654         name_suffix = 0
 655         name=flavor_data['name']
 656         while retry<max_retries:
 657             retry+=1
 658             try:
 659                 self._reload_connection()
 660                 if change_name_if_used:
 661                     #get used names
 662                     fl_names=[]
 663                     fl=self.nova.flavors.list()
 664                     for f in fl:
 665                         fl_names.append(f.name)
 666                     while name in fl_names:
 667                         name_suffix += 1
 668                         name = flavor_data['name']+"-" + str(name_suffix)
 669
 670                 ram = flavor_data.get('ram',64)
 671                 vcpus = flavor_data.get('vcpus',1)
 672                 numa_properties=None
 673
 674                 extended = flavor_data.get("extended")
 675                 if extended:
 676                     numas=extended.get("numas")
 677                     if numas:
 678                         numa_nodes = len(numas)
 679                         if numa_nodes > 1:
 680                             return -1, "Can not add flavor with more than one numa"
 681                         numa_properties = {"hw:numa_nodes":str(numa_nodes)}
 682                         numa_properties["hw:mem_page_size"] = "large"
 683                         numa_properties["hw:cpu_policy"] = "dedicated"
 684                         numa_properties["hw:numa_mempolicy"] = "strict"
 685                         if self.vim_type == "VIO":
 686                             numa_properties["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
 687                             numa_properties["vmware:latency_sensitivity_level"] = "high"
 688                         for numa in numas:
 689                             #overwrite ram and vcpus
 690                             #check if key 'memory' is present in numa else use ram value at flavor
 691                             if 'memory' in numa:
 692                                 ram = numa['memory']*1024
 693                             #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
 694                             if 'paired-threads' in numa:
 695                                 vcpus = numa['paired-threads']*2
 696                                 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
 697                                 numa_properties["hw:cpu_thread_policy"] = "require"
 698                                 numa_properties["hw:cpu_policy"] = "dedicated"
 699                             elif 'cores' in numa:
 700                                 vcpus = numa['cores']
 701                                 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
 702                                 numa_properties["hw:cpu_thread_policy"] = "isolate"
 703                                 numa_properties["hw:cpu_policy"] = "dedicated"
 704                             elif 'threads' in numa:
 705                                 vcpus = numa['threads']
 706                                 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
 707                                 numa_properties["hw:cpu_thread_policy"] = "prefer"
 708                                 numa_properties["hw:cpu_policy"] = "dedicated"
 709                             # for interface in numa.get("interfaces",() ):
 710                             #     if interface["dedicated"]=="yes":
 711                             #         raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
 712                             #     #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
 713
 714                 #create flavor
 715                 new_flavor=self.nova.flavors.create(name,
 716                                 ram,
 717                                 vcpus,
 718                                 flavor_data.get('disk',0),
 719                                 is_public=flavor_data.get('is_public', True)
 720                             )
 721                 #add metadata
 722                 if numa_properties:
 723                     new_flavor.set_keys(numa_properties)
 724                 return new_flavor.id
 725             except nvExceptions.Conflict as e:
 726                 if change_name_if_used and retry < max_retries:
 727                     continue
 728                 self._format_exception(e)
 729             #except nvExceptions.BadRequest as e:
 730             except (ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
 731                 self._format_exception(e)
 732
 733     def delete_flavor(self,flavor_id):
 734         '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
 735         '''
 736         try:
 737             self._reload_connection()
 738             self.nova.flavors.delete(flavor_id)
 739             return flavor_id
 740         #except nvExceptions.BadRequest as e:
 741         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
 742             self._format_exception(e)
 743
 744     def new_image(self,image_dict):
 745         '''
 746         Adds a tenant image to VIM. imge_dict is a dictionary with:
 747             name: name
 748             disk_format: qcow2, vhd, vmdk, raw (by default), ...
 749             location: path or URI
 750             public: "yes" or "no"
 751             metadata: metadata of the image
 752         Returns the image_id
 753         '''
 754         retry=0
 755         max_retries=3
 756         while retry<max_retries:
 757             retry+=1
 758             try:
 759                 self._reload_connection()
 760                 #determine format  http://docs.openstack.org/developer/glance/formats.html
 761                 if "disk_format" in image_dict:
 762                     disk_format=image_dict["disk_format"]
 763                 else: #autodiscover based on extension
 764                     if image_dict['location'][-6:]==".qcow2":
 765                         disk_format="qcow2"
 766                     elif image_dict['location'][-4:]==".vhd":
 767                         disk_format="vhd"
 768                     elif image_dict['location'][-5:]==".vmdk":
 769                         disk_format="vmdk"
 770                     elif image_dict['location'][-4:]==".vdi":
 771                         disk_format="vdi"
 772                     elif image_dict['location'][-4:]==".iso":
 773                         disk_format="iso"
 774                     elif image_dict['location'][-4:]==".aki":
 775                         disk_format="aki"
 776                     elif image_dict['location'][-4:]==".ari":
 777                         disk_format="ari"
 778                     elif image_dict['location'][-4:]==".ami":
 779                         disk_format="ami"
 780                     else:
 781                         disk_format="raw"
 782                 self.logger.debug("new_image: '%s' loading from '%s'", image_dict['name'], image_dict['location'])
 783                 if image_dict['location'][0:4]=="http":
 784                     new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
 785                             container_format="bare", location=image_dict['location'], disk_format=disk_format)
 786                 else: #local path
 787                     with open(image_dict['location']) as fimage:
 788                         new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
 789                             container_format="bare", data=fimage, disk_format=disk_format)
 790                 #insert metadata. We cannot use 'new_image.properties.setdefault'
 791                 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
 792                 new_image_nova=self.nova.images.find(id=new_image.id)
 793                 new_image_nova.metadata.setdefault('location',image_dict['location'])
 794                 metadata_to_load = image_dict.get('metadata')
 795                 if metadata_to_load:
 796                     for k,v in yaml.load(metadata_to_load).iteritems():
 797                         new_image_nova.metadata.setdefault(k,v)
 798                 return new_image.id
 799             except (nvExceptions.Conflict, ksExceptions.ClientException, nvExceptions.ClientException) as e:
 800                 self._format_exception(e)
 801             except (HTTPException, gl1Exceptions.HTTPException, gl1Exceptions.CommunicationError, ConnectionError) as e:
 802                 if retry==max_retries:
 803                     continue
 804                 self._format_exception(e)
 805             except IOError as e:  #can not open the file
 806                 raise vimconn.vimconnConnectionException(type(e).__name__ + ": " + str(e)+ " for " + image_dict['location'],
 807                                                          http_code=vimconn.HTTP_Bad_Request)
 808
 809     def delete_image(self, image_id):
 810         '''Deletes a tenant image from openstack VIM. Returns the old id
 811         '''
 812         try:
 813             self._reload_connection()
 814             self.nova.images.delete(image_id)
 815             return image_id
 816         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e: #TODO remove
 817             self._format_exception(e)
 818
 819     def get_image_id_from_path(self, path):
 820         '''Get the image id from image path in the VIM database. Returns the image_id'''
 821         try:
 822             self._reload_connection()
 823             images = self.nova.images.list()
 824             for image in images:
 825                 if image.metadata.get("location")==path:
 826                     return image.id
 827             raise vimconn.vimconnNotFoundException("image with location '{}' not found".format( path))
 828         except (ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e:
 829             self._format_exception(e)
 830
 831     def get_image_list(self, filter_dict={}):
 832         '''Obtain tenant images from VIM
 833         Filter_dict can be:
 834             id: image id
 835             name: image name
 836             checksum: image checksum
 837         Returns the image list of dictionaries:
 838             [{<the fields at Filter_dict plus some VIM specific>}, ...]
 839             List can be empty
 840         '''
 841         self.logger.debug("Getting image list from VIM filter: '%s'", str(filter_dict))
 842         try:
 843             self._reload_connection()
 844             filter_dict_os = filter_dict.copy()
 845             #First we filter by the available filter fields: name, id. The others are removed.
 846             filter_dict_os.pop('checksum', None)
 847             image_list = self.nova.images.findall(**filter_dict_os)
 848             if len(image_list) == 0:
 849                 return []
 850             #Then we filter by the rest of filter fields: checksum
 851             filtered_list = []
 852             for image in image_list:
 853                 try:
 854                     image_class = self.glance.images.get(image.id)
 855                     if 'checksum' not in filter_dict or image_class['checksum'] == filter_dict.get('checksum'):
 856                         filtered_list.append(image_class.copy())
 857                 except gl1Exceptions.HTTPNotFound:
 858                     pass
 859             return filtered_list
 860         except (ksExceptions.ClientException, nvExceptions.ClientException, gl1Exceptions.CommunicationError, ConnectionError) as e:
 861             self._format_exception(e)
 862
 863     def __wait_for_vm(self, vm_id, status):
 864         """wait until vm is in the desired status and return True.
 865         If the VM gets in ERROR status, return false.
 866         If the timeout is reached generate an exception"""
 867         elapsed_time = 0
 868         while elapsed_time < server_timeout:
 869             vm_status = self.nova.servers.get(vm_id).status
 870             if vm_status == status:
 871                 return True
 872             if vm_status == 'ERROR':
 873                 return False
 874             time.sleep(1)
 875             elapsed_time += 1
 876
 877         # if we exceeded the timeout rollback
 878         if elapsed_time >= server_timeout:
 879             raise vimconn.vimconnException('Timeout waiting for instance ' + vm_id + ' to get ' + status,
 880                                            http_code=vimconn.HTTP_Request_Timeout)
 881
 882     def _get_openstack_availablity_zones(self):
 883         """
 884         Get from openstack availability zones available
 885         :return:
 886         """
 887         try:
 888             openstack_availability_zone = self.nova.availability_zones.list()
 889             openstack_availability_zone = [str(zone.zoneName) for zone in openstack_availability_zone
 890                                            if zone.zoneName != 'internal']
 891             return openstack_availability_zone
 892         except Exception as e:
 893             return None
 894
 895     def _set_availablity_zones(self):
 896         """
 897         Set vim availablity zone
 898         :return:
 899         """
 900
 901         if 'availability_zone' in self.config:
 902             vim_availability_zones = self.config.get('availability_zone')
 903             if isinstance(vim_availability_zones, str):
 904                 self.availability_zone = [vim_availability_zones]
 905             elif isinstance(vim_availability_zones, list):
 906                 self.availability_zone = vim_availability_zones
 907         else:
 908             self.availability_zone = self._get_openstack_availablity_zones()
 909
 910     def _get_vm_availability_zone(self, availability_zone_index, availability_zone_list):
 911         """
 912         Return thge availability zone to be used by the created VM.
 913         :return: The VIM availability zone to be used or None
 914         """
 915         if availability_zone_index is None:
 916             if not self.config.get('availability_zone'):
 917                 return None
 918             elif isinstance(self.config.get('availability_zone'), str):
 919                 return self.config['availability_zone']
 920             else:
 921                 # TODO consider using a different parameter at config for default AV and AV list match
 922                 return self.config['availability_zone'][0]
 923
 924         vim_availability_zones = self.availability_zone
 925         # check if VIM offer enough availability zones describe in the VNFD
 926         if vim_availability_zones and len(availability_zone_list) <= len(vim_availability_zones):
 927             # check if all the names of NFV AV match VIM AV names
 928             match_by_index = False
 929             for av in availability_zone_list:
 930                 if av not in vim_availability_zones:
 931                     match_by_index = True
 932                     break
 933             if match_by_index:
 934                 return vim_availability_zones[availability_zone_index]
 935             else:
 936                 return availability_zone_list[availability_zone_index]
 937         else:
 938             raise vimconn.vimconnConflictException("No enough availability zones at VIM for this deployment")
 939
 940     def new_vminstance(self, name, description, start, image_id, flavor_id, net_list, cloud_config=None, disk_list=None,
 941                        availability_zone_index=None, availability_zone_list=None):
 942         """Adds a VM instance to VIM
 943         Params:
 944             start: indicates if VM must start or boot in pause mode. Ignored
 945             image_id,flavor_id: iamge and flavor uuid
 946             net_list: list of interfaces, each one is a dictionary with:
 947                 name:
 948                 net_id: network uuid to connect
 949                 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
 950                 model: interface model, ignored #TODO
 951                 mac_address: used for  SR-IOV ifaces #TODO for other types
 952                 use: 'data', 'bridge',  'mgmt'
 953                 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
 954                 vim_id: filled/added by this function
 955                 floating_ip: True/False (or it can be None)
 956                 'cloud_config': (optional) dictionary with:
 957                 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
 958                 'users': (optional) list of users to be inserted, each item is a dict with:
 959                     'name': (mandatory) user name,
 960                     'key-pairs': (optional) list of strings with the public key to be inserted to the user
 961                 'user-data': (optional) string is a text script to be passed directly to cloud-init
 962                 'config-files': (optional). List of files to be transferred. Each item is a dict with:
 963                     'dest': (mandatory) string with the destination absolute path
 964                     'encoding': (optional, by default text). Can be one of:
 965                         'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
 966                     'content' (mandatory): string with the content of the file
 967                     'permissions': (optional) string with file permissions, typically octal notation '0644'
 968                     'owner': (optional) file owner, string with the format 'owner:group'
 969                 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
 970             'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
 971                 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
 972                 'size': (mandatory) string with the size of the disk in GB
 973             availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
 974             availability_zone_list: list of availability zones given by user in the VNFD descriptor.  Ignore if
 975                 availability_zone_index is None
 976                 #TODO ip, security groups
 977         Returns a tuple with the instance identifier and created_items or raises an exception on error
 978             created_items can be None or a dictionary where this method can include key-values that will be passed to
 979             the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
 980             Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
 981             as not present.
 982         """
 983         self.logger.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id, flavor_id,str(net_list))
 984         try:
 985             server = None
 986             created_items = {}
 987             # metadata = {}
 988             net_list_vim = []
 989             external_network = []   # list of external networks to be connected to instance, later on used to create floating_ip
 990             no_secured_ports = []   # List of port-is with port-security disabled
 991             self._reload_connection()
 992             # metadata_vpci = {}   # For a specific neutron plugin
 993             block_device_mapping = None
 994             for net in net_list:
 995                 if not net.get("net_id"):   # skip non connected iface
 996                     continue
 997
 998                 port_dict={
 999                     "network_id": net["net_id"],
1000                     "name": net.get("name"),
1001                     "admin_state_up": True
1002                 }
1003                 if net["type"]=="virtual":
1004                     pass
1005                     # if "vpci" in net:
1006                     #     metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1007                 elif net["type"] == "VF" or net["type"] == "SR-IOV":  # for VF
1008                     # if "vpci" in net:
1009                     #     if "VF" not in metadata_vpci:
1010                     #         metadata_vpci["VF"]=[]
1011                     #     metadata_vpci["VF"].append([ net["vpci"], "" ])
1012                     port_dict["binding:vnic_type"]="direct"
1013                     # VIO specific Changes
1014                     if self.vim_type == "VIO":
1015                         # Need to create port with port_security_enabled = False and no-security-groups
1016                         port_dict["port_security_enabled"]=False
1017                         port_dict["provider_security_groups"]=[]
1018                         port_dict["security_groups"]=[]
1019                 else:   # For PT PCI-PASSTHROUGH
1020                     # VIO specific Changes
1021                     # Current VIO release does not support port with type 'direct-physical'
1022                     # So no need to create virtual port in case of PCI-device.
1023                     # Will update port_dict code when support gets added in next VIO release
1024                     if self.vim_type == "VIO":
1025                         raise vimconn.vimconnNotSupportedException(
1026                             "Current VIO release does not support full passthrough (PT)")
1027                     # if "vpci" in net:
1028                     #     if "PF" not in metadata_vpci:
1029                     #         metadata_vpci["PF"]=[]
1030                     #     metadata_vpci["PF"].append([ net["vpci"], "" ])
1031                     port_dict["binding:vnic_type"]="direct-physical"
1032                 if not port_dict["name"]:
1033                     port_dict["name"]=name
1034                 if net.get("mac_address"):
1035                     port_dict["mac_address"]=net["mac_address"]
1036                 new_port = self.neutron.create_port({"port": port_dict })
1037                 created_items["port:" + str(new_port["port"]["id"])] = True
1038                 net["mac_adress"] = new_port["port"]["mac_address"]
1039                 net["vim_id"] = new_port["port"]["id"]
1040                 # if try to use a network without subnetwork, it will return a emtpy list
1041                 fixed_ips = new_port["port"].get("fixed_ips")
1042                 if fixed_ips:
1043                     net["ip"] = fixed_ips[0].get("ip_address")
1044                 else:
1045                     net["ip"] = None
1046
1047                 port = {"port-id": new_port["port"]["id"]}
1048                 if float(self.nova.api_version.get_string()) >= 2.32:
1049                     port["tag"] = new_port["port"]["name"]
1050                 net_list_vim.append(port)
1051
1052                 if net.get('floating_ip', False):
1053                     net['exit_on_floating_ip_error'] = True
1054                     external_network.append(net)
1055                 elif net['use'] == 'mgmt' and self.config.get('use_floating_ip'):
1056                     net['exit_on_floating_ip_error'] = False
1057                     external_network.append(net)
1058
1059                 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1060                 # As a workaround we wait until the VM is active and then disable the port-security
1061                 if net.get("port_security") == False:
1062                     no_secured_ports.append(new_port["port"]["id"])
1063
1064             # if metadata_vpci:
1065             #     metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1066             #     if len(metadata["pci_assignement"]) >255:
1067             #         #limit the metadata size
1068             #         #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1069             #         self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1070             #         metadata = {}
1071
1072             self.logger.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1073                               name, image_id, flavor_id, str(net_list_vim), description)
1074
1075             security_groups = self.config.get('security_groups')
1076             if type(security_groups) is str:
1077                 security_groups = ( security_groups, )
1078             # cloud config
1079             config_drive, userdata = self._create_user_data(cloud_config)
1080
1081             # Create additional volumes in case these are present in disk_list
1082             base_disk_index = ord('b')
1083             if disk_list != None:
1084                 block_device_mapping = {}
1085                 for disk in disk_list:
1086                     if 'image_id' in disk:
1087                         volume = self.cinder.volumes.create(size = disk['size'],name = name + '_vd' +
1088                                     chr(base_disk_index), imageRef = disk['image_id'])
1089                     else:
1090                         volume = self.cinder.volumes.create(size=disk['size'], name=name + '_vd' +
1091                                     chr(base_disk_index))
1092                     created_items["volume:" + str(volume.id)] = True
1093                     block_device_mapping['_vd' +  chr(base_disk_index)] = volume.id
1094                     base_disk_index += 1
1095
1096                 # Wait until volumes are with status available
1097                 keep_waiting = True
1098                 elapsed_time = 0
1099                 while keep_waiting and elapsed_time < volume_timeout:
1100                     keep_waiting = False
1101                     for volume_id in block_device_mapping.itervalues():
1102                         if self.cinder.volumes.get(volume_id).status != 'available':
1103                             keep_waiting = True
1104                     if keep_waiting:
1105                         time.sleep(1)
1106                         elapsed_time += 1
1107
1108                 # If we exceeded the timeout rollback
1109                 if elapsed_time >= volume_timeout:
1110                     raise vimconn.vimconnException('Timeout creating volumes for instance ' + name,
1111                                                    http_code=vimconn.HTTP_Request_Timeout)
1112             # get availability Zone
1113             vm_av_zone = self._get_vm_availability_zone(availability_zone_index, availability_zone_list)
1114
1115             self.logger.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1116                               "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1117                               "block_device_mapping={})".format(name, image_id, flavor_id, net_list_vim,
1118                                                                 security_groups, vm_av_zone, self.config.get('keypair'),
1119                                                                 userdata, config_drive, block_device_mapping))
1120             server = self.nova.servers.create(name, image_id, flavor_id, nics=net_list_vim,
1121                                               security_groups=security_groups,
1122                                               availability_zone=vm_av_zone,
1123                                               key_name=self.config.get('keypair'),
1124                                               userdata=userdata,
1125                                               config_drive=config_drive,
1126                                               block_device_mapping=block_device_mapping
1127                                               )  # , description=description)
1128
1129             # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1130             if no_secured_ports:
1131                 self.__wait_for_vm(server.id, 'ACTIVE')
1132
1133             for port_id in no_secured_ports:
1134                 try:
1135                     self.neutron.update_port(port_id, {"port": {"port_security_enabled": False, "security_groups": None} })
1136                 except Exception as e:
1137                     self.logger.error("It was not possible to disable port security for port {}".format(port_id))
1138                     raise
1139
1140             # print "DONE :-)", server
1141
1142             pool_id = None
1143             if external_network:
1144                 floating_ips = self.neutron.list_floatingips().get("floatingips", ())
1145                 self.__wait_for_vm(server.id, 'ACTIVE')
1146
1147             for floating_network in external_network:
1148                 try:
1149                     assigned = False
1150                     while not assigned:
1151                         if floating_ips:
1152                             ip = floating_ips.pop(0)
1153                             if not ip.get("port_id", False) and ip.get('tenant_id') == server.tenant_id:
1154                                 free_floating_ip = ip.get("floating_ip_address")
1155                                 try:
1156                                     fix_ip = floating_network.get('ip')
1157                                     server.add_floating_ip(free_floating_ip, fix_ip)
1158                                     assigned = True
1159                                 except Exception as e:
1160                                     raise vimconn.vimconnException(type(e).__name__ + ": Cannot create floating_ip "+  str(e), http_code=vimconn.HTTP_Conflict)
1161                         else:
1162                             #Find the external network
1163                             external_nets = list()
1164                             for net in self.neutron.list_networks()['networks']:
1165                                 if net['router:external']:
1166                                         external_nets.append(net)
1167
1168                             if len(external_nets) == 0:
1169                                 raise vimconn.vimconnException("Cannot create floating_ip automatically since no external "
1170                                                                "network is present",
1171                                                                 http_code=vimconn.HTTP_Conflict)
1172                             if len(external_nets) > 1:
1173                                 raise vimconn.vimconnException("Cannot create floating_ip automatically since multiple "
1174                                                                "external networks are present",
1175                                                                http_code=vimconn.HTTP_Conflict)
1176
1177                             pool_id = external_nets[0].get('id')
1178                             param = {'floatingip': {'floating_network_id': pool_id, 'tenant_id': server.tenant_id}}
1179                             try:
1180                                 #self.logger.debug("Creating floating IP")
1181                                 new_floating_ip = self.neutron.create_floatingip(param)
1182                                 free_floating_ip = new_floating_ip['floatingip']['floating_ip_address']
1183                                 fix_ip = floating_network.get('ip')
1184                                 server.add_floating_ip(free_floating_ip, fix_ip)
1185                                 assigned=True
1186                             except Exception as e:
1187                                 raise vimconn.vimconnException(type(e).__name__ + ": Cannot assign floating_ip "+  str(e), http_code=vimconn.HTTP_Conflict)
1188                 except Exception as e:
1189                     if not floating_network['exit_on_floating_ip_error']:
1190                         self.logger.warn("Cannot create floating_ip. %s", str(e))
1191                         continue
1192                     raise
1193
1194             return server.id, created_items
1195 #        except nvExceptions.NotFound as e:
1196 #            error_value=-vimconn.HTTP_Not_Found
1197 #            error_text= "vm instance %s not found" % vm_id
1198 #        except TypeError as e:
1199 #            raise vimconn.vimconnException(type(e).__name__ + ": "+  str(e), http_code=vimconn.HTTP_Bad_Request)
1200
1201         except Exception as e:
1202             server_id = None
1203             if server:
1204                 server_id = server.id
1205             try:
1206                 self.delete_vminstance(server_id, created_items)
1207             except Exception as e2:
1208                 self.logger.error("new_vminstance rollback fail {}".format(e2))
1209
1210             self._format_exception(e)
1211
1212     def get_vminstance(self,vm_id):
1213         '''Returns the VM instance information from VIM'''
1214         #self.logger.debug("Getting VM from VIM")
1215         try:
1216             self._reload_connection()
1217             server = self.nova.servers.find(id=vm_id)
1218             #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1219             return server.to_dict()
1220         except (ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.NotFound, ConnectionError) as e:
1221             self._format_exception(e)
1222
1223     def get_vminstance_console(self,vm_id, console_type="vnc"):
1224         '''
1225         Get a console for the virtual machine
1226         Params:
1227             vm_id: uuid of the VM
1228             console_type, can be:
1229                 "novnc" (by default), "xvpvnc" for VNC types,
1230                 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1231         Returns dict with the console parameters:
1232                 protocol: ssh, ftp, http, https, ...
1233                 server:   usually ip address
1234                 port:     the http, ssh, ... port
1235                 suffix:   extra text, e.g. the http path and query string
1236         '''
1237         self.logger.debug("Getting VM CONSOLE from VIM")
1238         try:
1239             self._reload_connection()
1240             server = self.nova.servers.find(id=vm_id)
1241             if console_type == None or console_type == "novnc":
1242                 console_dict = server.get_vnc_console("novnc")
1243             elif console_type == "xvpvnc":
1244                 console_dict = server.get_vnc_console(console_type)
1245             elif console_type == "rdp-html5":
1246                 console_dict = server.get_rdp_console(console_type)
1247             elif console_type == "spice-html5":
1248                 console_dict = server.get_spice_console(console_type)
1249             else:
1250                 raise vimconn.vimconnException("console type '{}' not allowed".format(console_type), http_code=vimconn.HTTP_Bad_Request)
1251
1252             console_dict1 = console_dict.get("console")
1253             if console_dict1:
1254                 console_url = console_dict1.get("url")
1255                 if console_url:
1256                     #parse console_url
1257                     protocol_index = console_url.find("//")
1258                     suffix_index = console_url[protocol_index+2:].find("/") + protocol_index+2
1259                     port_index = console_url[protocol_index+2:suffix_index].find(":") + protocol_index+2
1260                     if protocol_index < 0 or port_index<0 or suffix_index<0:
1261                         return -vimconn.HTTP_Internal_Server_Error, "Unexpected response from VIM"
1262                     console_dict={"protocol": console_url[0:protocol_index],
1263                                   "server":   console_url[protocol_index+2:port_index],
1264                                   "port":     console_url[port_index:suffix_index],
1265                                   "suffix":   console_url[suffix_index+1:]
1266                                   }
1267                     protocol_index += 2
1268                     return console_dict
1269             raise vimconn.vimconnUnexpectedResponse("Unexpected response from VIM")
1270
1271         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.BadRequest, ConnectionError) as e:
1272             self._format_exception(e)
1273
1274     def delete_vminstance(self, vm_id, created_items=None):
1275         '''Removes a VM instance from VIM. Returns the old identifier
1276         '''
1277         #print "osconnector: Getting VM from VIM"
1278         if created_items == None:
1279             created_items = {}
1280         try:
1281             self._reload_connection()
1282             # delete VM ports attached to this networks before the virtual machine
1283             for k, v in created_items.items():
1284                 if not v:  # skip already deleted
1285                     continue
1286                 try:
1287                     k_item, _, k_id = k.partition(":")
1288                     if k_item == "port":
1289                         self.neutron.delete_port(k_id)
1290                 except Exception as e:
1291                     self.logger.error("Error deleting port: {}: {}".format(type(e).__name__, e))
1292
1293             # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1294             # #dettach volumes attached
1295             # server = self.nova.servers.get(vm_id)
1296             # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached']   #volume['id']
1297             # #for volume in volumes_attached_dict:
1298             # #    self.cinder.volumes.detach(volume['id'])
1299
1300             if vm_id:
1301                 self.nova.servers.delete(vm_id)
1302
1303             # delete volumes. Although having detached, they should have in active status before deleting
1304             # we ensure in this loop
1305             keep_waiting = True
1306             elapsed_time = 0
1307             while keep_waiting and elapsed_time < volume_timeout:
1308                 keep_waiting = False
1309                 for k, v in created_items.items():
1310                     if not v:  # skip already deleted
1311                         continue
1312                     try:
1313                         k_item, _, k_id = k.partition(":")
1314                         if k_item == "volume":
1315                             if self.cinder.volumes.get(k_id).status != 'available':
1316                                 keep_waiting = True
1317                             else:
1318                                 self.cinder.volumes.delete(k_id)
1319                     except Exception as e:
1320                         self.logger.error("Error deleting volume: {}: {}".format(type(e).__name__, e))
1321                 if keep_waiting:
1322                     time.sleep(1)
1323                     elapsed_time += 1
1324             return None
1325         except (nvExceptions.NotFound, ksExceptions.ClientException, nvExceptions.ClientException, ConnectionError) as e:
1326             self._format_exception(e)
1327
1328     def refresh_vms_status(self, vm_list):
1329         '''Get the status of the virtual machines and their interfaces/ports
1330            Params: the list of VM identifiers
1331            Returns a dictionary with:
1332                 vm_id:          #VIM id of this Virtual Machine
1333                     status:     #Mandatory. Text with one of:
1334                                 #  DELETED (not found at vim)
1335                                 #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1336                                 #  OTHER (Vim reported other status not understood)
1337                                 #  ERROR (VIM indicates an ERROR status)
1338                                 #  ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1339                                 #  CREATING (on building process), ERROR
1340                                 #  ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1341                                 #
1342                     error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
1343                     vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
1344                     interfaces:
1345                      -  vim_info:         #Text with plain information obtained from vim (yaml.safe_dump)
1346                         mac_address:      #Text format XX:XX:XX:XX:XX:XX
1347                         vim_net_id:       #network id where this interface is connected
1348                         vim_interface_id: #interface/port VIM id
1349                         ip_address:       #null, or text with IPv4, IPv6 address
1350                         compute_node:     #identification of compute node where PF,VF interface is allocated
1351                         pci:              #PCI address of the NIC that hosts the PF,VF
1352                         vlan:             #physical VLAN used for VF
1353         '''
1354         vm_dict={}
1355         self.logger.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1356         for vm_id in vm_list:
1357             vm={}
1358             try:
1359                 vm_vim = self.get_vminstance(vm_id)
1360                 if vm_vim['status'] in vmStatus2manoFormat:
1361                     vm['status']    =  vmStatus2manoFormat[ vm_vim['status'] ]
1362                 else:
1363                     vm['status']    = "OTHER"
1364                     vm['error_msg'] = "VIM status reported " + vm_vim['status']
1365                 try:
1366                     vm['vim_info']  = yaml.safe_dump(vm_vim, default_flow_style=True, width=256)
1367                 except yaml.representer.RepresenterError:
1368                     vm['vim_info'] = str(vm_vim)
1369                 vm["interfaces"] = []
1370                 if vm_vim.get('fault'):
1371                     vm['error_msg'] = str(vm_vim['fault'])
1372                 #get interfaces
1373                 try:
1374                     self._reload_connection()
1375                     port_dict=self.neutron.list_ports(device_id=vm_id)
1376                     for port in port_dict["ports"]:
1377                         interface={}
1378                         try:
1379                             interface['vim_info'] = yaml.safe_dump(port, default_flow_style=True, width=256)
1380                         except yaml.representer.RepresenterError:
1381                             interface['vim_info'] = str(port)
1382                         interface["mac_address"] = port.get("mac_address")
1383                         interface["vim_net_id"] = port["network_id"]
1384                         interface["vim_interface_id"] = port["id"]
1385                         # check if OS-EXT-SRV-ATTR:host is there,
1386                         # in case of non-admin credentials, it will be missing
1387                         if vm_vim.get('OS-EXT-SRV-ATTR:host'):
1388                             interface["compute_node"] = vm_vim['OS-EXT-SRV-ATTR:host']
1389                         interface["pci"] = None
1390
1391                         # check if binding:profile is there,
1392                         # in case of non-admin credentials, it will be missing
1393                         if port.get('binding:profile'):
1394                             if port['binding:profile'].get('pci_slot'):
1395                                 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1396                                 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1397                                 #   CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2)   assuming there are 2 ports per nic
1398                                 pci = port['binding:profile']['pci_slot']
1399                                 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1400                                 interface["pci"] = pci
1401                         interface["vlan"] = None
1402                         #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1403                         network = self.neutron.show_network(port["network_id"])
1404                         if network['network'].get('provider:network_type') == 'vlan' and \
1405                             port.get("binding:vnic_type") == "direct":
1406                             interface["vlan"] = network['network'].get('provider:segmentation_id')
1407                         ips=[]
1408                         #look for floating ip address
1409                         floating_ip_dict = self.neutron.list_floatingips(port_id=port["id"])
1410                         if floating_ip_dict.get("floatingips"):
1411                             ips.append(floating_ip_dict["floatingips"][0].get("floating_ip_address") )
1412
1413                         for subnet in port["fixed_ips"]:
1414                             ips.append(subnet["ip_address"])
1415                         interface["ip_address"] = ";".join(ips)
1416                         vm["interfaces"].append(interface)
1417                 except Exception as e:
1418                     self.logger.error("Error getting vm interface information " + type(e).__name__ + ": "+  str(e))
1419             except vimconn.vimconnNotFoundException as e:
1420                 self.logger.error("Exception getting vm status: %s", str(e))
1421                 vm['status'] = "DELETED"
1422                 vm['error_msg'] = str(e)
1423             except vimconn.vimconnException as e:
1424                 self.logger.error("Exception getting vm status: %s", str(e))
1425                 vm['status'] = "VIM_ERROR"
1426                 vm['error_msg'] = str(e)
1427             vm_dict[vm_id] = vm
1428         return vm_dict
1429
1430     def action_vminstance(self, vm_id, action_dict, created_items={}):
1431         '''Send and action over a VM instance from VIM
1432         Returns None or the console dict if the action was successfully sent to the VIM'''
1433         self.logger.debug("Action over VM '%s': %s", vm_id, str(action_dict))
1434         try:
1435             self._reload_connection()
1436             server = self.nova.servers.find(id=vm_id)
1437             if "start" in action_dict:
1438                 if action_dict["start"]=="rebuild":
1439                     server.rebuild()
1440                 else:
1441                     if server.status=="PAUSED":
1442                         server.unpause()
1443                     elif server.status=="SUSPENDED":
1444                         server.resume()
1445                     elif server.status=="SHUTOFF":
1446                         server.start()
1447             elif "pause" in action_dict:
1448                 server.pause()
1449             elif "resume" in action_dict:
1450                 server.resume()
1451             elif "shutoff" in action_dict or "shutdown" in action_dict:
1452                 server.stop()
1453             elif "forceOff" in action_dict:
1454                 server.stop() #TODO
1455             elif "terminate" in action_dict:
1456                 server.delete()
1457             elif "createImage" in action_dict:
1458                 server.create_image()
1459                 #"path":path_schema,
1460                 #"description":description_schema,
1461                 #"name":name_schema,
1462                 #"metadata":metadata_schema,
1463                 #"imageRef": id_schema,
1464                 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1465             elif "rebuild" in action_dict:
1466                 server.rebuild(server.image['id'])
1467             elif "reboot" in action_dict:
1468                 server.reboot() #reboot_type='SOFT'
1469             elif "console" in action_dict:
1470                 console_type = action_dict["console"]
1471                 if console_type == None or console_type == "novnc":
1472                     console_dict = server.get_vnc_console("novnc")
1473                 elif console_type == "xvpvnc":
1474                     console_dict = server.get_vnc_console(console_type)
1475                 elif console_type == "rdp-html5":
1476                     console_dict = server.get_rdp_console(console_type)
1477                 elif console_type == "spice-html5":
1478                     console_dict = server.get_spice_console(console_type)
1479                 else:
1480                     raise vimconn.vimconnException("console type '{}' not allowed".format(console_type),
1481                                                    http_code=vimconn.HTTP_Bad_Request)
1482                 try:
1483                     console_url = console_dict["console"]["url"]
1484                     #parse console_url
1485                     protocol_index = console_url.find("//")
1486                     suffix_index = console_url[protocol_index+2:].find("/") + protocol_index+2
1487                     port_index = console_url[protocol_index+2:suffix_index].find(":") + protocol_index+2
1488                     if protocol_index < 0 or port_index<0 or suffix_index<0:
1489                         raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
1490                     console_dict2={"protocol": console_url[0:protocol_index],
1491                                   "server":   console_url[protocol_index+2 : port_index],
1492                                   "port":     int(console_url[port_index+1 : suffix_index]),
1493                                   "suffix":   console_url[suffix_index+1:]
1494                                   }
1495                     return console_dict2
1496                 except Exception as e:
1497                     raise vimconn.vimconnException("Unexpected response from VIM " + str(console_dict))
1498
1499             return None
1500         except (ksExceptions.ClientException, nvExceptions.ClientException, nvExceptions.NotFound, ConnectionError) as e:
1501             self._format_exception(e)
1502         #TODO insert exception vimconn.HTTP_Unauthorized
1503
1504     ####### VIO Specific Changes #########
1505     def _genrate_vlanID(self):
1506         """
1507          Method to get unused vlanID
1508             Args:
1509                 None
1510             Returns:
1511                 vlanID
1512         """
1513         #Get used VLAN IDs
1514         usedVlanIDs = []
1515         networks = self.get_network_list()
1516         for net in networks:
1517             if net.get('provider:segmentation_id'):
1518                 usedVlanIDs.append(net.get('provider:segmentation_id'))
1519         used_vlanIDs = set(usedVlanIDs)
1520
1521         #find unused VLAN ID
1522         for vlanID_range in self.config.get('dataplane_net_vlan_range'):
1523             try:
1524                 start_vlanid , end_vlanid = map(int, vlanID_range.replace(" ", "").split("-"))
1525                 for vlanID in xrange(start_vlanid, end_vlanid + 1):
1526                     if vlanID not in used_vlanIDs:
1527                         return vlanID
1528             except Exception as exp:
1529                 raise vimconn.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp))
1530         else:
1531             raise vimconn.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1532                 " All given Vlan IDs {} are in use.".format(self.config.get('dataplane_net_vlan_range')))
1533
1534
1535     def _validate_vlan_ranges(self, dataplane_net_vlan_range):
1536         """
1537         Method to validate user given vlanID ranges
1538             Args:  None
1539             Returns: None
1540         """
1541         for vlanID_range in dataplane_net_vlan_range:
1542             vlan_range = vlanID_range.replace(" ", "")
1543             #validate format
1544             vlanID_pattern = r'(\d)*-(\d)*$'
1545             match_obj = re.match(vlanID_pattern, vlan_range)
1546             if not match_obj:
1547                 raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}.You must provide "\
1548                 "'dataplane_net_vlan_range' in format [start_ID - end_ID].".format(vlanID_range))
1549
1550             start_vlanid , end_vlanid = map(int,vlan_range.split("-"))
1551             if start_vlanid <= 0 :
1552                 raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1553                 "Start ID can not be zero. For VLAN "\
1554                 "networks valid IDs are 1 to 4094 ".format(vlanID_range))
1555             if end_vlanid > 4094 :
1556                 raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1557                 "End VLAN ID can not be greater than 4094. For VLAN "\
1558                 "networks valid IDs are 1 to 4094 ".format(vlanID_range))
1559
1560             if start_vlanid > end_vlanid:
1561                 raise vimconn.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1562                     "You must provide a 'dataplane_net_vlan_range' in format start_ID - end_ID and "\
1563                     "start_ID < end_ID ".format(vlanID_range))
1564
1565 #NOT USED FUNCTIONS
1566
1567     def new_external_port(self, port_data):
1568         #TODO openstack if needed
1569         '''Adds a external port to VIM'''
1570         '''Returns the port identifier'''
1571         return -vimconn.HTTP_Internal_Server_Error, "osconnector.new_external_port() not implemented"
1572
1573     def connect_port_network(self, port_id, network_id, admin=False):
1574         #TODO openstack if needed
1575         '''Connects a external port to a network'''
1576         '''Returns status code of the VIM response'''
1577         return -vimconn.HTTP_Internal_Server_Error, "osconnector.connect_port_network() not implemented"
1578
1579     def new_user(self, user_name, user_passwd, tenant_id=None):
1580         '''Adds a new user to openstack VIM'''
1581         '''Returns the user identifier'''
1582         self.logger.debug("osconnector: Adding a new user to VIM")
1583         try:
1584             self._reload_connection()
1585             user=self.keystone.users.create(user_name, user_passwd, tenant_id=tenant_id)
1586             #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1587             return user.id
1588         except ksExceptions.ConnectionError as e:
1589             error_value=-vimconn.HTTP_Bad_Request
1590             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1591         except ksExceptions.ClientException as e: #TODO remove
1592             error_value=-vimconn.HTTP_Bad_Request
1593             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1594         #TODO insert exception vimconn.HTTP_Unauthorized
1595         #if reaching here is because an exception
1596         if self.debug:
1597             self.logger.debug("new_user " + error_text)
1598         return error_value, error_text
1599
1600     def delete_user(self, user_id):
1601         '''Delete a user from openstack VIM'''
1602         '''Returns the user identifier'''
1603         if self.debug:
1604             print("osconnector: Deleting  a  user from VIM")
1605         try:
1606             self._reload_connection()
1607             self.keystone.users.delete(user_id)
1608             return 1, user_id
1609         except ksExceptions.ConnectionError as e:
1610             error_value=-vimconn.HTTP_Bad_Request
1611             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1612         except ksExceptions.NotFound as e:
1613             error_value=-vimconn.HTTP_Not_Found
1614             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1615         except ksExceptions.ClientException as e: #TODO remove
1616             error_value=-vimconn.HTTP_Bad_Request
1617             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1618         #TODO insert exception vimconn.HTTP_Unauthorized
1619         #if reaching here is because an exception
1620         if self.debug:
1621             print("delete_tenant " + error_text)
1622         return error_value, error_text
1623
1624     def get_hosts_info(self):
1625         '''Get the information of deployed hosts
1626         Returns the hosts content'''
1627         if self.debug:
1628             print("osconnector: Getting Host info from VIM")
1629         try:
1630             h_list=[]
1631             self._reload_connection()
1632             hypervisors = self.nova.hypervisors.list()
1633             for hype in hypervisors:
1634                 h_list.append( hype.to_dict() )
1635             return 1, {"hosts":h_list}
1636         except nvExceptions.NotFound as e:
1637             error_value=-vimconn.HTTP_Not_Found
1638             error_text= (str(e) if len(e.args)==0 else str(e.args[0]))
1639         except (ksExceptions.ClientException, nvExceptions.ClientException) as e:
1640             error_value=-vimconn.HTTP_Bad_Request
1641             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1642         #TODO insert exception vimconn.HTTP_Unauthorized
1643         #if reaching here is because an exception
1644         if self.debug:
1645             print("get_hosts_info " + error_text)
1646         return error_value, error_text
1647
1648     def get_hosts(self, vim_tenant):
1649         '''Get the hosts and deployed instances
1650         Returns the hosts content'''
1651         r, hype_dict = self.get_hosts_info()
1652         if r<0:
1653             return r, hype_dict
1654         hypervisors = hype_dict["hosts"]
1655         try:
1656             servers = self.nova.servers.list()
1657             for hype in hypervisors:
1658                 for server in servers:
1659                     if server.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype['hypervisor_hostname']:
1660                         if 'vm' in hype:
1661                             hype['vm'].append(server.id)
1662                         else:
1663                             hype['vm'] = [server.id]
1664             return 1, hype_dict
1665         except nvExceptions.NotFound as e:
1666             error_value=-vimconn.HTTP_Not_Found
1667             error_text= (str(e) if len(e.args)==0 else str(e.args[0]))
1668         except (ksExceptions.ClientException, nvExceptions.ClientException) as e:
1669             error_value=-vimconn.HTTP_Bad_Request
1670             error_text= type(e).__name__ + ": "+  (str(e) if len(e.args)==0 else str(e.args[0]))
1671         #TODO insert exception vimconn.HTTP_Unauthorized
1672         #if reaching here is because an exception
1673         if self.debug:
1674             print("get_hosts " + error_text)
1675         return error_value, error_text
1676
1677     def new_classification(self, name, ctype, definition):
1678         self.logger.debug(
1679             'Adding a new (Traffic) Classification to VIM, named %s', name)
1680         try:
1681             new_class = None
1682             self._reload_connection()
1683             if ctype not in supportedClassificationTypes:
1684                 raise vimconn.vimconnNotSupportedException(
1685                         'OpenStack VIM connector doesn\'t support provided '
1686                         'Classification Type {}, supported ones are: '
1687                         '{}'.format(ctype, supportedClassificationTypes))
1688             if not self._validate_classification(ctype, definition):
1689                 raise vimconn.vimconnException(
1690                     'Incorrect Classification definition '
1691                     'for the type specified.')
1692             classification_dict = definition
1693             classification_dict['name'] = name
1694
1695             new_class = self.neutron.create_sfc_flow_classifier(
1696                 {'flow_classifier': classification_dict})
1697             return new_class['flow_classifier']['id']
1698         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1699                 neExceptions.NeutronException, ConnectionError) as e:
1700             self.logger.error(
1701                 'Creation of Classification failed.')
1702             self._format_exception(e)
1703
1704     def get_classification(self, class_id):
1705         self.logger.debug(" Getting Classification %s from VIM", class_id)
1706         filter_dict = {"id": class_id}
1707         class_list = self.get_classification_list(filter_dict)
1708         if len(class_list) == 0:
1709             raise vimconn.vimconnNotFoundException(
1710                 "Classification '{}' not found".format(class_id))
1711         elif len(class_list) > 1:
1712             raise vimconn.vimconnConflictException(
1713                 "Found more than one Classification with this criteria")
1714         classification = class_list[0]
1715         return classification
1716
1717     def get_classification_list(self, filter_dict={}):
1718         self.logger.debug("Getting Classifications from VIM filter: '%s'",
1719                           str(filter_dict))
1720         try:
1721             filter_dict_os = filter_dict.copy()
1722             self._reload_connection()
1723             if self.api_version3 and "tenant_id" in filter_dict_os:
1724                 filter_dict_os['project_id'] = filter_dict_os.pop('tenant_id')
1725             classification_dict = self.neutron.list_sfc_flow_classifiers(
1726                 **filter_dict_os)
1727             classification_list = classification_dict["flow_classifiers"]
1728             self.__classification_os2mano(classification_list)
1729             return classification_list
1730         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1731                 neExceptions.NeutronException, ConnectionError) as e:
1732             self._format_exception(e)
1733
1734     def delete_classification(self, class_id):
1735         self.logger.debug("Deleting Classification '%s' from VIM", class_id)
1736         try:
1737             self._reload_connection()
1738             self.neutron.delete_sfc_flow_classifier(class_id)
1739             return class_id
1740         except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
1741                 ksExceptions.ClientException, neExceptions.NeutronException,
1742                 ConnectionError) as e:
1743             self._format_exception(e)
1744
1745     def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True):
1746         self.logger.debug(
1747             "Adding a new Service Function Instance to VIM, named '%s'", name)
1748         try:
1749             new_sfi = None
1750             self._reload_connection()
1751             correlation = None
1752             if sfc_encap:
1753                 correlation = 'nsh'
1754             if len(ingress_ports) != 1:
1755                 raise vimconn.vimconnNotSupportedException(
1756                     "OpenStack VIM connector can only have "
1757                     "1 ingress port per SFI")
1758             if len(egress_ports) != 1:
1759                 raise vimconn.vimconnNotSupportedException(
1760                     "OpenStack VIM connector can only have "
1761                     "1 egress port per SFI")
1762             sfi_dict = {'name': name,
1763                         'ingress': ingress_ports[0],
1764                         'egress': egress_ports[0],
1765                         'service_function_parameters': {
1766                             'correlation': correlation}}
1767             new_sfi = self.neutron.create_sfc_port_pair({'port_pair': sfi_dict})
1768             return new_sfi['port_pair']['id']
1769         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1770                 neExceptions.NeutronException, ConnectionError) as e:
1771             if new_sfi:
1772                 try:
1773                     self.neutron.delete_sfc_port_pair(
1774                         new_sfi['port_pair']['id'])
1775                 except Exception:
1776                     self.logger.error(
1777                         'Creation of Service Function Instance failed, with '
1778                         'subsequent deletion failure as well.')
1779             self._format_exception(e)
1780
1781     def get_sfi(self, sfi_id):
1782         self.logger.debug(
1783             'Getting Service Function Instance %s from VIM', sfi_id)
1784         filter_dict = {"id": sfi_id}
1785         sfi_list = self.get_sfi_list(filter_dict)
1786         if len(sfi_list) == 0:
1787             raise vimconn.vimconnNotFoundException(
1788                 "Service Function Instance '{}' not found".format(sfi_id))
1789         elif len(sfi_list) > 1:
1790             raise vimconn.vimconnConflictException(
1791                 'Found more than one Service Function Instance '
1792                 'with this criteria')
1793         sfi = sfi_list[0]
1794         return sfi
1795
1796     def get_sfi_list(self, filter_dict={}):
1797         self.logger.debug("Getting Service Function Instances from "
1798                           "VIM filter: '%s'", str(filter_dict))
1799         try:
1800             self._reload_connection()
1801             filter_dict_os = filter_dict.copy()
1802             if self.api_version3 and "tenant_id" in filter_dict_os:
1803                 filter_dict_os['project_id'] = filter_dict_os.pop('tenant_id')
1804             sfi_dict = self.neutron.list_sfc_port_pairs(**filter_dict_os)
1805             sfi_list = sfi_dict["port_pairs"]
1806             self.__sfi_os2mano(sfi_list)
1807             return sfi_list
1808         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1809                 neExceptions.NeutronException, ConnectionError) as e:
1810             self._format_exception(e)
1811
1812     def delete_sfi(self, sfi_id):
1813         self.logger.debug("Deleting Service Function Instance '%s' "
1814                           "from VIM", sfi_id)
1815         try:
1816             self._reload_connection()
1817             self.neutron.delete_sfc_port_pair(sfi_id)
1818             return sfi_id
1819         except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
1820                 ksExceptions.ClientException, neExceptions.NeutronException,
1821                 ConnectionError) as e:
1822             self._format_exception(e)
1823
1824     def new_sf(self, name, sfis, sfc_encap=True):
1825         self.logger.debug("Adding a new Service Function to VIM, "
1826                           "named '%s'", name)
1827         try:
1828             new_sf = None
1829             self._reload_connection()
1830             correlation = None
1831             if sfc_encap:
1832                 correlation = 'nsh'
1833             for instance in sfis:
1834                 sfi = self.get_sfi(instance)
1835                 if sfi.get('sfc_encap') != sfc_encap:
1836                     raise vimconn.vimconnNotSupportedException(
1837                         "OpenStack VIM connector requires all SFIs of the "
1838                         "same SF to share the same SFC Encapsulation")
1839             sf_dict = {'name': name,
1840                        'port_pairs': sfis}
1841             new_sf = self.neutron.create_sfc_port_pair_group({
1842                 'port_pair_group': sf_dict})
1843             return new_sf['port_pair_group']['id']
1844         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1845                 neExceptions.NeutronException, ConnectionError) as e:
1846             if new_sf:
1847                 try:
1848                     self.neutron.delete_sfc_port_pair_group(
1849                         new_sf['port_pair_group']['id'])
1850                 except Exception:
1851                     self.logger.error(
1852                         'Creation of Service Function failed, with '
1853                         'subsequent deletion failure as well.')
1854             self._format_exception(e)
1855
1856     def get_sf(self, sf_id):
1857         self.logger.debug("Getting Service Function %s from VIM", sf_id)
1858         filter_dict = {"id": sf_id}
1859         sf_list = self.get_sf_list(filter_dict)
1860         if len(sf_list) == 0:
1861             raise vimconn.vimconnNotFoundException(
1862                 "Service Function '{}' not found".format(sf_id))
1863         elif len(sf_list) > 1:
1864             raise vimconn.vimconnConflictException(
1865                 "Found more than one Service Function with this criteria")
1866         sf = sf_list[0]
1867         return sf
1868
1869     def get_sf_list(self, filter_dict={}):
1870         self.logger.debug("Getting Service Function from VIM filter: '%s'",
1871                           str(filter_dict))
1872         try:
1873             self._reload_connection()
1874             filter_dict_os = filter_dict.copy()
1875             if self.api_version3 and "tenant_id" in filter_dict_os:
1876                 filter_dict_os['project_id'] = filter_dict_os.pop('tenant_id')
1877             sf_dict = self.neutron.list_sfc_port_pair_groups(**filter_dict_os)
1878             sf_list = sf_dict["port_pair_groups"]
1879             self.__sf_os2mano(sf_list)
1880             return sf_list
1881         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1882                 neExceptions.NeutronException, ConnectionError) as e:
1883             self._format_exception(e)
1884
1885     def delete_sf(self, sf_id):
1886         self.logger.debug("Deleting Service Function '%s' from VIM", sf_id)
1887         try:
1888             self._reload_connection()
1889             self.neutron.delete_sfc_port_pair_group(sf_id)
1890             return sf_id
1891         except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
1892                 ksExceptions.ClientException, neExceptions.NeutronException,
1893                 ConnectionError) as e:
1894             self._format_exception(e)
1895
1896     def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
1897         self.logger.debug("Adding a new Service Function Path to VIM, "
1898                           "named '%s'", name)
1899         try:
1900             new_sfp = None
1901             self._reload_connection()
1902             # In networking-sfc the MPLS encapsulation is legacy
1903             # should be used when no full SFC Encapsulation is intended
1904             sfc_encap = 'mpls'
1905             if sfc_encap:
1906                 correlation = 'nsh'
1907             sfp_dict = {'name': name,
1908                         'flow_classifiers': classifications,
1909                         'port_pair_groups': sfs,
1910                         'chain_parameters': {'correlation': correlation}}
1911             if spi:
1912                 sfp_dict['chain_id'] = spi
1913             new_sfp = self.neutron.create_sfc_port_chain({'port_chain': sfp_dict})
1914             return new_sfp["port_chain"]["id"]
1915         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1916                 neExceptions.NeutronException, ConnectionError) as e:
1917             if new_sfp:
1918                 try:
1919                     self.neutron.delete_sfc_port_chain(new_sfp['port_chain']['id'])
1920                 except Exception:
1921                     self.logger.error(
1922                         'Creation of Service Function Path failed, with '
1923                         'subsequent deletion failure as well.')
1924             self._format_exception(e)
1925
1926     def get_sfp(self, sfp_id):
1927         self.logger.debug(" Getting Service Function Path %s from VIM", sfp_id)
1928         filter_dict = {"id": sfp_id}
1929         sfp_list = self.get_sfp_list(filter_dict)
1930         if len(sfp_list) == 0:
1931             raise vimconn.vimconnNotFoundException(
1932                 "Service Function Path '{}' not found".format(sfp_id))
1933         elif len(sfp_list) > 1:
1934             raise vimconn.vimconnConflictException(
1935                 "Found more than one Service Function Path with this criteria")
1936         sfp = sfp_list[0]
1937         return sfp
1938
1939     def get_sfp_list(self, filter_dict={}):
1940         self.logger.debug("Getting Service Function Paths from VIM filter: "
1941                           "'%s'", str(filter_dict))
1942         try:
1943             self._reload_connection()
1944             filter_dict_os = filter_dict.copy()
1945             if self.api_version3 and "tenant_id" in filter_dict_os:
1946                 filter_dict_os['project_id'] = filter_dict_os.pop('tenant_id')
1947             sfp_dict = self.neutron.list_sfc_port_chains(**filter_dict_os)
1948             sfp_list = sfp_dict["port_chains"]
1949             self.__sfp_os2mano(sfp_list)
1950             return sfp_list
1951         except (neExceptions.ConnectionFailed, ksExceptions.ClientException,
1952                 neExceptions.NeutronException, ConnectionError) as e:
1953             self._format_exception(e)
1954
1955     def delete_sfp(self, sfp_id):
1956         self.logger.debug(
1957             "Deleting Service Function Path '%s' from VIM", sfp_id)
1958         try:
1959             self._reload_connection()
1960             self.neutron.delete_sfc_port_chain(sfp_id)
1961             return sfp_id
1962         except (neExceptions.ConnectionFailed, neExceptions.NeutronException,
1963                 ksExceptions.ClientException, neExceptions.NeutronException,
1964                 ConnectionError) as e:
1965             self._format_exception(e)