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