osm_ro/vimconn_openstack.py

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