osm_ro/vimconn_openstack.py

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