1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U.
5 # This file is part of openmano
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
12 # http://www.apache.org/licenses/LICENSE-2.0
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
22 osconnector implements all the methods to interact with openstack using the python-neutronclient.
24 For the VNF forwarding graph, The OpenStack VIM connector calls the
25 networking-sfc Neutron extension methods, whose resources are mapped
26 to the VIM connector's SFC resources as follows:
27 - Classification (OSM) -> Flow Classifier (Neutron)
28 - Service Function Instance (OSM) -> Port Pair (Neutron)
29 - Service Function (OSM) -> Port Pair Group (Neutron)
30 - Service Function Path (OSM) -> Port Chain (Neutron)
32 __author__
= "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C., Eduardo Sousa"
33 __date__
= "$22-sep-2017 23:59:59$"
35 from osm_ro
import vimconn
44 from pprint
import pformat
46 from novaclient
import client
as nClient
, exceptions
as nvExceptions
47 from keystoneauth1
.identity
import v2
, v3
48 from keystoneauth1
import session
49 import keystoneclient
.exceptions
as ksExceptions
50 import keystoneclient
.v3
.client
as ksClient_v3
51 import keystoneclient
.v2_0
.client
as ksClient_v2
52 from glanceclient
import client
as glClient
53 import glanceclient
.exc
as gl1Exceptions
54 from cinderclient
import client
as cClient
55 from http
.client
import HTTPException
# TODO py3 check that this base exception matches python2 httplib.HTTPException
56 from neutronclient
.neutron
import client
as neClient
57 from neutronclient
.common
import exceptions
as neExceptions
58 from requests
.exceptions
import ConnectionError
61 """contain the openstack virtual machine status to openmano status"""
62 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
64 'SUSPENDED': 'SUSPENDED',
67 'ERROR':'ERROR','DELETED':'DELETED'
69 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
72 supportedClassificationTypes
= ['legacy_flow_classifier']
74 #global var to have a timeout creating and deleting volumes
79 class SafeDumper(yaml
.SafeDumper
):
80 def represent_data(self
, data
):
81 # Openstack APIs use custom subclasses of dict and YAML safe dumper
82 # is designed to not handle that (reference issue 142 of pyyaml)
83 if isinstance(data
, dict) and data
.__class
__ != dict:
84 # A simple solution is to convert those items back to dicts
85 data
= dict(data
.items())
87 return super(SafeDumper
, self
).represent_data(data
)
90 class vimconnector(vimconn
.vimconnector
):
91 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
92 log_level
=None, config
={}, persistent_info
={}):
93 '''using common constructor parameters. In this case
94 'url' is the keystone authorization url,
95 'url_admin' is not use
97 api_version
= config
.get('APIversion')
98 if api_version
and api_version
not in ('v3.3', 'v2.0', '2', '3'):
99 raise vimconn
.vimconnException("Invalid value '{}' for config:APIversion. "
100 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version
))
101 vim_type
= config
.get('vim_type')
102 if vim_type
and vim_type
not in ('vio', 'VIO'):
103 raise vimconn
.vimconnException("Invalid value '{}' for config:vim_type."
104 "Allowed values are 'vio' or 'VIO'".format(vim_type
))
106 if config
.get('dataplane_net_vlan_range') is not None:
107 #validate vlan ranges provided by user
108 self
._validate
_vlan
_ranges
(config
.get('dataplane_net_vlan_range'), 'dataplane_net_vlan_range')
110 if config
.get('multisegment_vlan_range') is not None:
111 #validate vlan ranges provided by user
112 self
._validate
_vlan
_ranges
(config
.get('multisegment_vlan_range'), 'multisegment_vlan_range')
114 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
,
117 if self
.config
.get("insecure") and self
.config
.get("ca_cert"):
118 raise vimconn
.vimconnException("options insecure and ca_cert are mutually exclusive")
120 if self
.config
.get("insecure"):
122 if self
.config
.get("ca_cert"):
123 self
.verify
= self
.config
.get("ca_cert")
126 raise TypeError('url param can not be NoneType')
127 self
.persistent_info
= persistent_info
128 self
.availability_zone
= persistent_info
.get('availability_zone', None)
129 self
.session
= persistent_info
.get('session', {'reload_client': True})
130 self
.my_tenant_id
= self
.session
.get('my_tenant_id')
131 self
.nova
= self
.session
.get('nova')
132 self
.neutron
= self
.session
.get('neutron')
133 self
.cinder
= self
.session
.get('cinder')
134 self
.glance
= self
.session
.get('glance')
135 # self.glancev1 = self.session.get('glancev1')
136 self
.keystone
= self
.session
.get('keystone')
137 self
.api_version3
= self
.session
.get('api_version3')
138 self
.vim_type
= self
.config
.get("vim_type")
140 self
.vim_type
= self
.vim_type
.upper()
141 if self
.config
.get("use_internal_endpoint"):
142 self
.endpoint_type
= "internalURL"
144 self
.endpoint_type
= None
146 logging
.getLogger('urllib3').setLevel(logging
.WARNING
)
147 logging
.getLogger('keystoneauth').setLevel(logging
.WARNING
)
148 logging
.getLogger('novaclient').setLevel(logging
.WARNING
)
149 self
.logger
= logging
.getLogger('openmano.vim.openstack')
151 # allow security_groups to be a list or a single string
152 if isinstance(self
.config
.get('security_groups'), str):
153 self
.config
['security_groups'] = [self
.config
['security_groups']]
154 self
.security_groups_id
= None
156 ####### VIO Specific Changes #########
157 if self
.vim_type
== "VIO":
158 self
.logger
= logging
.getLogger('openmano.vim.vio')
161 self
.logger
.setLevel( getattr(logging
, log_level
))
163 def __getitem__(self
, index
):
164 """Get individuals parameters.
166 if index
== 'project_domain_id':
167 return self
.config
.get("project_domain_id")
168 elif index
== 'user_domain_id':
169 return self
.config
.get("user_domain_id")
171 return vimconn
.vimconnector
.__getitem
__(self
, index
)
173 def __setitem__(self
, index
, value
):
174 """Set individuals parameters and it is marked as dirty so to force connection reload.
176 if index
== 'project_domain_id':
177 self
.config
["project_domain_id"] = value
178 elif index
== 'user_domain_id':
179 self
.config
["user_domain_id"] = value
181 vimconn
.vimconnector
.__setitem
__(self
, index
, value
)
182 self
.session
['reload_client'] = True
184 def serialize(self
, value
):
185 """Serialization of python basic types.
187 In the case value is not serializable a message will be logged and a
188 simple representation of the data that cannot be converted back to
191 if isinstance(value
, str):
195 return yaml
.dump(value
, Dumper
=SafeDumper
,
196 default_flow_style
=True, width
=256)
197 except yaml
.representer
.RepresenterError
:
198 self
.logger
.debug('The following entity cannot be serialized in YAML:\n\n%s\n\n', pformat(value
),
202 def _reload_connection(self
):
203 '''Called before any operation, it check if credentials has changed
204 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
206 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
207 if self
.session
['reload_client']:
208 if self
.config
.get('APIversion'):
209 self
.api_version3
= self
.config
['APIversion'] == 'v3.3' or self
.config
['APIversion'] == '3'
210 else: # get from ending auth_url that end with v3 or with v2.0
211 self
.api_version3
= self
.url
.endswith("/v3") or self
.url
.endswith("/v3/")
212 self
.session
['api_version3'] = self
.api_version3
213 if self
.api_version3
:
214 if self
.config
.get('project_domain_id') or self
.config
.get('project_domain_name'):
215 project_domain_id_default
= None
217 project_domain_id_default
= 'default'
218 if self
.config
.get('user_domain_id') or self
.config
.get('user_domain_name'):
219 user_domain_id_default
= None
221 user_domain_id_default
= 'default'
222 auth
= v3
.Password(auth_url
=self
.url
,
224 password
=self
.passwd
,
225 project_name
=self
.tenant_name
,
226 project_id
=self
.tenant_id
,
227 project_domain_id
=self
.config
.get('project_domain_id', project_domain_id_default
),
228 user_domain_id
=self
.config
.get('user_domain_id', user_domain_id_default
),
229 project_domain_name
=self
.config
.get('project_domain_name'),
230 user_domain_name
=self
.config
.get('user_domain_name'))
232 auth
= v2
.Password(auth_url
=self
.url
,
234 password
=self
.passwd
,
235 tenant_name
=self
.tenant_name
,
236 tenant_id
=self
.tenant_id
)
237 sess
= session
.Session(auth
=auth
, verify
=self
.verify
)
238 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River Titanium cloud and StarlingX
239 region_name
= self
.config
.get('region_name')
240 if self
.api_version3
:
241 self
.keystone
= ksClient_v3
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
243 self
.keystone
= ksClient_v2
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
244 self
.session
['keystone'] = self
.keystone
245 # In order to enable microversion functionality an explicit microversion must be specified in 'config'.
246 # This implementation approach is due to the warning message in
247 # https://developer.openstack.org/api-guide/compute/microversions.html
248 # where it is stated that microversion backwards compatibility is not guaranteed and clients should
249 # always require an specific microversion.
250 # To be able to use 'device role tagging' functionality define 'microversion: 2.32' in datacenter config
251 version
= self
.config
.get("microversion")
254 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River Titanium cloud and StarlingX
255 self
.nova
= self
.session
['nova'] = nClient
.Client(str(version
), session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
256 self
.neutron
= self
.session
['neutron'] = neClient
.Client('2.0', session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
257 self
.cinder
= self
.session
['cinder'] = cClient
.Client(2, session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
259 self
.my_tenant_id
= self
.session
['my_tenant_id'] = sess
.get_project_id()
260 except Exception as e
:
261 self
.logger
.error("Cannot get project_id from session", exc_info
=True)
262 if self
.endpoint_type
== "internalURL":
263 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
264 glance_endpoint
= self
.keystone
.endpoints
.list(glance_service_id
, interface
="internal")[0].url
266 glance_endpoint
= None
267 self
.glance
= self
.session
['glance'] = glClient
.Client(2, session
=sess
, endpoint
=glance_endpoint
)
268 # using version 1 of glance client in new_image()
269 # self.glancev1 = self.session['glancev1'] = glClient.Client('1', session=sess,
270 # endpoint=glance_endpoint)
271 self
.session
['reload_client'] = False
272 self
.persistent_info
['session'] = self
.session
273 # add availablity zone info inside self.persistent_info
274 self
._set
_availablity
_zones
()
275 self
.persistent_info
['availability_zone'] = self
.availability_zone
276 self
.security_groups_id
= None # force to get again security_groups_ids next time they are needed
278 def __net_os2mano(self
, net_list_dict
):
279 '''Transform the net openstack format to mano format
280 net_list_dict can be a list of dict or a single dict'''
281 if type(net_list_dict
) is dict:
282 net_list_
=(net_list_dict
,)
283 elif type(net_list_dict
) is list:
284 net_list_
=net_list_dict
286 raise TypeError("param net_list_dict must be a list or a dictionary")
287 for net
in net_list_
:
288 if net
.get('provider:network_type') == "vlan":
293 def __classification_os2mano(self
, class_list_dict
):
294 """Transform the openstack format (Flow Classifier) to mano format
295 (Classification) class_list_dict can be a list of dict or a single dict
297 if isinstance(class_list_dict
, dict):
298 class_list_
= [class_list_dict
]
299 elif isinstance(class_list_dict
, list):
300 class_list_
= class_list_dict
303 "param class_list_dict must be a list or a dictionary")
304 for classification
in class_list_
:
305 id = classification
.pop('id')
306 name
= classification
.pop('name')
307 description
= classification
.pop('description')
308 project_id
= classification
.pop('project_id')
309 tenant_id
= classification
.pop('tenant_id')
310 original_classification
= copy
.deepcopy(classification
)
311 classification
.clear()
312 classification
['ctype'] = 'legacy_flow_classifier'
313 classification
['definition'] = original_classification
314 classification
['id'] = id
315 classification
['name'] = name
316 classification
['description'] = description
317 classification
['project_id'] = project_id
318 classification
['tenant_id'] = tenant_id
320 def __sfi_os2mano(self
, sfi_list_dict
):
321 """Transform the openstack format (Port Pair) to mano format (SFI)
322 sfi_list_dict can be a list of dict or a single dict
324 if isinstance(sfi_list_dict
, dict):
325 sfi_list_
= [sfi_list_dict
]
326 elif isinstance(sfi_list_dict
, list):
327 sfi_list_
= sfi_list_dict
330 "param sfi_list_dict must be a list or a dictionary")
331 for sfi
in sfi_list_
:
332 sfi
['ingress_ports'] = []
333 sfi
['egress_ports'] = []
334 if sfi
.get('ingress'):
335 sfi
['ingress_ports'].append(sfi
['ingress'])
336 if sfi
.get('egress'):
337 sfi
['egress_ports'].append(sfi
['egress'])
340 params
= sfi
.get('service_function_parameters')
343 correlation
= params
.get('correlation')
346 sfi
['sfc_encap'] = sfc_encap
347 del sfi
['service_function_parameters']
349 def __sf_os2mano(self
, sf_list_dict
):
350 """Transform the openstack format (Port Pair Group) to mano format (SF)
351 sf_list_dict can be a list of dict or a single dict
353 if isinstance(sf_list_dict
, dict):
354 sf_list_
= [sf_list_dict
]
355 elif isinstance(sf_list_dict
, list):
356 sf_list_
= sf_list_dict
359 "param sf_list_dict must be a list or a dictionary")
361 del sf
['port_pair_group_parameters']
362 sf
['sfis'] = sf
['port_pairs']
365 def __sfp_os2mano(self
, sfp_list_dict
):
366 """Transform the openstack format (Port Chain) to mano format (SFP)
367 sfp_list_dict can be a list of dict or a single dict
369 if isinstance(sfp_list_dict
, dict):
370 sfp_list_
= [sfp_list_dict
]
371 elif isinstance(sfp_list_dict
, list):
372 sfp_list_
= sfp_list_dict
375 "param sfp_list_dict must be a list or a dictionary")
376 for sfp
in sfp_list_
:
377 params
= sfp
.pop('chain_parameters')
380 correlation
= params
.get('correlation')
383 sfp
['sfc_encap'] = sfc_encap
384 sfp
['spi'] = sfp
.pop('chain_id')
385 sfp
['classifications'] = sfp
.pop('flow_classifiers')
386 sfp
['service_functions'] = sfp
.pop('port_pair_groups')
388 # placeholder for now; read TODO note below
389 def _validate_classification(self
, type, definition
):
390 # only legacy_flow_classifier Type is supported at this point
392 # TODO(igordcard): this method should be an abstract method of an
393 # abstract Classification class to be implemented by the specific
394 # Types. Also, abstract vimconnector should call the validation
395 # method before the implemented VIM connectors are called.
397 def _format_exception(self
, exception
):
398 """Transform a keystone, nova, neutron exception into a vimconn exception discovering the cause"""
400 message_error
= str(exception
)
402 if isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
, ksExceptions
.NotFound
,
403 gl1Exceptions
.HTTPNotFound
)):
404 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + message_error
)
405 elif isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
406 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
)):
407 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + message_error
)
408 elif isinstance(exception
, (KeyError, nvExceptions
.BadRequest
, ksExceptions
.BadRequest
)):
409 raise vimconn
.vimconnException(type(exception
).__name
__ + ": " + message_error
)
410 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
411 neExceptions
.NeutronException
)):
412 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + message_error
)
413 elif isinstance(exception
, nvExceptions
.Conflict
):
414 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + message_error
)
415 elif isinstance(exception
, vimconn
.vimconnException
):
418 self
.logger
.error("General Exception " + message_error
, exc_info
=True)
419 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + message_error
)
421 def _get_ids_from_name(self
):
423 Obtain ids from name of tenant and security_groups. Store at self .security_groups_id"
426 # get tenant_id if only tenant_name is supplied
427 self
._reload
_connection
()
428 if not self
.my_tenant_id
:
429 raise vimconn
.vimconnConnectionException("Error getting tenant information from name={} id={}".
430 format(self
.tenant_name
, self
.tenant_id
))
431 if self
.config
.get('security_groups') and not self
.security_groups_id
:
432 # convert from name to id
433 neutron_sg_list
= self
.neutron
.list_security_groups(tenant_id
=self
.my_tenant_id
)["security_groups"]
435 self
.security_groups_id
= []
436 for sg
in self
.config
.get('security_groups'):
437 for neutron_sg
in neutron_sg_list
:
438 if sg
in (neutron_sg
["id"], neutron_sg
["name"]):
439 self
.security_groups_id
.append(neutron_sg
["id"])
442 self
.security_groups_id
= None
443 raise vimconn
.vimconnConnectionException("Not found security group {} for this tenant".format(sg
))
445 def check_vim_connectivity(self
):
446 # just get network list to check connectivity and credentials
447 self
.get_network_list(filter_dict
={})
449 def get_tenant_list(self
, filter_dict
={}):
450 '''Obtain tenants of VIM
451 filter_dict can contain the following keys:
452 name: filter by tenant name
453 id: filter by tenant uuid/id
455 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
457 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
459 self
._reload
_connection
()
460 if self
.api_version3
:
461 project_class_list
= self
.keystone
.projects
.list(name
=filter_dict
.get("name"))
463 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
465 for project
in project_class_list
:
466 if filter_dict
.get('id') and filter_dict
["id"] != project
.id:
468 project_list
.append(project
.to_dict())
470 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
471 self
._format
_exception
(e
)
473 def new_tenant(self
, tenant_name
, tenant_description
):
474 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
475 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
477 self
._reload
_connection
()
478 if self
.api_version3
:
479 project
= self
.keystone
.projects
.create(tenant_name
, self
.config
.get("project_domain_id", "default"),
480 description
=tenant_description
, is_domain
=False)
482 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
484 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ksExceptions
.BadRequest
, ConnectionError
) as e
:
485 self
._format
_exception
(e
)
487 def delete_tenant(self
, tenant_id
):
488 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
489 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
491 self
._reload
_connection
()
492 if self
.api_version3
:
493 self
.keystone
.projects
.delete(tenant_id
)
495 self
.keystone
.tenants
.delete(tenant_id
)
497 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ksExceptions
.NotFound
, ConnectionError
) as e
:
498 self
._format
_exception
(e
)
500 def new_network(self
, net_name
, net_type
, ip_profile
=None, shared
=False, provider_network_profile
=None):
501 """Adds a tenant network to VIM
503 'net_name': name of the network
505 'bridge': overlay isolated network
506 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
507 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
508 'ip_profile': is a dict containing the IP parameters of the network
509 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
510 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
511 'gateway_address': (Optional) ip_schema, that is X.X.X.X
512 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
513 'dhcp_enabled': True or False
514 'dhcp_start_address': ip_schema, first IP to grant
515 'dhcp_count': number of IPs to grant.
516 'shared': if this network can be seen/use by other tenants/organization
517 'provider_network_profile': (optional) contains {segmentation-id: vlan, network-type: vlan|vxlan,
518 physical-network: physnet-label}
519 Returns a tuple with the network identifier and created_items, or raises an exception on error
520 created_items can be None or a dictionary where this method can include key-values that will be passed to
521 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
522 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
525 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
526 # self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
530 if provider_network_profile
:
531 vlan
= provider_network_profile
.get("segmentation-id")
534 self
._reload
_connection
()
535 network_dict
= {'name': net_name
, 'admin_state_up': True}
536 if net_type
in ("data", "ptp"):
537 provider_physical_network
= None
538 if provider_network_profile
and provider_network_profile
.get("physical-network"):
539 provider_physical_network
= provider_network_profile
.get("physical-network")
540 # provider-network must be one of the dataplane_physcial_netowrk if this is a list. If it is string
541 # or not declared, just ignore the checking
542 if isinstance(self
.config
.get('dataplane_physical_net'), (tuple, list)) and \
543 provider_physical_network
not in self
.config
['dataplane_physical_net']:
544 raise vimconn
.vimconnConflictException(
545 "Invalid parameter 'provider-network:physical-network' for network creation. '{}' is not "
546 "one of the declared list at VIM_config:dataplane_physical_net".format(
547 provider_physical_network
))
548 if not provider_physical_network
: # use the default dataplane_physical_net
549 provider_physical_network
= self
.config
.get('dataplane_physical_net')
550 # if it is non empty list, use the first value. If it is a string use the value directly
551 if isinstance(provider_physical_network
, (tuple, list)) and provider_physical_network
:
552 provider_physical_network
= provider_physical_network
[0]
554 if not provider_physical_network
:
555 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at VIM_config "
556 "for creating underlay networks. or use the NS instantiation"
557 " parameter provider-network:physical-network for the VLD")
559 if not self
.config
.get('multisegment_support'):
560 network_dict
["provider:physical_network"] = provider_physical_network
561 if provider_network_profile
and "network-type" in provider_network_profile
:
562 network_dict
["provider:network_type"] = provider_network_profile
["network-type"]
564 network_dict
["provider:network_type"] = self
.config
.get('dataplane_network_type','vlan')
566 network_dict
["provider:segmentation_id"] = vlan
571 "provider:physical_network": '',
572 "provider:network_type": 'vxlan'
574 segment_list
.append(segment1_dict
)
576 "provider:physical_network": provider_physical_network
,
577 "provider:network_type": "vlan"
580 segment2_dict
["provider:segmentation_id"] = vlan
581 elif self
.config
.get('multisegment_vlan_range'):
582 vlanID
= self
._generate
_multisegment
_vlanID
()
583 segment2_dict
["provider:segmentation_id"] = vlanID
585 # raise vimconn.vimconnConflictException(
586 # "You must provide 'multisegment_vlan_range' at config dict before creating a multisegment network")
587 segment_list
.append(segment2_dict
)
588 network_dict
["segments"] = segment_list
590 # VIO Specific Changes. It needs a concrete VLAN
591 if self
.vim_type
== "VIO" and vlan
is None:
592 if self
.config
.get('dataplane_net_vlan_range') is None:
593 raise vimconn
.vimconnConflictException(
594 "You must provide 'dataplane_net_vlan_range' in format [start_ID - end_ID] at VIM_config "
595 "for creating underlay networks")
596 network_dict
["provider:segmentation_id"] = self
._generate
_vlanID
()
598 network_dict
["shared"] = shared
599 if self
.config
.get("disable_network_port_security"):
600 network_dict
["port_security_enabled"] = False
601 new_net
= self
.neutron
.create_network({'network':network_dict
})
603 # create subnetwork, even if there is no profile
606 if not ip_profile
.get('subnet_address'):
607 #Fake subnet is required
608 subnet_rand
= random
.randint(0, 255)
609 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
610 if 'ip_version' not in ip_profile
:
611 ip_profile
['ip_version'] = "IPv4"
612 subnet
= {"name": net_name
+"-subnet",
613 "network_id": new_net
["network"]["id"],
614 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
615 "cidr": ip_profile
['subnet_address']
617 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
618 if ip_profile
.get('gateway_address'):
619 subnet
['gateway_ip'] = ip_profile
['gateway_address']
621 subnet
['gateway_ip'] = None
622 if ip_profile
.get('dns_address'):
623 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
624 if 'dhcp_enabled' in ip_profile
:
625 subnet
['enable_dhcp'] = False if \
626 ip_profile
['dhcp_enabled']=="false" or ip_profile
['dhcp_enabled']==False else True
627 if ip_profile
.get('dhcp_start_address'):
628 subnet
['allocation_pools'] = []
629 subnet
['allocation_pools'].append(dict())
630 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
631 if ip_profile
.get('dhcp_count'):
632 #parts = ip_profile['dhcp_start_address'].split('.')
633 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
634 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
635 ip_int
+= ip_profile
['dhcp_count'] - 1
636 ip_str
= str(netaddr
.IPAddress(ip_int
))
637 subnet
['allocation_pools'][0]['end'] = ip_str
638 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
639 self
.neutron
.create_subnet({"subnet": subnet
} )
641 if net_type
== "data" and self
.config
.get('multisegment_support'):
642 if self
.config
.get('l2gw_support'):
643 l2gw_list
= self
.neutron
.list_l2_gateways().get("l2_gateways", ())
644 for l2gw
in l2gw_list
:
646 l2gw_conn
["l2_gateway_id"] = l2gw
["id"]
647 l2gw_conn
["network_id"] = new_net
["network"]["id"]
648 l2gw_conn
["segmentation_id"] = str(vlanID
)
649 new_l2gw_conn
= self
.neutron
.create_l2_gateway_connection({"l2_gateway_connection": l2gw_conn
})
650 created_items
["l2gwconn:" + str(new_l2gw_conn
["l2_gateway_connection"]["id"])] = True
651 return new_net
["network"]["id"], created_items
652 except Exception as e
:
653 #delete l2gw connections (if any) before deleting the network
654 for k
, v
in created_items
.items():
655 if not v
: # skip already deleted
658 k_item
, _
, k_id
= k
.partition(":")
659 if k_item
== "l2gwconn":
660 self
.neutron
.delete_l2_gateway_connection(k_id
)
661 except Exception as e2
:
662 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e2
).__name
__, e2
))
664 self
.neutron
.delete_network(new_net
['network']['id'])
665 self
._format
_exception
(e
)
667 def get_network_list(self
, filter_dict
={}):
668 '''Obtain tenant networks of VIM
674 admin_state_up: boolean
676 Returns the network list of dictionaries
678 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
680 self
._reload
_connection
()
681 filter_dict_os
= filter_dict
.copy()
682 if self
.api_version3
and "tenant_id" in filter_dict_os
:
683 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id') #T ODO check
684 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
685 net_list
= net_dict
["networks"]
686 self
.__net
_os
2mano
(net_list
)
688 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
689 self
._format
_exception
(e
)
691 def get_network(self
, net_id
):
692 '''Obtain details of network from VIM
693 Returns the network information from a network id'''
694 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
695 filter_dict
={"id": net_id
}
696 net_list
= self
.get_network_list(filter_dict
)
698 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
699 elif len(net_list
)>1:
700 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
703 for subnet_id
in net
.get("subnets", () ):
705 subnet
= self
.neutron
.show_subnet(subnet_id
)
706 except Exception as e
:
707 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
708 subnet
= {"id": subnet_id
, "fault": str(e
)}
709 subnets
.append(subnet
)
710 net
["subnets"] = subnets
711 net
["encapsulation"] = net
.get('provider:network_type')
712 net
["encapsulation_type"] = net
.get('provider:network_type')
713 net
["segmentation_id"] = net
.get('provider:segmentation_id')
714 net
["encapsulation_id"] = net
.get('provider:segmentation_id')
717 def delete_network(self
, net_id
, created_items
=None):
719 Removes a tenant network from VIM and its associated elements
720 :param net_id: VIM identifier of the network, provided by method new_network
721 :param created_items: dictionary with extra items to be deleted. provided by method new_network
722 Returns the network identifier or raises an exception upon error or when network is not found
724 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
725 if created_items
== None:
728 self
._reload
_connection
()
729 #delete l2gw connections (if any) before deleting the network
730 for k
, v
in created_items
.items():
731 if not v
: # skip already deleted
734 k_item
, _
, k_id
= k
.partition(":")
735 if k_item
== "l2gwconn":
736 self
.neutron
.delete_l2_gateway_connection(k_id
)
737 except Exception as e
:
738 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e
).__name
__, e
))
739 #delete VM ports attached to this networks before the network
740 ports
= self
.neutron
.list_ports(network_id
=net_id
)
741 for p
in ports
['ports']:
743 self
.neutron
.delete_port(p
["id"])
744 except Exception as e
:
745 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
746 self
.neutron
.delete_network(net_id
)
748 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
749 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
750 self
._format
_exception
(e
)
752 def refresh_nets_status(self
, net_list
):
753 '''Get the status of the networks
754 Params: the list of network identifiers
755 Returns a dictionary with:
756 net_id: #VIM id of this network
757 status: #Mandatory. Text with one of:
758 # DELETED (not found at vim)
759 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
760 # OTHER (Vim reported other status not understood)
761 # ERROR (VIM indicates an ERROR status)
762 # ACTIVE, INACTIVE, DOWN (admin down),
763 # BUILD (on building process)
765 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
766 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
770 for net_id
in net_list
:
773 net_vim
= self
.get_network(net_id
)
774 if net_vim
['status'] in netStatus2manoFormat
:
775 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
777 net
["status"] = "OTHER"
778 net
["error_msg"] = "VIM status reported " + net_vim
['status']
780 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
781 net
['status'] = 'DOWN'
783 net
['vim_info'] = self
.serialize(net_vim
)
785 if net_vim
.get('fault'): #TODO
786 net
['error_msg'] = str(net_vim
['fault'])
787 except vimconn
.vimconnNotFoundException
as e
:
788 self
.logger
.error("Exception getting net status: %s", str(e
))
789 net
['status'] = "DELETED"
790 net
['error_msg'] = str(e
)
791 except vimconn
.vimconnException
as e
:
792 self
.logger
.error("Exception getting net status: %s", str(e
))
793 net
['status'] = "VIM_ERROR"
794 net
['error_msg'] = str(e
)
795 net_dict
[net_id
] = net
798 def get_flavor(self
, flavor_id
):
799 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
800 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
802 self
._reload
_connection
()
803 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
804 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
805 return flavor
.to_dict()
806 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
807 self
._format
_exception
(e
)
809 def get_flavor_id_from_data(self
, flavor_dict
):
810 """Obtain flavor id that match the flavor description
811 Returns the flavor_id or raises a vimconnNotFoundException
812 flavor_dict: contains the required ram, vcpus, disk
813 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
814 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
815 vimconnNotFoundException is raised
817 exact_match
= False if self
.config
.get('use_existing_flavors') else True
819 self
._reload
_connection
()
820 flavor_candidate_id
= None
821 flavor_candidate_data
= (10000, 10000, 10000)
822 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
824 extended
= flavor_dict
.get("extended", {})
827 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemented")
829 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
831 # numas = extended.get("numas")
832 for flavor
in self
.nova
.flavors
.list():
833 epa
= flavor
.get_keys()
837 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
838 if flavor_data
== flavor_target
:
840 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
841 flavor_candidate_id
= flavor
.id
842 flavor_candidate_data
= flavor_data
843 if not exact_match
and flavor_candidate_id
:
844 return flavor_candidate_id
845 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
846 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
847 self
._format
_exception
(e
)
849 def process_resource_quota(self
, quota
, prefix
, extra_specs
):
856 extra_specs
["quota:" + prefix
+ "_limit"] = quota
['limit']
857 if 'reserve' in quota
:
858 extra_specs
["quota:" + prefix
+ "_reservation"] = quota
['reserve']
859 if 'shares' in quota
:
860 extra_specs
["quota:" + prefix
+ "_shares_level"] = "custom"
861 extra_specs
["quota:" + prefix
+ "_shares_share"] = quota
['shares']
863 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
864 '''Adds a tenant flavor to openstack VIM
865 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
866 Returns the flavor identifier
868 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
873 name
=flavor_data
['name']
874 while retry
<max_retries
:
877 self
._reload
_connection
()
878 if change_name_if_used
:
881 fl
=self
.nova
.flavors
.list()
883 fl_names
.append(f
.name
)
884 while name
in fl_names
:
886 name
= flavor_data
['name']+"-" + str(name_suffix
)
888 ram
= flavor_data
.get('ram',64)
889 vcpus
= flavor_data
.get('vcpus',1)
892 extended
= flavor_data
.get("extended")
894 numas
=extended
.get("numas")
896 numa_nodes
= len(numas
)
898 return -1, "Can not add flavor with more than one numa"
899 extra_specs
["hw:numa_nodes"] = str(numa_nodes
)
900 extra_specs
["hw:mem_page_size"] = "large"
901 extra_specs
["hw:cpu_policy"] = "dedicated"
902 extra_specs
["hw:numa_mempolicy"] = "strict"
903 if self
.vim_type
== "VIO":
904 extra_specs
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
905 extra_specs
["vmware:latency_sensitivity_level"] = "high"
907 #overwrite ram and vcpus
908 #check if key 'memory' is present in numa else use ram value at flavor
910 ram
= numa
['memory']*1024
911 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
912 extra_specs
["hw:cpu_sockets"] = 1
913 if 'paired-threads' in numa
:
914 vcpus
= numa
['paired-threads']*2
915 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
916 extra_specs
["hw:cpu_thread_policy"] = "require"
917 extra_specs
["hw:cpu_policy"] = "dedicated"
918 elif 'cores' in numa
:
919 vcpus
= numa
['cores']
920 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
921 extra_specs
["hw:cpu_thread_policy"] = "isolate"
922 extra_specs
["hw:cpu_policy"] = "dedicated"
923 elif 'threads' in numa
:
924 vcpus
= numa
['threads']
925 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
926 extra_specs
["hw:cpu_thread_policy"] = "prefer"
927 extra_specs
["hw:cpu_policy"] = "dedicated"
928 # for interface in numa.get("interfaces",() ):
929 # if interface["dedicated"]=="yes":
930 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
931 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
932 elif extended
.get("cpu-quota"):
933 self
.process_resource_quota(extended
.get("cpu-quota"), "cpu", extra_specs
)
934 if extended
.get("mem-quota"):
935 self
.process_resource_quota(extended
.get("mem-quota"), "memory", extra_specs
)
936 if extended
.get("vif-quota"):
937 self
.process_resource_quota(extended
.get("vif-quota"), "vif", extra_specs
)
938 if extended
.get("disk-io-quota"):
939 self
.process_resource_quota(extended
.get("disk-io-quota"), "disk_io", extra_specs
)
941 new_flavor
=self
.nova
.flavors
.create(name
,
944 flavor_data
.get('disk',0),
945 is_public
=flavor_data
.get('is_public', True)
949 new_flavor
.set_keys(extra_specs
)
951 except nvExceptions
.Conflict
as e
:
952 if change_name_if_used
and retry
< max_retries
:
954 self
._format
_exception
(e
)
955 #except nvExceptions.BadRequest as e:
956 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
, KeyError) as e
:
957 self
._format
_exception
(e
)
959 def delete_flavor(self
,flavor_id
):
960 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
963 self
._reload
_connection
()
964 self
.nova
.flavors
.delete(flavor_id
)
966 #except nvExceptions.BadRequest as e:
967 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
968 self
._format
_exception
(e
)
970 def new_image(self
,image_dict
):
972 Adds a tenant image to VIM. imge_dict is a dictionary with:
974 disk_format: qcow2, vhd, vmdk, raw (by default), ...
975 location: path or URI
976 public: "yes" or "no"
977 metadata: metadata of the image
982 while retry
<max_retries
:
985 self
._reload
_connection
()
986 #determine format http://docs.openstack.org/developer/glance/formats.html
987 if "disk_format" in image_dict
:
988 disk_format
=image_dict
["disk_format"]
989 else: #autodiscover based on extension
990 if image_dict
['location'].endswith(".qcow2"):
992 elif image_dict
['location'].endswith(".vhd"):
994 elif image_dict
['location'].endswith(".vmdk"):
996 elif image_dict
['location'].endswith(".vdi"):
998 elif image_dict
['location'].endswith(".iso"):
1000 elif image_dict
['location'].endswith(".aki"):
1002 elif image_dict
['location'].endswith(".ari"):
1004 elif image_dict
['location'].endswith(".ami"):
1008 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
1009 if self
.vim_type
== "VIO":
1010 container_format
= "bare"
1011 if 'container_format' in image_dict
:
1012 container_format
= image_dict
['container_format']
1013 new_image
= self
.glance
.images
.create(name
=image_dict
['name'], container_format
=container_format
,
1014 disk_format
=disk_format
)
1016 new_image
= self
.glance
.images
.create(name
=image_dict
['name'])
1017 if image_dict
['location'].startswith("http"):
1018 # TODO there is not a method to direct download. It must be downloaded locally with requests
1019 raise vimconn
.vimconnNotImplemented("Cannot create image from URL")
1021 with
open(image_dict
['location']) as fimage
:
1022 self
.glance
.images
.upload(new_image
.id, fimage
)
1023 #new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
1024 # container_format="bare", data=fimage, disk_format=disk_format)
1025 metadata_to_load
= image_dict
.get('metadata')
1026 # TODO location is a reserved word for current openstack versions. fixed for VIO please check for openstack
1027 if self
.vim_type
== "VIO":
1028 metadata_to_load
['upload_location'] = image_dict
['location']
1030 metadata_to_load
['location'] = image_dict
['location']
1031 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1033 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1034 self
._format
_exception
(e
)
1035 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1036 if retry
==max_retries
:
1038 self
._format
_exception
(e
)
1039 except IOError as e
: #can not open the file
1040 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
1041 http_code
=vimconn
.HTTP_Bad_Request
)
1043 def delete_image(self
, image_id
):
1044 '''Deletes a tenant image from openstack VIM. Returns the old id
1047 self
._reload
_connection
()
1048 self
.glance
.images
.delete(image_id
)
1050 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, gl1Exceptions
.HTTPNotFound
, ConnectionError
) as e
: #TODO remove
1051 self
._format
_exception
(e
)
1053 def get_image_id_from_path(self
, path
):
1054 '''Get the image id from image path in the VIM database. Returns the image_id'''
1056 self
._reload
_connection
()
1057 images
= self
.glance
.images
.list()
1058 for image
in images
:
1059 if image
.metadata
.get("location")==path
:
1061 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
1062 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1063 self
._format
_exception
(e
)
1065 def get_image_list(self
, filter_dict
={}):
1066 '''Obtain tenant images from VIM
1070 checksum: image checksum
1071 Returns the image list of dictionaries:
1072 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1075 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1077 self
._reload
_connection
()
1078 filter_dict_os
= filter_dict
.copy()
1079 #First we filter by the available filter fields: name, id. The others are removed.
1080 image_list
= self
.glance
.images
.list()
1082 for image
in image_list
:
1084 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1086 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1088 if filter_dict
.get("checksum") and image
["checksum"] != filter_dict
["checksum"]:
1091 filtered_list
.append(image
.copy())
1092 except gl1Exceptions
.HTTPNotFound
:
1094 return filtered_list
1095 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1096 self
._format
_exception
(e
)
1098 def __wait_for_vm(self
, vm_id
, status
):
1099 """wait until vm is in the desired status and return True.
1100 If the VM gets in ERROR status, return false.
1101 If the timeout is reached generate an exception"""
1103 while elapsed_time
< server_timeout
:
1104 vm_status
= self
.nova
.servers
.get(vm_id
).status
1105 if vm_status
== status
:
1107 if vm_status
== 'ERROR':
1112 # if we exceeded the timeout rollback
1113 if elapsed_time
>= server_timeout
:
1114 raise vimconn
.vimconnException('Timeout waiting for instance ' + vm_id
+ ' to get ' + status
,
1115 http_code
=vimconn
.HTTP_Request_Timeout
)
1117 def _get_openstack_availablity_zones(self
):
1119 Get from openstack availability zones available
1123 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1124 openstack_availability_zone
= [str(zone
.zoneName
) for zone
in openstack_availability_zone
1125 if zone
.zoneName
!= 'internal']
1126 return openstack_availability_zone
1127 except Exception as e
:
1130 def _set_availablity_zones(self
):
1132 Set vim availablity zone
1136 if 'availability_zone' in self
.config
:
1137 vim_availability_zones
= self
.config
.get('availability_zone')
1138 if isinstance(vim_availability_zones
, str):
1139 self
.availability_zone
= [vim_availability_zones
]
1140 elif isinstance(vim_availability_zones
, list):
1141 self
.availability_zone
= vim_availability_zones
1143 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1145 def _get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
1147 Return thge availability zone to be used by the created VM.
1148 :return: The VIM availability zone to be used or None
1150 if availability_zone_index
is None:
1151 if not self
.config
.get('availability_zone'):
1153 elif isinstance(self
.config
.get('availability_zone'), str):
1154 return self
.config
['availability_zone']
1156 # TODO consider using a different parameter at config for default AV and AV list match
1157 return self
.config
['availability_zone'][0]
1159 vim_availability_zones
= self
.availability_zone
1160 # check if VIM offer enough availability zones describe in the VNFD
1161 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
1162 # check if all the names of NFV AV match VIM AV names
1163 match_by_index
= False
1164 for av
in availability_zone_list
:
1165 if av
not in vim_availability_zones
:
1166 match_by_index
= True
1169 return vim_availability_zones
[availability_zone_index
]
1171 return availability_zone_list
[availability_zone_index
]
1173 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
1175 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
1176 availability_zone_index
=None, availability_zone_list
=None):
1177 """Adds a VM instance to VIM
1179 start: indicates if VM must start or boot in pause mode. Ignored
1180 image_id,flavor_id: iamge and flavor uuid
1181 net_list: list of interfaces, each one is a dictionary with:
1183 net_id: network uuid to connect
1184 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
1185 model: interface model, ignored #TODO
1186 mac_address: used for SR-IOV ifaces #TODO for other types
1187 use: 'data', 'bridge', 'mgmt'
1188 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
1189 vim_id: filled/added by this function
1190 floating_ip: True/False (or it can be None)
1191 'cloud_config': (optional) dictionary with:
1192 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1193 'users': (optional) list of users to be inserted, each item is a dict with:
1194 'name': (mandatory) user name,
1195 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1196 'user-data': (optional) string is a text script to be passed directly to cloud-init
1197 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1198 'dest': (mandatory) string with the destination absolute path
1199 'encoding': (optional, by default text). Can be one of:
1200 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1201 'content' (mandatory): string with the content of the file
1202 'permissions': (optional) string with file permissions, typically octal notation '0644'
1203 'owner': (optional) file owner, string with the format 'owner:group'
1204 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1205 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1206 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1207 'size': (mandatory) string with the size of the disk in GB
1208 'vim_id' (optional) should use this existing volume id
1209 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1210 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1211 availability_zone_index is None
1212 #TODO ip, security groups
1213 Returns a tuple with the instance identifier and created_items or raises an exception on error
1214 created_items can be None or a dictionary where this method can include key-values that will be passed to
1215 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1216 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1219 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
1225 external_network
= [] # list of external networks to be connected to instance, later on used to create floating_ip
1226 no_secured_ports
= [] # List of port-is with port-security disabled
1227 self
._reload
_connection
()
1228 # metadata_vpci = {} # For a specific neutron plugin
1229 block_device_mapping
= None
1231 for net
in net_list
:
1232 if not net
.get("net_id"): # skip non connected iface
1236 "network_id": net
["net_id"],
1237 "name": net
.get("name"),
1238 "admin_state_up": True
1240 if self
.config
.get("security_groups") and net
.get("port_security") is not False and \
1241 not self
.config
.get("no_port_security_extension"):
1242 if not self
.security_groups_id
:
1243 self
._get
_ids
_from
_name
()
1244 port_dict
["security_groups"] = self
.security_groups_id
1246 if net
["type"]=="virtual":
1249 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1250 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1252 # if "VF" not in metadata_vpci:
1253 # metadata_vpci["VF"]=[]
1254 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1255 port_dict
["binding:vnic_type"]="direct"
1256 # VIO specific Changes
1257 if self
.vim_type
== "VIO":
1258 # Need to create port with port_security_enabled = False and no-security-groups
1259 port_dict
["port_security_enabled"]=False
1260 port_dict
["provider_security_groups"]=[]
1261 port_dict
["security_groups"]=[]
1262 else: # For PT PCI-PASSTHROUGH
1263 # VIO specific Changes
1264 # Current VIO release does not support port with type 'direct-physical'
1265 # So no need to create virtual port in case of PCI-device.
1266 # Will update port_dict code when support gets added in next VIO release
1267 if self
.vim_type
== "VIO":
1268 raise vimconn
.vimconnNotSupportedException(
1269 "Current VIO release does not support full passthrough (PT)")
1271 # if "PF" not in metadata_vpci:
1272 # metadata_vpci["PF"]=[]
1273 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1274 port_dict
["binding:vnic_type"]="direct-physical"
1275 if not port_dict
["name"]:
1276 port_dict
["name"]=name
1277 if net
.get("mac_address"):
1278 port_dict
["mac_address"]=net
["mac_address"]
1279 if net
.get("ip_address"):
1280 port_dict
["fixed_ips"] = [{'ip_address': net
["ip_address"]}]
1281 # TODO add 'subnet_id': <subnet_id>
1282 new_port
= self
.neutron
.create_port({"port": port_dict
})
1283 created_items
["port:" + str(new_port
["port"]["id"])] = True
1284 net
["mac_adress"] = new_port
["port"]["mac_address"]
1285 net
["vim_id"] = new_port
["port"]["id"]
1286 # if try to use a network without subnetwork, it will return a emtpy list
1287 fixed_ips
= new_port
["port"].get("fixed_ips")
1289 net
["ip"] = fixed_ips
[0].get("ip_address")
1293 port
= {"port-id": new_port
["port"]["id"]}
1294 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1295 port
["tag"] = new_port
["port"]["name"]
1296 net_list_vim
.append(port
)
1298 if net
.get('floating_ip', False):
1299 net
['exit_on_floating_ip_error'] = True
1300 external_network
.append(net
)
1301 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
1302 net
['exit_on_floating_ip_error'] = False
1303 external_network
.append(net
)
1304 net
['floating_ip'] = self
.config
.get('use_floating_ip')
1306 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1307 # As a workaround we wait until the VM is active and then disable the port-security
1308 if net
.get("port_security") == False and not self
.config
.get("no_port_security_extension"):
1309 no_secured_ports
.append(new_port
["port"]["id"])
1312 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1313 # if len(metadata["pci_assignement"]) >255:
1314 # #limit the metadata size
1315 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1316 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1319 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1320 name
, image_id
, flavor_id
, str(net_list_vim
), description
)
1323 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1325 # Create additional volumes in case these are present in disk_list
1326 base_disk_index
= ord('b')
1328 block_device_mapping
= {}
1329 for disk
in disk_list
:
1330 if disk
.get('vim_id'):
1331 block_device_mapping
['_vd' + chr(base_disk_index
)] = disk
['vim_id']
1333 if 'image_id' in disk
:
1334 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1335 chr(base_disk_index
), imageRef
=disk
['image_id'])
1337 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1338 chr(base_disk_index
))
1339 created_items
["volume:" + str(volume
.id)] = True
1340 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
1341 base_disk_index
+= 1
1343 # Wait until created volumes are with status available
1345 while elapsed_time
< volume_timeout
:
1346 for created_item
in created_items
:
1347 v
, _
, volume_id
= created_item
.partition(":")
1349 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
1351 else: # all ready: break from while
1355 # If we exceeded the timeout rollback
1356 if elapsed_time
>= volume_timeout
:
1357 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
1358 http_code
=vimconn
.HTTP_Request_Timeout
)
1359 # get availability Zone
1360 vm_av_zone
= self
._get
_vm
_availability
_zone
(availability_zone_index
, availability_zone_list
)
1362 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1363 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1364 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
1365 self
.config
.get("security_groups"), vm_av_zone
,
1366 self
.config
.get('keypair'), userdata
, config_drive
,
1367 block_device_mapping
))
1368 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
,
1369 security_groups
=self
.config
.get("security_groups"),
1370 # TODO remove security_groups in future versions. Already at neutron port
1371 availability_zone
=vm_av_zone
,
1372 key_name
=self
.config
.get('keypair'),
1374 config_drive
=config_drive
,
1375 block_device_mapping
=block_device_mapping
1376 ) # , description=description)
1378 vm_start_time
= time
.time()
1379 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1380 if no_secured_ports
:
1381 self
.__wait
_for
_vm
(server
.id, 'ACTIVE')
1383 for port_id
in no_secured_ports
:
1385 self
.neutron
.update_port(port_id
,
1386 {"port": {"port_security_enabled": False, "security_groups": None}})
1387 except Exception as e
:
1388 raise vimconn
.vimconnException("It was not possible to disable port security for port {}".format(
1390 # print "DONE :-)", server
1393 if external_network
:
1394 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
1395 for floating_network
in external_network
:
1400 ip
= floating_ips
.pop(0)
1401 if ip
.get("port_id", False) or ip
.get('tenant_id') != server
.tenant_id
:
1403 if isinstance(floating_network
['floating_ip'], str):
1404 if ip
.get("floating_network_id") != floating_network
['floating_ip']:
1406 free_floating_ip
= ip
["id"]
1408 if isinstance(floating_network
['floating_ip'], str) and \
1409 floating_network
['floating_ip'].lower() != "true":
1410 pool_id
= floating_network
['floating_ip']
1412 # Find the external network
1413 external_nets
= list()
1414 for net
in self
.neutron
.list_networks()['networks']:
1415 if net
['router:external']:
1416 external_nets
.append(net
)
1418 if len(external_nets
) == 0:
1419 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
1420 "network is present",
1421 http_code
=vimconn
.HTTP_Conflict
)
1422 if len(external_nets
) > 1:
1423 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
1424 "external networks are present",
1425 http_code
=vimconn
.HTTP_Conflict
)
1427 pool_id
= external_nets
[0].get('id')
1428 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
1430 # self.logger.debug("Creating floating IP")
1431 new_floating_ip
= self
.neutron
.create_floatingip(param
)
1432 free_floating_ip
= new_floating_ip
['floatingip']['id']
1433 except Exception as e
:
1434 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create new floating_ip " +
1435 str(e
), http_code
=vimconn
.HTTP_Conflict
)
1439 # the vim_id key contains the neutron.port_id
1440 self
.neutron
.update_floatingip(free_floating_ip
,
1441 {"floatingip": {"port_id": floating_network
["vim_id"]}})
1442 # Using nove is deprecated on nova client 10.0
1444 except Exception as e
:
1445 # openstack need some time after VM creation to asign an IP. So retry if fails
1446 vm_status
= self
.nova
.servers
.get(server
.id).status
1447 if vm_status
!= 'ACTIVE' and vm_status
!= 'ERROR':
1448 if time
.time() - vm_start_time
< server_timeout
:
1451 raise vimconn
.vimconnException(
1452 "Cannot create floating_ip: {} {}".format(type(e
).__name
__, e
),
1453 http_code
=vimconn
.HTTP_Conflict
)
1455 except Exception as e
:
1456 if not floating_network
['exit_on_floating_ip_error']:
1457 self
.logger
.warning("Cannot create floating_ip. %s", str(e
))
1461 return server
.id, created_items
1462 # except nvExceptions.NotFound as e:
1463 # error_value=-vimconn.HTTP_Not_Found
1464 # error_text= "vm instance %s not found" % vm_id
1465 # except TypeError as e:
1466 # raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
1468 except Exception as e
:
1471 server_id
= server
.id
1473 self
.delete_vminstance(server_id
, created_items
)
1474 except Exception as e2
:
1475 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
1477 self
._format
_exception
(e
)
1479 def get_vminstance(self
,vm_id
):
1480 '''Returns the VM instance information from VIM'''
1481 #self.logger.debug("Getting VM from VIM")
1483 self
._reload
_connection
()
1484 server
= self
.nova
.servers
.find(id=vm_id
)
1485 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1486 return server
.to_dict()
1487 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1488 self
._format
_exception
(e
)
1490 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1492 Get a console for the virtual machine
1494 vm_id: uuid of the VM
1495 console_type, can be:
1496 "novnc" (by default), "xvpvnc" for VNC types,
1497 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1498 Returns dict with the console parameters:
1499 protocol: ssh, ftp, http, https, ...
1500 server: usually ip address
1501 port: the http, ssh, ... port
1502 suffix: extra text, e.g. the http path and query string
1504 self
.logger
.debug("Getting VM CONSOLE from VIM")
1506 self
._reload
_connection
()
1507 server
= self
.nova
.servers
.find(id=vm_id
)
1508 if console_type
== None or console_type
== "novnc":
1509 console_dict
= server
.get_vnc_console("novnc")
1510 elif console_type
== "xvpvnc":
1511 console_dict
= server
.get_vnc_console(console_type
)
1512 elif console_type
== "rdp-html5":
1513 console_dict
= server
.get_rdp_console(console_type
)
1514 elif console_type
== "spice-html5":
1515 console_dict
= server
.get_spice_console(console_type
)
1517 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1519 console_dict1
= console_dict
.get("console")
1521 console_url
= console_dict1
.get("url")
1524 protocol_index
= console_url
.find("//")
1525 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1526 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1527 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1528 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1529 console_dict
={"protocol": console_url
[0:protocol_index
],
1530 "server": console_url
[protocol_index
+2:port_index
],
1531 "port": console_url
[port_index
:suffix_index
],
1532 "suffix": console_url
[suffix_index
+1:]
1536 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1538 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1539 self
._format
_exception
(e
)
1541 def delete_vminstance(self
, vm_id
, created_items
=None):
1542 '''Removes a VM instance from VIM. Returns the old identifier
1544 #print "osconnector: Getting VM from VIM"
1545 if created_items
== None:
1548 self
._reload
_connection
()
1549 # delete VM ports attached to this networks before the virtual machine
1550 for k
, v
in created_items
.items():
1551 if not v
: # skip already deleted
1554 k_item
, _
, k_id
= k
.partition(":")
1555 if k_item
== "port":
1556 self
.neutron
.delete_port(k_id
)
1557 except Exception as e
:
1558 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
1560 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1561 # #dettach volumes attached
1562 # server = self.nova.servers.get(vm_id)
1563 # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
1564 # #for volume in volumes_attached_dict:
1565 # # self.cinder.volumes.detach(volume['id'])
1568 self
.nova
.servers
.delete(vm_id
)
1570 # delete volumes. Although having detached, they should have in active status before deleting
1571 # we ensure in this loop
1574 while keep_waiting
and elapsed_time
< volume_timeout
:
1575 keep_waiting
= False
1576 for k
, v
in created_items
.items():
1577 if not v
: # skip already deleted
1580 k_item
, _
, k_id
= k
.partition(":")
1581 if k_item
== "volume":
1582 if self
.cinder
.volumes
.get(k_id
).status
!= 'available':
1585 self
.cinder
.volumes
.delete(k_id
)
1586 except Exception as e
:
1587 self
.logger
.error("Error deleting volume: {}: {}".format(type(e
).__name
__, e
))
1592 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1593 self
._format
_exception
(e
)
1595 def refresh_vms_status(self
, vm_list
):
1596 '''Get the status of the virtual machines and their interfaces/ports
1597 Params: the list of VM identifiers
1598 Returns a dictionary with:
1599 vm_id: #VIM id of this Virtual Machine
1600 status: #Mandatory. Text with one of:
1601 # DELETED (not found at vim)
1602 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1603 # OTHER (Vim reported other status not understood)
1604 # ERROR (VIM indicates an ERROR status)
1605 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1606 # CREATING (on building process), ERROR
1607 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1609 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1610 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1612 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1613 mac_address: #Text format XX:XX:XX:XX:XX:XX
1614 vim_net_id: #network id where this interface is connected
1615 vim_interface_id: #interface/port VIM id
1616 ip_address: #null, or text with IPv4, IPv6 address
1617 compute_node: #identification of compute node where PF,VF interface is allocated
1618 pci: #PCI address of the NIC that hosts the PF,VF
1619 vlan: #physical VLAN used for VF
1622 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1623 for vm_id
in vm_list
:
1626 vm_vim
= self
.get_vminstance(vm_id
)
1627 if vm_vim
['status'] in vmStatus2manoFormat
:
1628 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1630 vm
['status'] = "OTHER"
1631 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1633 vm
['vim_info'] = self
.serialize(vm_vim
)
1635 vm
["interfaces"] = []
1636 if vm_vim
.get('fault'):
1637 vm
['error_msg'] = str(vm_vim
['fault'])
1640 self
._reload
_connection
()
1641 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
1642 for port
in port_dict
["ports"]:
1644 interface
['vim_info'] = self
.serialize(port
)
1645 interface
["mac_address"] = port
.get("mac_address")
1646 interface
["vim_net_id"] = port
["network_id"]
1647 interface
["vim_interface_id"] = port
["id"]
1648 # check if OS-EXT-SRV-ATTR:host is there,
1649 # in case of non-admin credentials, it will be missing
1650 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1651 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1652 interface
["pci"] = None
1654 # check if binding:profile is there,
1655 # in case of non-admin credentials, it will be missing
1656 if port
.get('binding:profile'):
1657 if port
['binding:profile'].get('pci_slot'):
1658 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1659 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1660 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1661 pci
= port
['binding:profile']['pci_slot']
1662 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1663 interface
["pci"] = pci
1664 interface
["vlan"] = None
1665 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1666 network
= self
.neutron
.show_network(port
["network_id"])
1667 if network
['network'].get('provider:network_type') == 'vlan' and \
1668 port
.get("binding:vnic_type") in ("direct", "direct-physical"):
1669 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1671 #look for floating ip address
1673 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1674 if floating_ip_dict
.get("floatingips"):
1675 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1679 for subnet
in port
["fixed_ips"]:
1680 ips
.append(subnet
["ip_address"])
1681 interface
["ip_address"] = ";".join(ips
)
1682 vm
["interfaces"].append(interface
)
1683 except Exception as e
:
1684 self
.logger
.error("Error getting vm interface information {}: {}".format(type(e
).__name
__, e
),
1686 except vimconn
.vimconnNotFoundException
as e
:
1687 self
.logger
.error("Exception getting vm status: %s", str(e
))
1688 vm
['status'] = "DELETED"
1689 vm
['error_msg'] = str(e
)
1690 except vimconn
.vimconnException
as e
:
1691 self
.logger
.error("Exception getting vm status: %s", str(e
))
1692 vm
['status'] = "VIM_ERROR"
1693 vm
['error_msg'] = str(e
)
1697 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1698 '''Send and action over a VM instance from VIM
1699 Returns None or the console dict if the action was successfully sent to the VIM'''
1700 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1702 self
._reload
_connection
()
1703 server
= self
.nova
.servers
.find(id=vm_id
)
1704 if "start" in action_dict
:
1705 if action_dict
["start"]=="rebuild":
1708 if server
.status
=="PAUSED":
1710 elif server
.status
=="SUSPENDED":
1712 elif server
.status
=="SHUTOFF":
1714 elif "pause" in action_dict
:
1716 elif "resume" in action_dict
:
1718 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1720 elif "forceOff" in action_dict
:
1722 elif "terminate" in action_dict
:
1724 elif "createImage" in action_dict
:
1725 server
.create_image()
1726 #"path":path_schema,
1727 #"description":description_schema,
1728 #"name":name_schema,
1729 #"metadata":metadata_schema,
1730 #"imageRef": id_schema,
1731 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1732 elif "rebuild" in action_dict
:
1733 server
.rebuild(server
.image
['id'])
1734 elif "reboot" in action_dict
:
1735 server
.reboot() #reboot_type='SOFT'
1736 elif "console" in action_dict
:
1737 console_type
= action_dict
["console"]
1738 if console_type
== None or console_type
== "novnc":
1739 console_dict
= server
.get_vnc_console("novnc")
1740 elif console_type
== "xvpvnc":
1741 console_dict
= server
.get_vnc_console(console_type
)
1742 elif console_type
== "rdp-html5":
1743 console_dict
= server
.get_rdp_console(console_type
)
1744 elif console_type
== "spice-html5":
1745 console_dict
= server
.get_spice_console(console_type
)
1747 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1748 http_code
=vimconn
.HTTP_Bad_Request
)
1750 console_url
= console_dict
["console"]["url"]
1752 protocol_index
= console_url
.find("//")
1753 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1754 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1755 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1756 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1757 console_dict2
={"protocol": console_url
[0:protocol_index
],
1758 "server": console_url
[protocol_index
+2 : port_index
],
1759 "port": int(console_url
[port_index
+1 : suffix_index
]),
1760 "suffix": console_url
[suffix_index
+1:]
1762 return console_dict2
1763 except Exception as e
:
1764 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1767 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1768 self
._format
_exception
(e
)
1769 #TODO insert exception vimconn.HTTP_Unauthorized
1771 ####### VIO Specific Changes #########
1772 def _generate_vlanID(self
):
1774 Method to get unused vlanID
1782 networks
= self
.get_network_list()
1783 for net
in networks
:
1784 if net
.get('provider:segmentation_id'):
1785 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1786 used_vlanIDs
= set(usedVlanIDs
)
1788 #find unused VLAN ID
1789 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1791 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1792 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
1793 if vlanID
not in used_vlanIDs
:
1795 except Exception as exp
:
1796 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1798 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1799 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1802 def _generate_multisegment_vlanID(self
):
1804 Method to get unused vlanID
1812 networks
= self
.get_network_list()
1813 for net
in networks
:
1814 if net
.get('provider:network_type') == "vlan" and net
.get('provider:segmentation_id'):
1815 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1816 elif net
.get('segments'):
1817 for segment
in net
.get('segments'):
1818 if segment
.get('provider:network_type') == "vlan" and segment
.get('provider:segmentation_id'):
1819 usedVlanIDs
.append(segment
.get('provider:segmentation_id'))
1820 used_vlanIDs
= set(usedVlanIDs
)
1822 # find unused VLAN ID
1823 for vlanID_range
in self
.config
.get('multisegment_vlan_range'):
1825 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1826 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
1827 if vlanID
not in used_vlanIDs
:
1829 except Exception as exp
:
1830 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1832 raise vimconn
.vimconnConflictException("Unable to create the VLAN segment."
1833 " All VLAN IDs {} are in use.".format(self
.config
.get('multisegment_vlan_range')))
1836 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
1838 Method to validate user given vlanID ranges
1842 for vlanID_range
in input_vlan_range
:
1843 vlan_range
= vlanID_range
.replace(" ", "")
1845 vlanID_pattern
= r
'(\d)*-(\d)*$'
1846 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1848 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}.You must provide "\
1849 "'{}' in format [start_ID - end_ID].".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1851 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1852 if start_vlanid
<= 0 :
1853 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1854 "Start ID can not be zero. For VLAN "\
1855 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1856 if end_vlanid
> 4094 :
1857 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1858 "End VLAN ID can not be greater than 4094. For VLAN "\
1859 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1861 if start_vlanid
> end_vlanid
:
1862 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1863 "You must provide '{}' in format start_ID - end_ID and "\
1864 "start_ID < end_ID ".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1868 def new_external_port(self
, port_data
):
1869 #TODO openstack if needed
1870 '''Adds a external port to VIM'''
1871 '''Returns the port identifier'''
1872 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1874 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1875 #TODO openstack if needed
1876 '''Connects a external port to a network'''
1877 '''Returns status code of the VIM response'''
1878 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1880 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1881 '''Adds a new user to openstack VIM'''
1882 '''Returns the user identifier'''
1883 self
.logger
.debug("osconnector: Adding a new user to VIM")
1885 self
._reload
_connection
()
1886 user
=self
.keystone
.users
.create(user_name
, password
=user_passwd
, default_project
=tenant_id
)
1887 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1889 except ksExceptions
.ConnectionError
as e
:
1890 error_value
=-vimconn
.HTTP_Bad_Request
1891 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1892 except ksExceptions
.ClientException
as e
: #TODO remove
1893 error_value
=-vimconn
.HTTP_Bad_Request
1894 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1895 #TODO insert exception vimconn.HTTP_Unauthorized
1896 #if reaching here is because an exception
1897 self
.logger
.debug("new_user " + error_text
)
1898 return error_value
, error_text
1900 def delete_user(self
, user_id
):
1901 '''Delete a user from openstack VIM'''
1902 '''Returns the user identifier'''
1904 print("osconnector: Deleting a user from VIM")
1906 self
._reload
_connection
()
1907 self
.keystone
.users
.delete(user_id
)
1909 except ksExceptions
.ConnectionError
as e
:
1910 error_value
=-vimconn
.HTTP_Bad_Request
1911 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1912 except ksExceptions
.NotFound
as e
:
1913 error_value
=-vimconn
.HTTP_Not_Found
1914 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1915 except ksExceptions
.ClientException
as e
: #TODO remove
1916 error_value
=-vimconn
.HTTP_Bad_Request
1917 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1918 #TODO insert exception vimconn.HTTP_Unauthorized
1919 #if reaching here is because an exception
1920 self
.logger
.debug("delete_tenant " + error_text
)
1921 return error_value
, error_text
1923 def get_hosts_info(self
):
1924 '''Get the information of deployed hosts
1925 Returns the hosts content'''
1927 print("osconnector: Getting Host info from VIM")
1930 self
._reload
_connection
()
1931 hypervisors
= self
.nova
.hypervisors
.list()
1932 for hype
in hypervisors
:
1933 h_list
.append( hype
.to_dict() )
1934 return 1, {"hosts":h_list
}
1935 except nvExceptions
.NotFound
as e
:
1936 error_value
=-vimconn
.HTTP_Not_Found
1937 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1938 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1939 error_value
=-vimconn
.HTTP_Bad_Request
1940 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1941 #TODO insert exception vimconn.HTTP_Unauthorized
1942 #if reaching here is because an exception
1943 self
.logger
.debug("get_hosts_info " + error_text
)
1944 return error_value
, error_text
1946 def get_hosts(self
, vim_tenant
):
1947 '''Get the hosts and deployed instances
1948 Returns the hosts content'''
1949 r
, hype_dict
= self
.get_hosts_info()
1952 hypervisors
= hype_dict
["hosts"]
1954 servers
= self
.nova
.servers
.list()
1955 for hype
in hypervisors
:
1956 for server
in servers
:
1957 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1959 hype
['vm'].append(server
.id)
1961 hype
['vm'] = [server
.id]
1963 except nvExceptions
.NotFound
as e
:
1964 error_value
=-vimconn
.HTTP_Not_Found
1965 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1966 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1967 error_value
=-vimconn
.HTTP_Bad_Request
1968 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1969 #TODO insert exception vimconn.HTTP_Unauthorized
1970 #if reaching here is because an exception
1971 self
.logger
.debug("get_hosts " + error_text
)
1972 return error_value
, error_text
1974 def new_classification(self
, name
, ctype
, definition
):
1975 self
.logger
.debug('Adding a new (Traffic) Classification to VIM, named %s', name
)
1978 self
._reload
_connection
()
1979 if ctype
not in supportedClassificationTypes
:
1980 raise vimconn
.vimconnNotSupportedException(
1981 'OpenStack VIM connector doesn\'t support provided '
1982 'Classification Type {}, supported ones are: '
1983 '{}'.format(ctype
, supportedClassificationTypes
))
1984 if not self
._validate
_classification
(ctype
, definition
):
1985 raise vimconn
.vimconnException(
1986 'Incorrect Classification definition '
1987 'for the type specified.')
1988 classification_dict
= definition
1989 classification_dict
['name'] = name
1991 new_class
= self
.neutron
.create_sfc_flow_classifier(
1992 {'flow_classifier': classification_dict
})
1993 return new_class
['flow_classifier']['id']
1994 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1995 neExceptions
.NeutronException
, ConnectionError
) as e
:
1997 'Creation of Classification failed.')
1998 self
._format
_exception
(e
)
2000 def get_classification(self
, class_id
):
2001 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
2002 filter_dict
= {"id": class_id
}
2003 class_list
= self
.get_classification_list(filter_dict
)
2004 if len(class_list
) == 0:
2005 raise vimconn
.vimconnNotFoundException(
2006 "Classification '{}' not found".format(class_id
))
2007 elif len(class_list
) > 1:
2008 raise vimconn
.vimconnConflictException(
2009 "Found more than one Classification with this criteria")
2010 classification
= class_list
[0]
2011 return classification
2013 def get_classification_list(self
, filter_dict
={}):
2014 self
.logger
.debug("Getting Classifications from VIM filter: '%s'",
2017 filter_dict_os
= filter_dict
.copy()
2018 self
._reload
_connection
()
2019 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2020 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2021 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
2023 classification_list
= classification_dict
["flow_classifiers"]
2024 self
.__classification
_os
2mano
(classification_list
)
2025 return classification_list
2026 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2027 neExceptions
.NeutronException
, ConnectionError
) as e
:
2028 self
._format
_exception
(e
)
2030 def delete_classification(self
, class_id
):
2031 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
2033 self
._reload
_connection
()
2034 self
.neutron
.delete_sfc_flow_classifier(class_id
)
2036 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2037 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2038 ConnectionError
) as e
:
2039 self
._format
_exception
(e
)
2041 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
2042 self
.logger
.debug("Adding a new Service Function Instance to VIM, named '%s'", name
)
2045 self
._reload
_connection
()
2049 if len(ingress_ports
) != 1:
2050 raise vimconn
.vimconnNotSupportedException(
2051 "OpenStack VIM connector can only have "
2052 "1 ingress port per SFI")
2053 if len(egress_ports
) != 1:
2054 raise vimconn
.vimconnNotSupportedException(
2055 "OpenStack VIM connector can only have "
2056 "1 egress port per SFI")
2057 sfi_dict
= {'name': name
,
2058 'ingress': ingress_ports
[0],
2059 'egress': egress_ports
[0],
2060 'service_function_parameters': {
2061 'correlation': correlation
}}
2062 new_sfi
= self
.neutron
.create_sfc_port_pair({'port_pair': sfi_dict
})
2063 return new_sfi
['port_pair']['id']
2064 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2065 neExceptions
.NeutronException
, ConnectionError
) as e
:
2068 self
.neutron
.delete_sfc_port_pair(
2069 new_sfi
['port_pair']['id'])
2072 'Creation of Service Function Instance failed, with '
2073 'subsequent deletion failure as well.')
2074 self
._format
_exception
(e
)
2076 def get_sfi(self
, sfi_id
):
2077 self
.logger
.debug('Getting Service Function Instance %s from VIM', sfi_id
)
2078 filter_dict
= {"id": sfi_id
}
2079 sfi_list
= self
.get_sfi_list(filter_dict
)
2080 if len(sfi_list
) == 0:
2081 raise vimconn
.vimconnNotFoundException("Service Function Instance '{}' not found".format(sfi_id
))
2082 elif len(sfi_list
) > 1:
2083 raise vimconn
.vimconnConflictException(
2084 'Found more than one Service Function Instance '
2085 'with this criteria')
2089 def get_sfi_list(self
, filter_dict
={}):
2090 self
.logger
.debug("Getting Service Function Instances from VIM filter: '%s'", str(filter_dict
))
2092 self
._reload
_connection
()
2093 filter_dict_os
= filter_dict
.copy()
2094 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2095 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2096 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
2097 sfi_list
= sfi_dict
["port_pairs"]
2098 self
.__sfi
_os
2mano
(sfi_list
)
2100 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2101 neExceptions
.NeutronException
, ConnectionError
) as e
:
2102 self
._format
_exception
(e
)
2104 def delete_sfi(self
, sfi_id
):
2105 self
.logger
.debug("Deleting Service Function Instance '%s' "
2108 self
._reload
_connection
()
2109 self
.neutron
.delete_sfc_port_pair(sfi_id
)
2111 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2112 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2113 ConnectionError
) as e
:
2114 self
._format
_exception
(e
)
2116 def new_sf(self
, name
, sfis
, sfc_encap
=True):
2117 self
.logger
.debug("Adding a new Service Function to VIM, named '%s'", name
)
2120 self
._reload
_connection
()
2121 # correlation = None
2123 # correlation = 'nsh'
2124 for instance
in sfis
:
2125 sfi
= self
.get_sfi(instance
)
2126 if sfi
.get('sfc_encap') != sfc_encap
:
2127 raise vimconn
.vimconnNotSupportedException(
2128 "OpenStack VIM connector requires all SFIs of the "
2129 "same SF to share the same SFC Encapsulation")
2130 sf_dict
= {'name': name
,
2132 new_sf
= self
.neutron
.create_sfc_port_pair_group({
2133 'port_pair_group': sf_dict
})
2134 return new_sf
['port_pair_group']['id']
2135 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2136 neExceptions
.NeutronException
, ConnectionError
) as e
:
2139 self
.neutron
.delete_sfc_port_pair_group(
2140 new_sf
['port_pair_group']['id'])
2143 'Creation of Service Function failed, with '
2144 'subsequent deletion failure as well.')
2145 self
._format
_exception
(e
)
2147 def get_sf(self
, sf_id
):
2148 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
2149 filter_dict
= {"id": sf_id
}
2150 sf_list
= self
.get_sf_list(filter_dict
)
2151 if len(sf_list
) == 0:
2152 raise vimconn
.vimconnNotFoundException(
2153 "Service Function '{}' not found".format(sf_id
))
2154 elif len(sf_list
) > 1:
2155 raise vimconn
.vimconnConflictException(
2156 "Found more than one Service Function with this criteria")
2160 def get_sf_list(self
, filter_dict
={}):
2161 self
.logger
.debug("Getting Service Function from VIM filter: '%s'",
2164 self
._reload
_connection
()
2165 filter_dict_os
= filter_dict
.copy()
2166 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2167 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2168 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
2169 sf_list
= sf_dict
["port_pair_groups"]
2170 self
.__sf
_os
2mano
(sf_list
)
2172 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2173 neExceptions
.NeutronException
, ConnectionError
) as e
:
2174 self
._format
_exception
(e
)
2176 def delete_sf(self
, sf_id
):
2177 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
2179 self
._reload
_connection
()
2180 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
2182 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2183 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2184 ConnectionError
) as e
:
2185 self
._format
_exception
(e
)
2187 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
2188 self
.logger
.debug("Adding a new Service Function Path to VIM, named '%s'", name
)
2191 self
._reload
_connection
()
2192 # In networking-sfc the MPLS encapsulation is legacy
2193 # should be used when no full SFC Encapsulation is intended
2194 correlation
= 'mpls'
2197 sfp_dict
= {'name': name
,
2198 'flow_classifiers': classifications
,
2199 'port_pair_groups': sfs
,
2200 'chain_parameters': {'correlation': correlation
}}
2202 sfp_dict
['chain_id'] = spi
2203 new_sfp
= self
.neutron
.create_sfc_port_chain({'port_chain': sfp_dict
})
2204 return new_sfp
["port_chain"]["id"]
2205 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2206 neExceptions
.NeutronException
, ConnectionError
) as e
:
2209 self
.neutron
.delete_sfc_port_chain(new_sfp
['port_chain']['id'])
2212 'Creation of Service Function Path failed, with '
2213 'subsequent deletion failure as well.')
2214 self
._format
_exception
(e
)
2216 def get_sfp(self
, sfp_id
):
2217 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
2218 filter_dict
= {"id": sfp_id
}
2219 sfp_list
= self
.get_sfp_list(filter_dict
)
2220 if len(sfp_list
) == 0:
2221 raise vimconn
.vimconnNotFoundException(
2222 "Service Function Path '{}' not found".format(sfp_id
))
2223 elif len(sfp_list
) > 1:
2224 raise vimconn
.vimconnConflictException(
2225 "Found more than one Service Function Path with this criteria")
2229 def get_sfp_list(self
, filter_dict
={}):
2230 self
.logger
.debug("Getting Service Function Paths from VIM filter: '%s'", str(filter_dict
))
2232 self
._reload
_connection
()
2233 filter_dict_os
= filter_dict
.copy()
2234 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2235 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2236 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
2237 sfp_list
= sfp_dict
["port_chains"]
2238 self
.__sfp
_os
2mano
(sfp_list
)
2240 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2241 neExceptions
.NeutronException
, ConnectionError
) as e
:
2242 self
._format
_exception
(e
)
2244 def delete_sfp(self
, sfp_id
):
2245 self
.logger
.debug("Deleting Service Function Path '%s' from VIM", sfp_id
)
2247 self
._reload
_connection
()
2248 self
.neutron
.delete_sfc_port_chain(sfp_id
)
2250 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2251 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2252 ConnectionError
) as e
:
2253 self
._format
_exception
(e
)
2256 def refresh_sfps_status(self
, sfp_list
):
2257 '''Get the status of the service function path
2258 Params: the list of sfp identifiers
2259 Returns a dictionary with:
2260 vm_id: #VIM id of this service function path
2261 status: #Mandatory. Text with one of:
2262 # DELETED (not found at vim)
2263 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2264 # OTHER (Vim reported other status not understood)
2265 # ERROR (VIM indicates an ERROR status)
2267 # CREATING (on building process)
2268 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2269 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)F
2272 self
.logger
.debug("refresh_sfps status: Getting tenant SFP information from VIM")
2273 for sfp_id
in sfp_list
:
2276 sfp_vim
= self
.get_sfp(sfp_id
)
2278 sfp
['status'] = vmStatus2manoFormat
[ 'ACTIVE' ]
2280 sfp
['status'] = "OTHER"
2281 sfp
['error_msg'] = "VIM status reported " + vm_vim
['status']
2283 sfp
['vim_info'] = self
.serialize(sfp_vim
)
2285 if sfp_vim
.get('fault'):
2286 sfp
['error_msg'] = str(sfp_vim
['fault'])
2288 except vimconn
.vimconnNotFoundException
as e
:
2289 self
.logger
.error("Exception getting sfp status: %s", str(e
))
2290 sfp
['status'] = "DELETED"
2291 sfp
['error_msg'] = str(e
)
2292 except vimconn
.vimconnException
as e
:
2293 self
.logger
.error("Exception getting sfp status: %s", str(e
))
2294 sfp
['status'] = "VIM_ERROR"
2295 sfp
['error_msg'] = str(e
)
2296 sfp_dict
[sfp_id
] = sfp
2300 def refresh_sfis_status(self
, sfi_list
):
2301 '''Get the status of the service function instances
2302 Params: the list of sfi identifiers
2303 Returns a dictionary with:
2304 vm_id: #VIM id of this service function instance
2305 status: #Mandatory. Text with one of:
2306 # DELETED (not found at vim)
2307 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2308 # OTHER (Vim reported other status not understood)
2309 # ERROR (VIM indicates an ERROR status)
2311 # CREATING (on building process)
2312 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2313 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2316 self
.logger
.debug("refresh_sfis status: Getting tenant sfi information from VIM")
2317 for sfi_id
in sfi_list
:
2320 sfi_vim
= self
.get_sfi(sfi_id
)
2322 sfi
['status'] = vmStatus2manoFormat
[ 'ACTIVE' ]
2324 sfi
['status'] = "OTHER"
2325 sfi
['error_msg'] = "VIM status reported " + vm_vim
['status']
2327 sfi
['vim_info'] = self
.serialize(sfi_vim
)
2329 if sfi_vim
.get('fault'):
2330 sfi
['error_msg'] = str(sfi_vim
['fault'])
2332 except vimconn
.vimconnNotFoundException
as e
:
2333 self
.logger
.error("Exception getting sfi status: %s", str(e
))
2334 sfi
['status'] = "DELETED"
2335 sfi
['error_msg'] = str(e
)
2336 except vimconn
.vimconnException
as e
:
2337 self
.logger
.error("Exception getting sfi status: %s", str(e
))
2338 sfi
['status'] = "VIM_ERROR"
2339 sfi
['error_msg'] = str(e
)
2340 sfi_dict
[sfi_id
] = sfi
2344 def refresh_sfs_status(self
, sf_list
):
2345 '''Get the status of the service functions
2346 Params: the list of sf identifiers
2347 Returns a dictionary with:
2348 vm_id: #VIM id of this service function
2349 status: #Mandatory. Text with one of:
2350 # DELETED (not found at vim)
2351 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2352 # OTHER (Vim reported other status not understood)
2353 # ERROR (VIM indicates an ERROR status)
2355 # CREATING (on building process)
2356 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2357 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2360 self
.logger
.debug("refresh_sfs status: Getting tenant sf information from VIM")
2361 for sf_id
in sf_list
:
2364 sf_vim
= self
.get_sf(sf_id
)
2366 sf
['status'] = vmStatus2manoFormat
[ 'ACTIVE' ]
2368 sf
['status'] = "OTHER"
2369 sf
['error_msg'] = "VIM status reported " + vm_vim
['status']
2371 sf
['vim_info'] = self
.serialize(sf_vim
)
2373 if sf_vim
.get('fault'):
2374 sf
['error_msg'] = str(sf_vim
['fault'])
2376 except vimconn
.vimconnNotFoundException
as e
:
2377 self
.logger
.error("Exception getting sf status: %s", str(e
))
2378 sf
['status'] = "DELETED"
2379 sf
['error_msg'] = str(e
)
2380 except vimconn
.vimconnException
as e
:
2381 self
.logger
.error("Exception getting sf status: %s", str(e
))
2382 sf
['status'] = "VIM_ERROR"
2383 sf
['error_msg'] = str(e
)
2389 def refresh_classifications_status(self
, classification_list
):
2390 '''Get the status of the classifications
2391 Params: the list of classification identifiers
2392 Returns a dictionary with:
2393 vm_id: #VIM id of this classifier
2394 status: #Mandatory. Text with one of:
2395 # DELETED (not found at vim)
2396 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
2397 # OTHER (Vim reported other status not understood)
2398 # ERROR (VIM indicates an ERROR status)
2400 # CREATING (on building process)
2401 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
2402 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
2404 classification_dict
={}
2405 self
.logger
.debug("refresh_classifications status: Getting tenant classification information from VIM")
2406 for classification_id
in classification_list
:
2409 classification_vim
= self
.get_classification(classification_id
)
2410 if classification_vim
:
2411 classification
['status'] = vmStatus2manoFormat
[ 'ACTIVE' ]
2413 classification
['status'] = "OTHER"
2414 classification
['error_msg'] = "VIM status reported " + vm_vim
['status']
2416 classification
['vim_info'] = self
.serialize(classification_vim
)
2418 if classification_vim
.get('fault'):
2419 classification
['error_msg'] = str(classification_vim
['fault'])
2421 except vimconn
.vimconnNotFoundException
as e
:
2422 self
.logger
.error("Exception getting classification status: %s", str(e
))
2423 classification
['status'] = "DELETED"
2424 classification
['error_msg'] = str(e
)
2425 except vimconn
.vimconnException
as e
:
2426 self
.logger
.error("Exception getting classification status: %s", str(e
))
2427 classification
['status'] = "VIM_ERROR"
2428 classification
['error_msg'] = str(e
)
2429 classification_dict
[classification_id
] = classification
2430 return classification_dict