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 if self
.config
.get("disable_network_port_security"):
575 network_dict
["port_security_enabled"] = False
576 new_net
= self
.neutron
.create_network({'network':network_dict
})
578 # create subnetwork, even if there is no profile
581 if not ip_profile
.get('subnet_address'):
582 #Fake subnet is required
583 subnet_rand
= random
.randint(0, 255)
584 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
585 if 'ip_version' not in ip_profile
:
586 ip_profile
['ip_version'] = "IPv4"
587 subnet
= {"name": net_name
+"-subnet",
588 "network_id": new_net
["network"]["id"],
589 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
590 "cidr": ip_profile
['subnet_address']
592 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
593 if ip_profile
.get('gateway_address'):
594 subnet
['gateway_ip'] = ip_profile
['gateway_address']
596 subnet
['gateway_ip'] = None
597 if ip_profile
.get('dns_address'):
598 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
599 if 'dhcp_enabled' in ip_profile
:
600 subnet
['enable_dhcp'] = False if \
601 ip_profile
['dhcp_enabled']=="false" or ip_profile
['dhcp_enabled']==False else True
602 if ip_profile
.get('dhcp_start_address'):
603 subnet
['allocation_pools'] = []
604 subnet
['allocation_pools'].append(dict())
605 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
606 if ip_profile
.get('dhcp_count'):
607 #parts = ip_profile['dhcp_start_address'].split('.')
608 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
609 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
610 ip_int
+= ip_profile
['dhcp_count'] - 1
611 ip_str
= str(netaddr
.IPAddress(ip_int
))
612 subnet
['allocation_pools'][0]['end'] = ip_str
613 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
614 self
.neutron
.create_subnet({"subnet": subnet
} )
616 if net_type
== "data" and self
.config
.get('multisegment_support'):
617 if self
.config
.get('l2gw_support'):
618 l2gw_list
= self
.neutron
.list_l2_gateways().get("l2_gateways", ())
619 for l2gw
in l2gw_list
:
621 l2gw_conn
["l2_gateway_id"] = l2gw
["id"]
622 l2gw_conn
["network_id"] = new_net
["network"]["id"]
623 l2gw_conn
["segmentation_id"] = str(vlanID
)
624 new_l2gw_conn
= self
.neutron
.create_l2_gateway_connection({"l2_gateway_connection": l2gw_conn
})
625 created_items
["l2gwconn:" + str(new_l2gw_conn
["l2_gateway_connection"]["id"])] = True
626 return new_net
["network"]["id"], created_items
627 except Exception as e
:
628 #delete l2gw connections (if any) before deleting the network
629 for k
, v
in created_items
.items():
630 if not v
: # skip already deleted
633 k_item
, _
, k_id
= k
.partition(":")
634 if k_item
== "l2gwconn":
635 self
.neutron
.delete_l2_gateway_connection(k_id
)
636 except Exception as e2
:
637 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e2
).__name
__, e2
))
639 self
.neutron
.delete_network(new_net
['network']['id'])
640 self
._format
_exception
(e
)
642 def get_network_list(self
, filter_dict
={}):
643 '''Obtain tenant networks of VIM
649 admin_state_up: boolean
651 Returns the network list of dictionaries
653 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
655 self
._reload
_connection
()
656 filter_dict_os
= filter_dict
.copy()
657 if self
.api_version3
and "tenant_id" in filter_dict_os
:
658 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id') #T ODO check
659 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
660 net_list
= net_dict
["networks"]
661 self
.__net
_os
2mano
(net_list
)
663 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
664 self
._format
_exception
(e
)
666 def get_network(self
, net_id
):
667 '''Obtain details of network from VIM
668 Returns the network information from a network id'''
669 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
670 filter_dict
={"id": net_id
}
671 net_list
= self
.get_network_list(filter_dict
)
673 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
674 elif len(net_list
)>1:
675 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
678 for subnet_id
in net
.get("subnets", () ):
680 subnet
= self
.neutron
.show_subnet(subnet_id
)
681 except Exception as e
:
682 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
683 subnet
= {"id": subnet_id
, "fault": str(e
)}
684 subnets
.append(subnet
)
685 net
["subnets"] = subnets
686 net
["encapsulation"] = net
.get('provider:network_type')
687 net
["encapsulation_type"] = net
.get('provider:network_type')
688 net
["segmentation_id"] = net
.get('provider:segmentation_id')
689 net
["encapsulation_id"] = net
.get('provider:segmentation_id')
692 def delete_network(self
, net_id
, created_items
=None):
694 Removes a tenant network from VIM and its associated elements
695 :param net_id: VIM identifier of the network, provided by method new_network
696 :param created_items: dictionary with extra items to be deleted. provided by method new_network
697 Returns the network identifier or raises an exception upon error or when network is not found
699 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
700 if created_items
== None:
703 self
._reload
_connection
()
704 #delete l2gw connections (if any) before deleting the network
705 for k
, v
in created_items
.items():
706 if not v
: # skip already deleted
709 k_item
, _
, k_id
= k
.partition(":")
710 if k_item
== "l2gwconn":
711 self
.neutron
.delete_l2_gateway_connection(k_id
)
712 except Exception as e
:
713 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e
).__name
__, e
))
714 #delete VM ports attached to this networks before the network
715 ports
= self
.neutron
.list_ports(network_id
=net_id
)
716 for p
in ports
['ports']:
718 self
.neutron
.delete_port(p
["id"])
719 except Exception as e
:
720 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
721 self
.neutron
.delete_network(net_id
)
723 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
724 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
725 self
._format
_exception
(e
)
727 def refresh_nets_status(self
, net_list
):
728 '''Get the status of the networks
729 Params: the list of network identifiers
730 Returns a dictionary with:
731 net_id: #VIM id of this network
732 status: #Mandatory. Text with one of:
733 # DELETED (not found at vim)
734 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
735 # OTHER (Vim reported other status not understood)
736 # ERROR (VIM indicates an ERROR status)
737 # ACTIVE, INACTIVE, DOWN (admin down),
738 # BUILD (on building process)
740 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
741 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
745 for net_id
in net_list
:
748 net_vim
= self
.get_network(net_id
)
749 if net_vim
['status'] in netStatus2manoFormat
:
750 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
752 net
["status"] = "OTHER"
753 net
["error_msg"] = "VIM status reported " + net_vim
['status']
755 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
756 net
['status'] = 'DOWN'
758 net
['vim_info'] = self
.serialize(net_vim
)
760 if net_vim
.get('fault'): #TODO
761 net
['error_msg'] = str(net_vim
['fault'])
762 except vimconn
.vimconnNotFoundException
as e
:
763 self
.logger
.error("Exception getting net status: %s", str(e
))
764 net
['status'] = "DELETED"
765 net
['error_msg'] = str(e
)
766 except vimconn
.vimconnException
as e
:
767 self
.logger
.error("Exception getting net status: %s", str(e
))
768 net
['status'] = "VIM_ERROR"
769 net
['error_msg'] = str(e
)
770 net_dict
[net_id
] = net
773 def get_flavor(self
, flavor_id
):
774 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
775 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
777 self
._reload
_connection
()
778 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
779 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
780 return flavor
.to_dict()
781 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
782 self
._format
_exception
(e
)
784 def get_flavor_id_from_data(self
, flavor_dict
):
785 """Obtain flavor id that match the flavor description
786 Returns the flavor_id or raises a vimconnNotFoundException
787 flavor_dict: contains the required ram, vcpus, disk
788 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
789 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
790 vimconnNotFoundException is raised
792 exact_match
= False if self
.config
.get('use_existing_flavors') else True
794 self
._reload
_connection
()
795 flavor_candidate_id
= None
796 flavor_candidate_data
= (10000, 10000, 10000)
797 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
799 extended
= flavor_dict
.get("extended", {})
802 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemented")
804 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
806 # numas = extended.get("numas")
807 for flavor
in self
.nova
.flavors
.list():
808 epa
= flavor
.get_keys()
812 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
813 if flavor_data
== flavor_target
:
815 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
816 flavor_candidate_id
= flavor
.id
817 flavor_candidate_data
= flavor_data
818 if not exact_match
and flavor_candidate_id
:
819 return flavor_candidate_id
820 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
821 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
822 self
._format
_exception
(e
)
824 def process_resource_quota(self
, quota
, prefix
, extra_specs
):
831 extra_specs
["quota:" + prefix
+ "_limit"] = quota
['limit']
832 if 'reserve' in quota
:
833 extra_specs
["quota:" + prefix
+ "_reservation"] = quota
['reserve']
834 if 'shares' in quota
:
835 extra_specs
["quota:" + prefix
+ "_shares_level"] = "custom"
836 extra_specs
["quota:" + prefix
+ "_shares_share"] = quota
['shares']
838 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
839 '''Adds a tenant flavor to openstack VIM
840 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
841 Returns the flavor identifier
843 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
848 name
=flavor_data
['name']
849 while retry
<max_retries
:
852 self
._reload
_connection
()
853 if change_name_if_used
:
856 fl
=self
.nova
.flavors
.list()
858 fl_names
.append(f
.name
)
859 while name
in fl_names
:
861 name
= flavor_data
['name']+"-" + str(name_suffix
)
863 ram
= flavor_data
.get('ram',64)
864 vcpus
= flavor_data
.get('vcpus',1)
867 extended
= flavor_data
.get("extended")
869 numas
=extended
.get("numas")
871 numa_nodes
= len(numas
)
873 return -1, "Can not add flavor with more than one numa"
874 extra_specs
["hw:numa_nodes"] = str(numa_nodes
)
875 extra_specs
["hw:mem_page_size"] = "large"
876 extra_specs
["hw:cpu_policy"] = "dedicated"
877 extra_specs
["hw:numa_mempolicy"] = "strict"
878 if self
.vim_type
== "VIO":
879 extra_specs
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
880 extra_specs
["vmware:latency_sensitivity_level"] = "high"
882 #overwrite ram and vcpus
883 #check if key 'memory' is present in numa else use ram value at flavor
885 ram
= numa
['memory']*1024
886 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
887 extra_specs
["hw:cpu_sockets"] = 1
888 if 'paired-threads' in numa
:
889 vcpus
= numa
['paired-threads']*2
890 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
891 extra_specs
["hw:cpu_thread_policy"] = "require"
892 extra_specs
["hw:cpu_policy"] = "dedicated"
893 elif 'cores' in numa
:
894 vcpus
= numa
['cores']
895 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
896 extra_specs
["hw:cpu_thread_policy"] = "isolate"
897 extra_specs
["hw:cpu_policy"] = "dedicated"
898 elif 'threads' in numa
:
899 vcpus
= numa
['threads']
900 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
901 extra_specs
["hw:cpu_thread_policy"] = "prefer"
902 extra_specs
["hw:cpu_policy"] = "dedicated"
903 # for interface in numa.get("interfaces",() ):
904 # if interface["dedicated"]=="yes":
905 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
906 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
907 elif extended
.get("cpu-quota"):
908 self
.process_resource_quota(extended
.get("cpu-quota"), "cpu", extra_specs
)
909 if extended
.get("mem-quota"):
910 self
.process_resource_quota(extended
.get("mem-quota"), "memory", extra_specs
)
911 if extended
.get("vif-quota"):
912 self
.process_resource_quota(extended
.get("vif-quota"), "vif", extra_specs
)
913 if extended
.get("disk-io-quota"):
914 self
.process_resource_quota(extended
.get("disk-io-quota"), "disk_io", extra_specs
)
916 new_flavor
=self
.nova
.flavors
.create(name
,
919 flavor_data
.get('disk',0),
920 is_public
=flavor_data
.get('is_public', True)
924 new_flavor
.set_keys(extra_specs
)
926 except nvExceptions
.Conflict
as e
:
927 if change_name_if_used
and retry
< max_retries
:
929 self
._format
_exception
(e
)
930 #except nvExceptions.BadRequest as e:
931 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
, KeyError) as e
:
932 self
._format
_exception
(e
)
934 def delete_flavor(self
,flavor_id
):
935 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
938 self
._reload
_connection
()
939 self
.nova
.flavors
.delete(flavor_id
)
941 #except nvExceptions.BadRequest as e:
942 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
943 self
._format
_exception
(e
)
945 def new_image(self
,image_dict
):
947 Adds a tenant image to VIM. imge_dict is a dictionary with:
949 disk_format: qcow2, vhd, vmdk, raw (by default), ...
950 location: path or URI
951 public: "yes" or "no"
952 metadata: metadata of the image
957 while retry
<max_retries
:
960 self
._reload
_connection
()
961 #determine format http://docs.openstack.org/developer/glance/formats.html
962 if "disk_format" in image_dict
:
963 disk_format
=image_dict
["disk_format"]
964 else: #autodiscover based on extension
965 if image_dict
['location'].endswith(".qcow2"):
967 elif image_dict
['location'].endswith(".vhd"):
969 elif image_dict
['location'].endswith(".vmdk"):
971 elif image_dict
['location'].endswith(".vdi"):
973 elif image_dict
['location'].endswith(".iso"):
975 elif image_dict
['location'].endswith(".aki"):
977 elif image_dict
['location'].endswith(".ari"):
979 elif image_dict
['location'].endswith(".ami"):
983 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
984 if self
.vim_type
== "VIO":
985 container_format
= "bare"
986 if 'container_format' in image_dict
:
987 container_format
= image_dict
['container_format']
988 new_image
= self
.glance
.images
.create(name
=image_dict
['name'], container_format
=container_format
,
989 disk_format
=disk_format
)
991 new_image
= self
.glance
.images
.create(name
=image_dict
['name'])
992 if image_dict
['location'].startswith("http"):
993 # TODO there is not a method to direct download. It must be downloaded locally with requests
994 raise vimconn
.vimconnNotImplemented("Cannot create image from URL")
996 with
open(image_dict
['location']) as fimage
:
997 self
.glance
.images
.upload(new_image
.id, fimage
)
998 #new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
999 # container_format="bare", data=fimage, disk_format=disk_format)
1000 metadata_to_load
= image_dict
.get('metadata')
1001 # TODO location is a reserved word for current openstack versions. fixed for VIO please check for openstack
1002 if self
.vim_type
== "VIO":
1003 metadata_to_load
['upload_location'] = image_dict
['location']
1005 metadata_to_load
['location'] = image_dict
['location']
1006 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1008 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1009 self
._format
_exception
(e
)
1010 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1011 if retry
==max_retries
:
1013 self
._format
_exception
(e
)
1014 except IOError as e
: #can not open the file
1015 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
1016 http_code
=vimconn
.HTTP_Bad_Request
)
1018 def delete_image(self
, image_id
):
1019 '''Deletes a tenant image from openstack VIM. Returns the old id
1022 self
._reload
_connection
()
1023 self
.glance
.images
.delete(image_id
)
1025 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, gl1Exceptions
.HTTPNotFound
, ConnectionError
) as e
: #TODO remove
1026 self
._format
_exception
(e
)
1028 def get_image_id_from_path(self
, path
):
1029 '''Get the image id from image path in the VIM database. Returns the image_id'''
1031 self
._reload
_connection
()
1032 images
= self
.glance
.images
.list()
1033 for image
in images
:
1034 if image
.metadata
.get("location")==path
:
1036 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
1037 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1038 self
._format
_exception
(e
)
1040 def get_image_list(self
, filter_dict
={}):
1041 '''Obtain tenant images from VIM
1045 checksum: image checksum
1046 Returns the image list of dictionaries:
1047 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1050 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1052 self
._reload
_connection
()
1053 filter_dict_os
= filter_dict
.copy()
1054 #First we filter by the available filter fields: name, id. The others are removed.
1055 image_list
= self
.glance
.images
.list()
1057 for image
in image_list
:
1059 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1061 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1063 if filter_dict
.get("checksum") and image
["checksum"] != filter_dict
["checksum"]:
1066 filtered_list
.append(image
.copy())
1067 except gl1Exceptions
.HTTPNotFound
:
1069 return filtered_list
1070 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1071 self
._format
_exception
(e
)
1073 def __wait_for_vm(self
, vm_id
, status
):
1074 """wait until vm is in the desired status and return True.
1075 If the VM gets in ERROR status, return false.
1076 If the timeout is reached generate an exception"""
1078 while elapsed_time
< server_timeout
:
1079 vm_status
= self
.nova
.servers
.get(vm_id
).status
1080 if vm_status
== status
:
1082 if vm_status
== 'ERROR':
1087 # if we exceeded the timeout rollback
1088 if elapsed_time
>= server_timeout
:
1089 raise vimconn
.vimconnException('Timeout waiting for instance ' + vm_id
+ ' to get ' + status
,
1090 http_code
=vimconn
.HTTP_Request_Timeout
)
1092 def _get_openstack_availablity_zones(self
):
1094 Get from openstack availability zones available
1098 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1099 openstack_availability_zone
= [str(zone
.zoneName
) for zone
in openstack_availability_zone
1100 if zone
.zoneName
!= 'internal']
1101 return openstack_availability_zone
1102 except Exception as e
:
1105 def _set_availablity_zones(self
):
1107 Set vim availablity zone
1111 if 'availability_zone' in self
.config
:
1112 vim_availability_zones
= self
.config
.get('availability_zone')
1113 if isinstance(vim_availability_zones
, str):
1114 self
.availability_zone
= [vim_availability_zones
]
1115 elif isinstance(vim_availability_zones
, list):
1116 self
.availability_zone
= vim_availability_zones
1118 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1120 def _get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
1122 Return thge availability zone to be used by the created VM.
1123 :return: The VIM availability zone to be used or None
1125 if availability_zone_index
is None:
1126 if not self
.config
.get('availability_zone'):
1128 elif isinstance(self
.config
.get('availability_zone'), str):
1129 return self
.config
['availability_zone']
1131 # TODO consider using a different parameter at config for default AV and AV list match
1132 return self
.config
['availability_zone'][0]
1134 vim_availability_zones
= self
.availability_zone
1135 # check if VIM offer enough availability zones describe in the VNFD
1136 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
1137 # check if all the names of NFV AV match VIM AV names
1138 match_by_index
= False
1139 for av
in availability_zone_list
:
1140 if av
not in vim_availability_zones
:
1141 match_by_index
= True
1144 return vim_availability_zones
[availability_zone_index
]
1146 return availability_zone_list
[availability_zone_index
]
1148 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
1150 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
1151 availability_zone_index
=None, availability_zone_list
=None):
1152 """Adds a VM instance to VIM
1154 start: indicates if VM must start or boot in pause mode. Ignored
1155 image_id,flavor_id: iamge and flavor uuid
1156 net_list: list of interfaces, each one is a dictionary with:
1158 net_id: network uuid to connect
1159 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
1160 model: interface model, ignored #TODO
1161 mac_address: used for SR-IOV ifaces #TODO for other types
1162 use: 'data', 'bridge', 'mgmt'
1163 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
1164 vim_id: filled/added by this function
1165 floating_ip: True/False (or it can be None)
1166 'cloud_config': (optional) dictionary with:
1167 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1168 'users': (optional) list of users to be inserted, each item is a dict with:
1169 'name': (mandatory) user name,
1170 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1171 'user-data': (optional) string is a text script to be passed directly to cloud-init
1172 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1173 'dest': (mandatory) string with the destination absolute path
1174 'encoding': (optional, by default text). Can be one of:
1175 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1176 'content' (mandatory): string with the content of the file
1177 'permissions': (optional) string with file permissions, typically octal notation '0644'
1178 'owner': (optional) file owner, string with the format 'owner:group'
1179 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1180 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1181 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1182 'size': (mandatory) string with the size of the disk in GB
1183 'vim_id' (optional) should use this existing volume id
1184 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1185 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1186 availability_zone_index is None
1187 #TODO ip, security groups
1188 Returns a tuple with the instance identifier and created_items or raises an exception on error
1189 created_items can be None or a dictionary where this method can include key-values that will be passed to
1190 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1191 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1194 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
1200 external_network
= [] # list of external networks to be connected to instance, later on used to create floating_ip
1201 no_secured_ports
= [] # List of port-is with port-security disabled
1202 self
._reload
_connection
()
1203 # metadata_vpci = {} # For a specific neutron plugin
1204 block_device_mapping
= None
1206 for net
in net_list
:
1207 if not net
.get("net_id"): # skip non connected iface
1211 "network_id": net
["net_id"],
1212 "name": net
.get("name"),
1213 "admin_state_up": True
1215 if self
.config
.get("security_groups") and net
.get("port_security") is not False and \
1216 not self
.config
.get("no_port_security_extension"):
1217 if not self
.security_groups_id
:
1218 self
._get
_ids
_from
_name
()
1219 port_dict
["security_groups"] = self
.security_groups_id
1221 if net
["type"]=="virtual":
1224 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1225 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1227 # if "VF" not in metadata_vpci:
1228 # metadata_vpci["VF"]=[]
1229 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1230 port_dict
["binding:vnic_type"]="direct"
1231 # VIO specific Changes
1232 if self
.vim_type
== "VIO":
1233 # Need to create port with port_security_enabled = False and no-security-groups
1234 port_dict
["port_security_enabled"]=False
1235 port_dict
["provider_security_groups"]=[]
1236 port_dict
["security_groups"]=[]
1237 else: # For PT PCI-PASSTHROUGH
1238 # VIO specific Changes
1239 # Current VIO release does not support port with type 'direct-physical'
1240 # So no need to create virtual port in case of PCI-device.
1241 # Will update port_dict code when support gets added in next VIO release
1242 if self
.vim_type
== "VIO":
1243 raise vimconn
.vimconnNotSupportedException(
1244 "Current VIO release does not support full passthrough (PT)")
1246 # if "PF" not in metadata_vpci:
1247 # metadata_vpci["PF"]=[]
1248 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1249 port_dict
["binding:vnic_type"]="direct-physical"
1250 if not port_dict
["name"]:
1251 port_dict
["name"]=name
1252 if net
.get("mac_address"):
1253 port_dict
["mac_address"]=net
["mac_address"]
1254 if net
.get("ip_address"):
1255 port_dict
["fixed_ips"] = [{'ip_address': net
["ip_address"]}]
1256 # TODO add 'subnet_id': <subnet_id>
1257 new_port
= self
.neutron
.create_port({"port": port_dict
})
1258 created_items
["port:" + str(new_port
["port"]["id"])] = True
1259 net
["mac_adress"] = new_port
["port"]["mac_address"]
1260 net
["vim_id"] = new_port
["port"]["id"]
1261 # if try to use a network without subnetwork, it will return a emtpy list
1262 fixed_ips
= new_port
["port"].get("fixed_ips")
1264 net
["ip"] = fixed_ips
[0].get("ip_address")
1268 port
= {"port-id": new_port
["port"]["id"]}
1269 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1270 port
["tag"] = new_port
["port"]["name"]
1271 net_list_vim
.append(port
)
1273 if net
.get('floating_ip', False):
1274 net
['exit_on_floating_ip_error'] = True
1275 external_network
.append(net
)
1276 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
1277 net
['exit_on_floating_ip_error'] = False
1278 external_network
.append(net
)
1279 net
['floating_ip'] = self
.config
.get('use_floating_ip')
1281 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1282 # As a workaround we wait until the VM is active and then disable the port-security
1283 if net
.get("port_security") == False and not self
.config
.get("no_port_security_extension"):
1284 no_secured_ports
.append(new_port
["port"]["id"])
1287 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1288 # if len(metadata["pci_assignement"]) >255:
1289 # #limit the metadata size
1290 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1291 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1294 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1295 name
, image_id
, flavor_id
, str(net_list_vim
), description
)
1298 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1300 # Create additional volumes in case these are present in disk_list
1301 base_disk_index
= ord('b')
1303 block_device_mapping
= {}
1304 for disk
in disk_list
:
1305 if disk
.get('vim_id'):
1306 block_device_mapping
['_vd' + chr(base_disk_index
)] = disk
['vim_id']
1308 if 'image_id' in disk
:
1309 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1310 chr(base_disk_index
), imageRef
=disk
['image_id'])
1312 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1313 chr(base_disk_index
))
1314 created_items
["volume:" + str(volume
.id)] = True
1315 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
1316 base_disk_index
+= 1
1318 # Wait until created volumes are with status available
1320 while elapsed_time
< volume_timeout
:
1321 for created_item
in created_items
:
1322 v
, _
, volume_id
= created_item
.partition(":")
1324 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
1326 else: # all ready: break from while
1330 # If we exceeded the timeout rollback
1331 if elapsed_time
>= volume_timeout
:
1332 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
1333 http_code
=vimconn
.HTTP_Request_Timeout
)
1334 # get availability Zone
1335 vm_av_zone
= self
._get
_vm
_availability
_zone
(availability_zone_index
, availability_zone_list
)
1337 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1338 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1339 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
1340 self
.config
.get("security_groups"), vm_av_zone
,
1341 self
.config
.get('keypair'), userdata
, config_drive
,
1342 block_device_mapping
))
1343 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
,
1344 security_groups
=self
.config
.get("security_groups"),
1345 # TODO remove security_groups in future versions. Already at neutron port
1346 availability_zone
=vm_av_zone
,
1347 key_name
=self
.config
.get('keypair'),
1349 config_drive
=config_drive
,
1350 block_device_mapping
=block_device_mapping
1351 ) # , description=description)
1353 vm_start_time
= time
.time()
1354 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1355 if no_secured_ports
:
1356 self
.__wait
_for
_vm
(server
.id, 'ACTIVE')
1358 for port_id
in no_secured_ports
:
1360 self
.neutron
.update_port(port_id
,
1361 {"port": {"port_security_enabled": False, "security_groups": None}})
1362 except Exception as e
:
1363 raise vimconn
.vimconnException("It was not possible to disable port security for port {}".format(
1365 # print "DONE :-)", server
1368 if external_network
:
1369 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
1370 for floating_network
in external_network
:
1375 ip
= floating_ips
.pop(0)
1376 if ip
.get("port_id", False) or ip
.get('tenant_id') != server
.tenant_id
:
1378 if isinstance(floating_network
['floating_ip'], str):
1379 if ip
.get("floating_network_id") != floating_network
['floating_ip']:
1381 free_floating_ip
= ip
.get("floating_ip_address")
1383 if isinstance(floating_network
['floating_ip'], str) and \
1384 floating_network
['floating_ip'].lower() != "true":
1385 pool_id
= floating_network
['floating_ip']
1387 # Find the external network
1388 external_nets
= list()
1389 for net
in self
.neutron
.list_networks()['networks']:
1390 if net
['router:external']:
1391 external_nets
.append(net
)
1393 if len(external_nets
) == 0:
1394 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
1395 "network is present",
1396 http_code
=vimconn
.HTTP_Conflict
)
1397 if len(external_nets
) > 1:
1398 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
1399 "external networks are present",
1400 http_code
=vimconn
.HTTP_Conflict
)
1402 pool_id
= external_nets
[0].get('id')
1403 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
1405 # self.logger.debug("Creating floating IP")
1406 new_floating_ip
= self
.neutron
.create_floatingip(param
)
1407 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
1408 except Exception as e
:
1409 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create new floating_ip " +
1410 str(e
), http_code
=vimconn
.HTTP_Conflict
)
1412 fix_ip
= floating_network
.get('ip')
1415 server
.add_floating_ip(free_floating_ip
, fix_ip
)
1417 except Exception as e
:
1418 # openstack need some time after VM creation to asign an IP. So retry if fails
1419 vm_status
= self
.nova
.servers
.get(server
.id).status
1420 if vm_status
!= 'ACTIVE' and vm_status
!= 'ERROR':
1421 if time
.time() - vm_start_time
< server_timeout
:
1424 raise vimconn
.vimconnException(
1425 "Cannot create floating_ip: {} {}".format(type(e
).__name
__, e
),
1426 http_code
=vimconn
.HTTP_Conflict
)
1428 except Exception as e
:
1429 if not floating_network
['exit_on_floating_ip_error']:
1430 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
1434 return server
.id, created_items
1435 # except nvExceptions.NotFound as e:
1436 # error_value=-vimconn.HTTP_Not_Found
1437 # error_text= "vm instance %s not found" % vm_id
1438 # except TypeError as e:
1439 # raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
1441 except Exception as e
:
1444 server_id
= server
.id
1446 self
.delete_vminstance(server_id
, created_items
)
1447 except Exception as e2
:
1448 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
1450 self
._format
_exception
(e
)
1452 def get_vminstance(self
,vm_id
):
1453 '''Returns the VM instance information from VIM'''
1454 #self.logger.debug("Getting VM from VIM")
1456 self
._reload
_connection
()
1457 server
= self
.nova
.servers
.find(id=vm_id
)
1458 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1459 return server
.to_dict()
1460 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1461 self
._format
_exception
(e
)
1463 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1465 Get a console for the virtual machine
1467 vm_id: uuid of the VM
1468 console_type, can be:
1469 "novnc" (by default), "xvpvnc" for VNC types,
1470 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1471 Returns dict with the console parameters:
1472 protocol: ssh, ftp, http, https, ...
1473 server: usually ip address
1474 port: the http, ssh, ... port
1475 suffix: extra text, e.g. the http path and query string
1477 self
.logger
.debug("Getting VM CONSOLE from VIM")
1479 self
._reload
_connection
()
1480 server
= self
.nova
.servers
.find(id=vm_id
)
1481 if console_type
== None or console_type
== "novnc":
1482 console_dict
= server
.get_vnc_console("novnc")
1483 elif console_type
== "xvpvnc":
1484 console_dict
= server
.get_vnc_console(console_type
)
1485 elif console_type
== "rdp-html5":
1486 console_dict
= server
.get_rdp_console(console_type
)
1487 elif console_type
== "spice-html5":
1488 console_dict
= server
.get_spice_console(console_type
)
1490 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1492 console_dict1
= console_dict
.get("console")
1494 console_url
= console_dict1
.get("url")
1497 protocol_index
= console_url
.find("//")
1498 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1499 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1500 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1501 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1502 console_dict
={"protocol": console_url
[0:protocol_index
],
1503 "server": console_url
[protocol_index
+2:port_index
],
1504 "port": console_url
[port_index
:suffix_index
],
1505 "suffix": console_url
[suffix_index
+1:]
1509 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1511 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1512 self
._format
_exception
(e
)
1514 def delete_vminstance(self
, vm_id
, created_items
=None):
1515 '''Removes a VM instance from VIM. Returns the old identifier
1517 #print "osconnector: Getting VM from VIM"
1518 if created_items
== None:
1521 self
._reload
_connection
()
1522 # delete VM ports attached to this networks before the virtual machine
1523 for k
, v
in created_items
.items():
1524 if not v
: # skip already deleted
1527 k_item
, _
, k_id
= k
.partition(":")
1528 if k_item
== "port":
1529 self
.neutron
.delete_port(k_id
)
1530 except Exception as e
:
1531 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
1533 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1534 # #dettach volumes attached
1535 # server = self.nova.servers.get(vm_id)
1536 # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
1537 # #for volume in volumes_attached_dict:
1538 # # self.cinder.volumes.detach(volume['id'])
1541 self
.nova
.servers
.delete(vm_id
)
1543 # delete volumes. Although having detached, they should have in active status before deleting
1544 # we ensure in this loop
1547 while keep_waiting
and elapsed_time
< volume_timeout
:
1548 keep_waiting
= False
1549 for k
, v
in created_items
.items():
1550 if not v
: # skip already deleted
1553 k_item
, _
, k_id
= k
.partition(":")
1554 if k_item
== "volume":
1555 if self
.cinder
.volumes
.get(k_id
).status
!= 'available':
1558 self
.cinder
.volumes
.delete(k_id
)
1559 except Exception as e
:
1560 self
.logger
.error("Error deleting volume: {}: {}".format(type(e
).__name
__, e
))
1565 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1566 self
._format
_exception
(e
)
1568 def refresh_vms_status(self
, vm_list
):
1569 '''Get the status of the virtual machines and their interfaces/ports
1570 Params: the list of VM identifiers
1571 Returns a dictionary with:
1572 vm_id: #VIM id of this Virtual Machine
1573 status: #Mandatory. Text with one of:
1574 # DELETED (not found at vim)
1575 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1576 # OTHER (Vim reported other status not understood)
1577 # ERROR (VIM indicates an ERROR status)
1578 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1579 # CREATING (on building process), ERROR
1580 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1582 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1583 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1585 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1586 mac_address: #Text format XX:XX:XX:XX:XX:XX
1587 vim_net_id: #network id where this interface is connected
1588 vim_interface_id: #interface/port VIM id
1589 ip_address: #null, or text with IPv4, IPv6 address
1590 compute_node: #identification of compute node where PF,VF interface is allocated
1591 pci: #PCI address of the NIC that hosts the PF,VF
1592 vlan: #physical VLAN used for VF
1595 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1596 for vm_id
in vm_list
:
1599 vm_vim
= self
.get_vminstance(vm_id
)
1600 if vm_vim
['status'] in vmStatus2manoFormat
:
1601 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1603 vm
['status'] = "OTHER"
1604 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1606 vm
['vim_info'] = self
.serialize(vm_vim
)
1608 vm
["interfaces"] = []
1609 if vm_vim
.get('fault'):
1610 vm
['error_msg'] = str(vm_vim
['fault'])
1613 self
._reload
_connection
()
1614 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
1615 for port
in port_dict
["ports"]:
1617 interface
['vim_info'] = self
.serialize(port
)
1618 interface
["mac_address"] = port
.get("mac_address")
1619 interface
["vim_net_id"] = port
["network_id"]
1620 interface
["vim_interface_id"] = port
["id"]
1621 # check if OS-EXT-SRV-ATTR:host is there,
1622 # in case of non-admin credentials, it will be missing
1623 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1624 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1625 interface
["pci"] = None
1627 # check if binding:profile is there,
1628 # in case of non-admin credentials, it will be missing
1629 if port
.get('binding:profile'):
1630 if port
['binding:profile'].get('pci_slot'):
1631 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1632 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1633 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1634 pci
= port
['binding:profile']['pci_slot']
1635 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1636 interface
["pci"] = pci
1637 interface
["vlan"] = None
1638 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1639 network
= self
.neutron
.show_network(port
["network_id"])
1640 if network
['network'].get('provider:network_type') == 'vlan' and \
1641 port
.get("binding:vnic_type") == "direct":
1642 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1644 #look for floating ip address
1646 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1647 if floating_ip_dict
.get("floatingips"):
1648 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1652 for subnet
in port
["fixed_ips"]:
1653 ips
.append(subnet
["ip_address"])
1654 interface
["ip_address"] = ";".join(ips
)
1655 vm
["interfaces"].append(interface
)
1656 except Exception as e
:
1657 self
.logger
.error("Error getting vm interface information {}: {}".format(type(e
).__name
__, e
),
1659 except vimconn
.vimconnNotFoundException
as e
:
1660 self
.logger
.error("Exception getting vm status: %s", str(e
))
1661 vm
['status'] = "DELETED"
1662 vm
['error_msg'] = str(e
)
1663 except vimconn
.vimconnException
as e
:
1664 self
.logger
.error("Exception getting vm status: %s", str(e
))
1665 vm
['status'] = "VIM_ERROR"
1666 vm
['error_msg'] = str(e
)
1670 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1671 '''Send and action over a VM instance from VIM
1672 Returns None or the console dict if the action was successfully sent to the VIM'''
1673 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1675 self
._reload
_connection
()
1676 server
= self
.nova
.servers
.find(id=vm_id
)
1677 if "start" in action_dict
:
1678 if action_dict
["start"]=="rebuild":
1681 if server
.status
=="PAUSED":
1683 elif server
.status
=="SUSPENDED":
1685 elif server
.status
=="SHUTOFF":
1687 elif "pause" in action_dict
:
1689 elif "resume" in action_dict
:
1691 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1693 elif "forceOff" in action_dict
:
1695 elif "terminate" in action_dict
:
1697 elif "createImage" in action_dict
:
1698 server
.create_image()
1699 #"path":path_schema,
1700 #"description":description_schema,
1701 #"name":name_schema,
1702 #"metadata":metadata_schema,
1703 #"imageRef": id_schema,
1704 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1705 elif "rebuild" in action_dict
:
1706 server
.rebuild(server
.image
['id'])
1707 elif "reboot" in action_dict
:
1708 server
.reboot() #reboot_type='SOFT'
1709 elif "console" in action_dict
:
1710 console_type
= action_dict
["console"]
1711 if console_type
== None or console_type
== "novnc":
1712 console_dict
= server
.get_vnc_console("novnc")
1713 elif console_type
== "xvpvnc":
1714 console_dict
= server
.get_vnc_console(console_type
)
1715 elif console_type
== "rdp-html5":
1716 console_dict
= server
.get_rdp_console(console_type
)
1717 elif console_type
== "spice-html5":
1718 console_dict
= server
.get_spice_console(console_type
)
1720 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1721 http_code
=vimconn
.HTTP_Bad_Request
)
1723 console_url
= console_dict
["console"]["url"]
1725 protocol_index
= console_url
.find("//")
1726 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1727 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1728 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1729 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1730 console_dict2
={"protocol": console_url
[0:protocol_index
],
1731 "server": console_url
[protocol_index
+2 : port_index
],
1732 "port": int(console_url
[port_index
+1 : suffix_index
]),
1733 "suffix": console_url
[suffix_index
+1:]
1735 return console_dict2
1736 except Exception as e
:
1737 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1740 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1741 self
._format
_exception
(e
)
1742 #TODO insert exception vimconn.HTTP_Unauthorized
1744 ####### VIO Specific Changes #########
1745 def _generate_vlanID(self
):
1747 Method to get unused vlanID
1755 networks
= self
.get_network_list()
1756 for net
in networks
:
1757 if net
.get('provider:segmentation_id'):
1758 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1759 used_vlanIDs
= set(usedVlanIDs
)
1761 #find unused VLAN ID
1762 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1764 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1765 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1766 if vlanID
not in used_vlanIDs
:
1768 except Exception as exp
:
1769 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1771 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1772 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1775 def _generate_multisegment_vlanID(self
):
1777 Method to get unused vlanID
1785 networks
= self
.get_network_list()
1786 for net
in networks
:
1787 if net
.get('provider:network_type') == "vlan" and net
.get('provider:segmentation_id'):
1788 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1789 elif net
.get('segments'):
1790 for segment
in net
.get('segments'):
1791 if segment
.get('provider:network_type') == "vlan" and segment
.get('provider:segmentation_id'):
1792 usedVlanIDs
.append(segment
.get('provider:segmentation_id'))
1793 used_vlanIDs
= set(usedVlanIDs
)
1795 #find unused VLAN ID
1796 for vlanID_range
in self
.config
.get('multisegment_vlan_range'):
1798 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1799 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1800 if vlanID
not in used_vlanIDs
:
1802 except Exception as exp
:
1803 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1805 raise vimconn
.vimconnConflictException("Unable to create the VLAN segment."\
1806 " All VLAN IDs {} are in use.".format(self
.config
.get('multisegment_vlan_range')))
1809 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
1811 Method to validate user given vlanID ranges
1815 for vlanID_range
in input_vlan_range
:
1816 vlan_range
= vlanID_range
.replace(" ", "")
1818 vlanID_pattern
= r
'(\d)*-(\d)*$'
1819 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1821 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}.You must provide "\
1822 "'{}' in format [start_ID - end_ID].".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1824 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1825 if start_vlanid
<= 0 :
1826 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1827 "Start ID can not be zero. For VLAN "\
1828 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1829 if end_vlanid
> 4094 :
1830 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1831 "End VLAN ID can not be greater than 4094. For VLAN "\
1832 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1834 if start_vlanid
> end_vlanid
:
1835 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1836 "You must provide '{}' in format start_ID - end_ID and "\
1837 "start_ID < end_ID ".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1841 def new_external_port(self
, port_data
):
1842 #TODO openstack if needed
1843 '''Adds a external port to VIM'''
1844 '''Returns the port identifier'''
1845 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1847 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1848 #TODO openstack if needed
1849 '''Connects a external port to a network'''
1850 '''Returns status code of the VIM response'''
1851 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1853 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1854 '''Adds a new user to openstack VIM'''
1855 '''Returns the user identifier'''
1856 self
.logger
.debug("osconnector: Adding a new user to VIM")
1858 self
._reload
_connection
()
1859 user
=self
.keystone
.users
.create(user_name
, password
=user_passwd
, default_project
=tenant_id
)
1860 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1862 except ksExceptions
.ConnectionError
as e
:
1863 error_value
=-vimconn
.HTTP_Bad_Request
1864 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1865 except ksExceptions
.ClientException
as e
: #TODO remove
1866 error_value
=-vimconn
.HTTP_Bad_Request
1867 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1868 #TODO insert exception vimconn.HTTP_Unauthorized
1869 #if reaching here is because an exception
1870 self
.logger
.debug("new_user " + error_text
)
1871 return error_value
, error_text
1873 def delete_user(self
, user_id
):
1874 '''Delete a user from openstack VIM'''
1875 '''Returns the user identifier'''
1877 print("osconnector: Deleting a user from VIM")
1879 self
._reload
_connection
()
1880 self
.keystone
.users
.delete(user_id
)
1882 except ksExceptions
.ConnectionError
as e
:
1883 error_value
=-vimconn
.HTTP_Bad_Request
1884 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1885 except ksExceptions
.NotFound
as e
:
1886 error_value
=-vimconn
.HTTP_Not_Found
1887 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1888 except ksExceptions
.ClientException
as e
: #TODO remove
1889 error_value
=-vimconn
.HTTP_Bad_Request
1890 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1891 #TODO insert exception vimconn.HTTP_Unauthorized
1892 #if reaching here is because an exception
1893 self
.logger
.debug("delete_tenant " + error_text
)
1894 return error_value
, error_text
1896 def get_hosts_info(self
):
1897 '''Get the information of deployed hosts
1898 Returns the hosts content'''
1900 print("osconnector: Getting Host info from VIM")
1903 self
._reload
_connection
()
1904 hypervisors
= self
.nova
.hypervisors
.list()
1905 for hype
in hypervisors
:
1906 h_list
.append( hype
.to_dict() )
1907 return 1, {"hosts":h_list
}
1908 except nvExceptions
.NotFound
as e
:
1909 error_value
=-vimconn
.HTTP_Not_Found
1910 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1911 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1912 error_value
=-vimconn
.HTTP_Bad_Request
1913 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1914 #TODO insert exception vimconn.HTTP_Unauthorized
1915 #if reaching here is because an exception
1916 self
.logger
.debug("get_hosts_info " + error_text
)
1917 return error_value
, error_text
1919 def get_hosts(self
, vim_tenant
):
1920 '''Get the hosts and deployed instances
1921 Returns the hosts content'''
1922 r
, hype_dict
= self
.get_hosts_info()
1925 hypervisors
= hype_dict
["hosts"]
1927 servers
= self
.nova
.servers
.list()
1928 for hype
in hypervisors
:
1929 for server
in servers
:
1930 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1932 hype
['vm'].append(server
.id)
1934 hype
['vm'] = [server
.id]
1936 except nvExceptions
.NotFound
as e
:
1937 error_value
=-vimconn
.HTTP_Not_Found
1938 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1939 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1940 error_value
=-vimconn
.HTTP_Bad_Request
1941 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1942 #TODO insert exception vimconn.HTTP_Unauthorized
1943 #if reaching here is because an exception
1944 self
.logger
.debug("get_hosts " + error_text
)
1945 return error_value
, error_text
1947 def new_classification(self
, name
, ctype
, definition
):
1949 'Adding a new (Traffic) Classification to VIM, named %s', name
)
1952 self
._reload
_connection
()
1953 if ctype
not in supportedClassificationTypes
:
1954 raise vimconn
.vimconnNotSupportedException(
1955 'OpenStack VIM connector doesn\'t support provided '
1956 'Classification Type {}, supported ones are: '
1957 '{}'.format(ctype
, supportedClassificationTypes
))
1958 if not self
._validate
_classification
(ctype
, definition
):
1959 raise vimconn
.vimconnException(
1960 'Incorrect Classification definition '
1961 'for the type specified.')
1962 classification_dict
= definition
1963 classification_dict
['name'] = name
1965 new_class
= self
.neutron
.create_sfc_flow_classifier(
1966 {'flow_classifier': classification_dict
})
1967 return new_class
['flow_classifier']['id']
1968 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1969 neExceptions
.NeutronException
, ConnectionError
) as e
:
1971 'Creation of Classification failed.')
1972 self
._format
_exception
(e
)
1974 def get_classification(self
, class_id
):
1975 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
1976 filter_dict
= {"id": class_id
}
1977 class_list
= self
.get_classification_list(filter_dict
)
1978 if len(class_list
) == 0:
1979 raise vimconn
.vimconnNotFoundException(
1980 "Classification '{}' not found".format(class_id
))
1981 elif len(class_list
) > 1:
1982 raise vimconn
.vimconnConflictException(
1983 "Found more than one Classification with this criteria")
1984 classification
= class_list
[0]
1985 return classification
1987 def get_classification_list(self
, filter_dict
={}):
1988 self
.logger
.debug("Getting Classifications from VIM filter: '%s'",
1991 filter_dict_os
= filter_dict
.copy()
1992 self
._reload
_connection
()
1993 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1994 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1995 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
1997 classification_list
= classification_dict
["flow_classifiers"]
1998 self
.__classification
_os
2mano
(classification_list
)
1999 return classification_list
2000 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2001 neExceptions
.NeutronException
, ConnectionError
) as e
:
2002 self
._format
_exception
(e
)
2004 def delete_classification(self
, class_id
):
2005 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
2007 self
._reload
_connection
()
2008 self
.neutron
.delete_sfc_flow_classifier(class_id
)
2010 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2011 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2012 ConnectionError
) as e
:
2013 self
._format
_exception
(e
)
2015 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
2017 "Adding a new Service Function Instance to VIM, named '%s'", name
)
2020 self
._reload
_connection
()
2024 if len(ingress_ports
) != 1:
2025 raise vimconn
.vimconnNotSupportedException(
2026 "OpenStack VIM connector can only have "
2027 "1 ingress port per SFI")
2028 if len(egress_ports
) != 1:
2029 raise vimconn
.vimconnNotSupportedException(
2030 "OpenStack VIM connector can only have "
2031 "1 egress port per SFI")
2032 sfi_dict
= {'name': name
,
2033 'ingress': ingress_ports
[0],
2034 'egress': egress_ports
[0],
2035 'service_function_parameters': {
2036 'correlation': correlation
}}
2037 new_sfi
= self
.neutron
.create_sfc_port_pair({'port_pair': sfi_dict
})
2038 return new_sfi
['port_pair']['id']
2039 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2040 neExceptions
.NeutronException
, ConnectionError
) as e
:
2043 self
.neutron
.delete_sfc_port_pair(
2044 new_sfi
['port_pair']['id'])
2047 'Creation of Service Function Instance failed, with '
2048 'subsequent deletion failure as well.')
2049 self
._format
_exception
(e
)
2051 def get_sfi(self
, sfi_id
):
2053 'Getting Service Function Instance %s from VIM', sfi_id
)
2054 filter_dict
= {"id": sfi_id
}
2055 sfi_list
= self
.get_sfi_list(filter_dict
)
2056 if len(sfi_list
) == 0:
2057 raise vimconn
.vimconnNotFoundException(
2058 "Service Function Instance '{}' not found".format(sfi_id
))
2059 elif len(sfi_list
) > 1:
2060 raise vimconn
.vimconnConflictException(
2061 'Found more than one Service Function Instance '
2062 'with this criteria')
2066 def get_sfi_list(self
, filter_dict
={}):
2067 self
.logger
.debug("Getting Service Function Instances from "
2068 "VIM filter: '%s'", str(filter_dict
))
2070 self
._reload
_connection
()
2071 filter_dict_os
= filter_dict
.copy()
2072 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2073 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2074 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
2075 sfi_list
= sfi_dict
["port_pairs"]
2076 self
.__sfi
_os
2mano
(sfi_list
)
2078 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2079 neExceptions
.NeutronException
, ConnectionError
) as e
:
2080 self
._format
_exception
(e
)
2082 def delete_sfi(self
, sfi_id
):
2083 self
.logger
.debug("Deleting Service Function Instance '%s' "
2086 self
._reload
_connection
()
2087 self
.neutron
.delete_sfc_port_pair(sfi_id
)
2089 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2090 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2091 ConnectionError
) as e
:
2092 self
._format
_exception
(e
)
2094 def new_sf(self
, name
, sfis
, sfc_encap
=True):
2095 self
.logger
.debug("Adding a new Service Function to VIM, "
2099 self
._reload
_connection
()
2100 # correlation = None
2102 # correlation = 'nsh'
2103 for instance
in sfis
:
2104 sfi
= self
.get_sfi(instance
)
2105 if sfi
.get('sfc_encap') != sfc_encap
:
2106 raise vimconn
.vimconnNotSupportedException(
2107 "OpenStack VIM connector requires all SFIs of the "
2108 "same SF to share the same SFC Encapsulation")
2109 sf_dict
= {'name': name
,
2111 new_sf
= self
.neutron
.create_sfc_port_pair_group({
2112 'port_pair_group': sf_dict
})
2113 return new_sf
['port_pair_group']['id']
2114 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2115 neExceptions
.NeutronException
, ConnectionError
) as e
:
2118 self
.neutron
.delete_sfc_port_pair_group(
2119 new_sf
['port_pair_group']['id'])
2122 'Creation of Service Function failed, with '
2123 'subsequent deletion failure as well.')
2124 self
._format
_exception
(e
)
2126 def get_sf(self
, sf_id
):
2127 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
2128 filter_dict
= {"id": sf_id
}
2129 sf_list
= self
.get_sf_list(filter_dict
)
2130 if len(sf_list
) == 0:
2131 raise vimconn
.vimconnNotFoundException(
2132 "Service Function '{}' not found".format(sf_id
))
2133 elif len(sf_list
) > 1:
2134 raise vimconn
.vimconnConflictException(
2135 "Found more than one Service Function with this criteria")
2139 def get_sf_list(self
, filter_dict
={}):
2140 self
.logger
.debug("Getting Service Function from VIM filter: '%s'",
2143 self
._reload
_connection
()
2144 filter_dict_os
= filter_dict
.copy()
2145 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2146 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2147 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
2148 sf_list
= sf_dict
["port_pair_groups"]
2149 self
.__sf
_os
2mano
(sf_list
)
2151 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2152 neExceptions
.NeutronException
, ConnectionError
) as e
:
2153 self
._format
_exception
(e
)
2155 def delete_sf(self
, sf_id
):
2156 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
2158 self
._reload
_connection
()
2159 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
2161 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2162 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2163 ConnectionError
) as e
:
2164 self
._format
_exception
(e
)
2166 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
2167 self
.logger
.debug("Adding a new Service Function Path to VIM, "
2171 self
._reload
_connection
()
2172 # In networking-sfc the MPLS encapsulation is legacy
2173 # should be used when no full SFC Encapsulation is intended
2174 correlation
= 'mpls'
2177 sfp_dict
= {'name': name
,
2178 'flow_classifiers': classifications
,
2179 'port_pair_groups': sfs
,
2180 'chain_parameters': {'correlation': correlation
}}
2182 sfp_dict
['chain_id'] = spi
2183 new_sfp
= self
.neutron
.create_sfc_port_chain({'port_chain': sfp_dict
})
2184 return new_sfp
["port_chain"]["id"]
2185 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2186 neExceptions
.NeutronException
, ConnectionError
) as e
:
2189 self
.neutron
.delete_sfc_port_chain(new_sfp
['port_chain']['id'])
2192 'Creation of Service Function Path failed, with '
2193 'subsequent deletion failure as well.')
2194 self
._format
_exception
(e
)
2196 def get_sfp(self
, sfp_id
):
2197 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
2198 filter_dict
= {"id": sfp_id
}
2199 sfp_list
= self
.get_sfp_list(filter_dict
)
2200 if len(sfp_list
) == 0:
2201 raise vimconn
.vimconnNotFoundException(
2202 "Service Function Path '{}' not found".format(sfp_id
))
2203 elif len(sfp_list
) > 1:
2204 raise vimconn
.vimconnConflictException(
2205 "Found more than one Service Function Path with this criteria")
2209 def get_sfp_list(self
, filter_dict
={}):
2210 self
.logger
.debug("Getting Service Function Paths from VIM filter: "
2211 "'%s'", str(filter_dict
))
2213 self
._reload
_connection
()
2214 filter_dict_os
= filter_dict
.copy()
2215 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2216 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2217 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
2218 sfp_list
= sfp_dict
["port_chains"]
2219 self
.__sfp
_os
2mano
(sfp_list
)
2221 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2222 neExceptions
.NeutronException
, ConnectionError
) as e
:
2223 self
._format
_exception
(e
)
2225 def delete_sfp(self
, sfp_id
):
2227 "Deleting Service Function Path '%s' from VIM", sfp_id
)
2229 self
._reload
_connection
()
2230 self
.neutron
.delete_sfc_port_chain(sfp_id
)
2232 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2233 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2234 ConnectionError
) as e
:
2235 self
._format
_exception
(e
)