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