osm_ro/vimconn_openstack.py

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