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 check_vim_connectivity(self
):
452 # just get network list to check connectivity and credentials
453 self
.get_network_list(filter_dict
={})
455 def get_tenant_list(self
, filter_dict
={}):
456 '''Obtain tenants of VIM
457 filter_dict can contain the following keys:
458 name: filter by tenant name
459 id: filter by tenant uuid/id
461 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
463 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
465 self
._reload
_connection
()
466 if self
.api_version3
:
467 project_class_list
= self
.keystone
.projects
.list(name
=filter_dict
.get("name"))
469 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
471 for project
in project_class_list
:
472 if filter_dict
.get('id') and filter_dict
["id"] != project
.id:
474 project_list
.append(project
.to_dict())
476 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
477 self
._format
_exception
(e
)
479 def new_tenant(self
, tenant_name
, tenant_description
):
480 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
481 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
483 self
._reload
_connection
()
484 if self
.api_version3
:
485 project
= self
.keystone
.projects
.create(tenant_name
, self
.config
.get("project_domain_id", "default"),
486 description
=tenant_description
, is_domain
=False)
488 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
490 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ksExceptions
.BadRequest
, ConnectionError
) as e
:
491 self
._format
_exception
(e
)
493 def delete_tenant(self
, tenant_id
):
494 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
495 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
497 self
._reload
_connection
()
498 if self
.api_version3
:
499 self
.keystone
.projects
.delete(tenant_id
)
501 self
.keystone
.tenants
.delete(tenant_id
)
503 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ksExceptions
.NotFound
, ConnectionError
) as e
:
504 self
._format
_exception
(e
)
506 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, provider_network_profile
=None):
507 """Adds a tenant network to VIM
509 'net_name': name of the network
511 'bridge': overlay isolated network
512 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
513 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
514 'ip_profile': is a dict containing the IP parameters of the network
515 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
516 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
517 'gateway_address': (Optional) ip_schema, that is X.X.X.X
518 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
519 'dhcp_enabled': True or False
520 'dhcp_start_address': ip_schema, first IP to grant
521 'dhcp_count': number of IPs to grant.
522 'shared': if this network can be seen/use by other tenants/organization
523 'provider_network_profile': (optional) contains {segmentation-id: vlan, provider-network: vim_netowrk}
524 Returns a tuple with the network identifier and created_items, or raises an exception on error
525 created_items can be None or a dictionary where this method can include key-values that will be passed to
526 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
527 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
530 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
531 # self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
535 if provider_network_profile
:
536 vlan
= provider_network_profile
.get("segmentation-id")
539 self
._reload
_connection
()
540 network_dict
= {'name': net_name
, 'admin_state_up': True}
541 if net_type
=="data" or net_type
=="ptp":
542 if self
.config
.get('dataplane_physical_net') == None:
543 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
544 if not self
.config
.get('multisegment_support'):
545 network_dict
["provider:physical_network"] = self
.config
[
546 'dataplane_physical_net'] # "physnet_sriov" #TODO physical
547 network_dict
["provider:network_type"] = "vlan"
549 network_dict
["provider:network_type"] = vlan
551 ###### Multi-segment case ######
554 segment1_dict
["provider:physical_network"] = ''
555 segment1_dict
["provider:network_type"] = 'vxlan'
556 segment_list
.append(segment1_dict
)
558 segment2_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net']
559 segment2_dict
["provider:network_type"] = "vlan"
560 if self
.config
.get('multisegment_vlan_range'):
561 vlanID
= self
._generate
_multisegment
_vlanID
()
562 segment2_dict
["provider:segmentation_id"] = vlanID
564 # raise vimconn.vimconnConflictException(
565 # "You must provide 'multisegment_vlan_range' at config dict before creating a multisegment network")
566 segment_list
.append(segment2_dict
)
567 network_dict
["segments"] = segment_list
569 ####### VIO Specific Changes #########
570 if self
.vim_type
== "VIO":
572 network_dict
["provider:segmentation_id"] = vlan
574 if self
.config
.get('dataplane_net_vlan_range') is None:
575 raise vimconn
.vimconnConflictException("You must provide "\
576 "'dataplane_net_vlan_range' in format [start_ID - end_ID]"\
577 "at config value before creating sriov network with vlan tag")
579 network_dict
["provider:segmentation_id"] = self
._generate
_vlanID
()
581 network_dict
["shared"] = shared
582 if self
.config
.get("disable_network_port_security"):
583 network_dict
["port_security_enabled"] = False
584 new_net
= self
.neutron
.create_network({'network':network_dict
})
586 # create subnetwork, even if there is no profile
589 if not ip_profile
.get('subnet_address'):
590 #Fake subnet is required
591 subnet_rand
= random
.randint(0, 255)
592 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
593 if 'ip_version' not in ip_profile
:
594 ip_profile
['ip_version'] = "IPv4"
595 subnet
= {"name": net_name
+"-subnet",
596 "network_id": new_net
["network"]["id"],
597 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
598 "cidr": ip_profile
['subnet_address']
600 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
601 if ip_profile
.get('gateway_address'):
602 subnet
['gateway_ip'] = ip_profile
['gateway_address']
604 subnet
['gateway_ip'] = None
605 if ip_profile
.get('dns_address'):
606 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
607 if 'dhcp_enabled' in ip_profile
:
608 subnet
['enable_dhcp'] = False if \
609 ip_profile
['dhcp_enabled']=="false" or ip_profile
['dhcp_enabled']==False else True
610 if ip_profile
.get('dhcp_start_address'):
611 subnet
['allocation_pools'] = []
612 subnet
['allocation_pools'].append(dict())
613 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
614 if ip_profile
.get('dhcp_count'):
615 #parts = ip_profile['dhcp_start_address'].split('.')
616 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
617 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
618 ip_int
+= ip_profile
['dhcp_count'] - 1
619 ip_str
= str(netaddr
.IPAddress(ip_int
))
620 subnet
['allocation_pools'][0]['end'] = ip_str
621 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
622 self
.neutron
.create_subnet({"subnet": subnet
} )
624 if net_type
== "data" and self
.config
.get('multisegment_support'):
625 if self
.config
.get('l2gw_support'):
626 l2gw_list
= self
.neutron
.list_l2_gateways().get("l2_gateways", ())
627 for l2gw
in l2gw_list
:
629 l2gw_conn
["l2_gateway_id"] = l2gw
["id"]
630 l2gw_conn
["network_id"] = new_net
["network"]["id"]
631 l2gw_conn
["segmentation_id"] = str(vlanID
)
632 new_l2gw_conn
= self
.neutron
.create_l2_gateway_connection({"l2_gateway_connection": l2gw_conn
})
633 created_items
["l2gwconn:" + str(new_l2gw_conn
["l2_gateway_connection"]["id"])] = True
634 return new_net
["network"]["id"], created_items
635 except Exception as e
:
636 #delete l2gw connections (if any) before deleting the network
637 for k
, v
in created_items
.items():
638 if not v
: # skip already deleted
641 k_item
, _
, k_id
= k
.partition(":")
642 if k_item
== "l2gwconn":
643 self
.neutron
.delete_l2_gateway_connection(k_id
)
644 except Exception as e2
:
645 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e2
).__name
__, e2
))
647 self
.neutron
.delete_network(new_net
['network']['id'])
648 self
._format
_exception
(e
)
650 def get_network_list(self
, filter_dict
={}):
651 '''Obtain tenant networks of VIM
657 admin_state_up: boolean
659 Returns the network list of dictionaries
661 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
663 self
._reload
_connection
()
664 filter_dict_os
= filter_dict
.copy()
665 if self
.api_version3
and "tenant_id" in filter_dict_os
:
666 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id') #T ODO check
667 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
668 net_list
= net_dict
["networks"]
669 self
.__net
_os
2mano
(net_list
)
671 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
672 self
._format
_exception
(e
)
674 def get_network(self
, net_id
):
675 '''Obtain details of network from VIM
676 Returns the network information from a network id'''
677 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
678 filter_dict
={"id": net_id
}
679 net_list
= self
.get_network_list(filter_dict
)
681 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
682 elif len(net_list
)>1:
683 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
686 for subnet_id
in net
.get("subnets", () ):
688 subnet
= self
.neutron
.show_subnet(subnet_id
)
689 except Exception as e
:
690 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
691 subnet
= {"id": subnet_id
, "fault": str(e
)}
692 subnets
.append(subnet
)
693 net
["subnets"] = subnets
694 net
["encapsulation"] = net
.get('provider:network_type')
695 net
["encapsulation_type"] = net
.get('provider:network_type')
696 net
["segmentation_id"] = net
.get('provider:segmentation_id')
697 net
["encapsulation_id"] = net
.get('provider:segmentation_id')
700 def delete_network(self
, net_id
, created_items
=None):
702 Removes a tenant network from VIM and its associated elements
703 :param net_id: VIM identifier of the network, provided by method new_network
704 :param created_items: dictionary with extra items to be deleted. provided by method new_network
705 Returns the network identifier or raises an exception upon error or when network is not found
707 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
708 if created_items
== None:
711 self
._reload
_connection
()
712 #delete l2gw connections (if any) before deleting the network
713 for k
, v
in created_items
.items():
714 if not v
: # skip already deleted
717 k_item
, _
, k_id
= k
.partition(":")
718 if k_item
== "l2gwconn":
719 self
.neutron
.delete_l2_gateway_connection(k_id
)
720 except Exception as e
:
721 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e
).__name
__, e
))
722 #delete VM ports attached to this networks before the network
723 ports
= self
.neutron
.list_ports(network_id
=net_id
)
724 for p
in ports
['ports']:
726 self
.neutron
.delete_port(p
["id"])
727 except Exception as e
:
728 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
729 self
.neutron
.delete_network(net_id
)
731 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
732 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
733 self
._format
_exception
(e
)
735 def refresh_nets_status(self
, net_list
):
736 '''Get the status of the networks
737 Params: the list of network identifiers
738 Returns a dictionary with:
739 net_id: #VIM id of this network
740 status: #Mandatory. Text with one of:
741 # DELETED (not found at vim)
742 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
743 # OTHER (Vim reported other status not understood)
744 # ERROR (VIM indicates an ERROR status)
745 # ACTIVE, INACTIVE, DOWN (admin down),
746 # BUILD (on building process)
748 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
749 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
753 for net_id
in net_list
:
756 net_vim
= self
.get_network(net_id
)
757 if net_vim
['status'] in netStatus2manoFormat
:
758 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
760 net
["status"] = "OTHER"
761 net
["error_msg"] = "VIM status reported " + net_vim
['status']
763 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
764 net
['status'] = 'DOWN'
766 net
['vim_info'] = self
.serialize(net_vim
)
768 if net_vim
.get('fault'): #TODO
769 net
['error_msg'] = str(net_vim
['fault'])
770 except vimconn
.vimconnNotFoundException
as e
:
771 self
.logger
.error("Exception getting net status: %s", str(e
))
772 net
['status'] = "DELETED"
773 net
['error_msg'] = str(e
)
774 except vimconn
.vimconnException
as e
:
775 self
.logger
.error("Exception getting net status: %s", str(e
))
776 net
['status'] = "VIM_ERROR"
777 net
['error_msg'] = str(e
)
778 net_dict
[net_id
] = net
781 def get_flavor(self
, flavor_id
):
782 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
783 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
785 self
._reload
_connection
()
786 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
787 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
788 return flavor
.to_dict()
789 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
790 self
._format
_exception
(e
)
792 def get_flavor_id_from_data(self
, flavor_dict
):
793 """Obtain flavor id that match the flavor description
794 Returns the flavor_id or raises a vimconnNotFoundException
795 flavor_dict: contains the required ram, vcpus, disk
796 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
797 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
798 vimconnNotFoundException is raised
800 exact_match
= False if self
.config
.get('use_existing_flavors') else True
802 self
._reload
_connection
()
803 flavor_candidate_id
= None
804 flavor_candidate_data
= (10000, 10000, 10000)
805 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
807 extended
= flavor_dict
.get("extended", {})
810 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemented")
812 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
814 # numas = extended.get("numas")
815 for flavor
in self
.nova
.flavors
.list():
816 epa
= flavor
.get_keys()
820 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
821 if flavor_data
== flavor_target
:
823 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
824 flavor_candidate_id
= flavor
.id
825 flavor_candidate_data
= flavor_data
826 if not exact_match
and flavor_candidate_id
:
827 return flavor_candidate_id
828 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
829 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
830 self
._format
_exception
(e
)
832 def process_resource_quota(self
, quota
, prefix
, extra_specs
):
839 extra_specs
["quota:" + prefix
+ "_limit"] = quota
['limit']
840 if 'reserve' in quota
:
841 extra_specs
["quota:" + prefix
+ "_reservation"] = quota
['reserve']
842 if 'shares' in quota
:
843 extra_specs
["quota:" + prefix
+ "_shares_level"] = "custom"
844 extra_specs
["quota:" + prefix
+ "_shares_share"] = quota
['shares']
846 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
847 '''Adds a tenant flavor to openstack VIM
848 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
849 Returns the flavor identifier
851 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
856 name
=flavor_data
['name']
857 while retry
<max_retries
:
860 self
._reload
_connection
()
861 if change_name_if_used
:
864 fl
=self
.nova
.flavors
.list()
866 fl_names
.append(f
.name
)
867 while name
in fl_names
:
869 name
= flavor_data
['name']+"-" + str(name_suffix
)
871 ram
= flavor_data
.get('ram',64)
872 vcpus
= flavor_data
.get('vcpus',1)
875 extended
= flavor_data
.get("extended")
877 numas
=extended
.get("numas")
879 numa_nodes
= len(numas
)
881 return -1, "Can not add flavor with more than one numa"
882 extra_specs
["hw:numa_nodes"] = str(numa_nodes
)
883 extra_specs
["hw:mem_page_size"] = "large"
884 extra_specs
["hw:cpu_policy"] = "dedicated"
885 extra_specs
["hw:numa_mempolicy"] = "strict"
886 if self
.vim_type
== "VIO":
887 extra_specs
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
888 extra_specs
["vmware:latency_sensitivity_level"] = "high"
890 #overwrite ram and vcpus
891 #check if key 'memory' is present in numa else use ram value at flavor
893 ram
= numa
['memory']*1024
894 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
895 extra_specs
["hw:cpu_sockets"] = 1
896 if 'paired-threads' in numa
:
897 vcpus
= numa
['paired-threads']*2
898 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
899 extra_specs
["hw:cpu_thread_policy"] = "require"
900 extra_specs
["hw:cpu_policy"] = "dedicated"
901 elif 'cores' in numa
:
902 vcpus
= numa
['cores']
903 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
904 extra_specs
["hw:cpu_thread_policy"] = "isolate"
905 extra_specs
["hw:cpu_policy"] = "dedicated"
906 elif 'threads' in numa
:
907 vcpus
= numa
['threads']
908 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
909 extra_specs
["hw:cpu_thread_policy"] = "prefer"
910 extra_specs
["hw:cpu_policy"] = "dedicated"
911 # for interface in numa.get("interfaces",() ):
912 # if interface["dedicated"]=="yes":
913 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
914 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
915 elif extended
.get("cpu-quota"):
916 self
.process_resource_quota(extended
.get("cpu-quota"), "cpu", extra_specs
)
917 if extended
.get("mem-quota"):
918 self
.process_resource_quota(extended
.get("mem-quota"), "memory", extra_specs
)
919 if extended
.get("vif-quota"):
920 self
.process_resource_quota(extended
.get("vif-quota"), "vif", extra_specs
)
921 if extended
.get("disk-io-quota"):
922 self
.process_resource_quota(extended
.get("disk-io-quota"), "disk_io", extra_specs
)
924 new_flavor
=self
.nova
.flavors
.create(name
,
927 flavor_data
.get('disk',0),
928 is_public
=flavor_data
.get('is_public', True)
932 new_flavor
.set_keys(extra_specs
)
934 except nvExceptions
.Conflict
as e
:
935 if change_name_if_used
and retry
< max_retries
:
937 self
._format
_exception
(e
)
938 #except nvExceptions.BadRequest as e:
939 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
, KeyError) as e
:
940 self
._format
_exception
(e
)
942 def delete_flavor(self
,flavor_id
):
943 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
946 self
._reload
_connection
()
947 self
.nova
.flavors
.delete(flavor_id
)
949 #except nvExceptions.BadRequest as e:
950 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
951 self
._format
_exception
(e
)
953 def new_image(self
,image_dict
):
955 Adds a tenant image to VIM. imge_dict is a dictionary with:
957 disk_format: qcow2, vhd, vmdk, raw (by default), ...
958 location: path or URI
959 public: "yes" or "no"
960 metadata: metadata of the image
965 while retry
<max_retries
:
968 self
._reload
_connection
()
969 #determine format http://docs.openstack.org/developer/glance/formats.html
970 if "disk_format" in image_dict
:
971 disk_format
=image_dict
["disk_format"]
972 else: #autodiscover based on extension
973 if image_dict
['location'].endswith(".qcow2"):
975 elif image_dict
['location'].endswith(".vhd"):
977 elif image_dict
['location'].endswith(".vmdk"):
979 elif image_dict
['location'].endswith(".vdi"):
981 elif image_dict
['location'].endswith(".iso"):
983 elif image_dict
['location'].endswith(".aki"):
985 elif image_dict
['location'].endswith(".ari"):
987 elif image_dict
['location'].endswith(".ami"):
991 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
992 if self
.vim_type
== "VIO":
993 container_format
= "bare"
994 if 'container_format' in image_dict
:
995 container_format
= image_dict
['container_format']
996 new_image
= self
.glance
.images
.create(name
=image_dict
['name'], container_format
=container_format
,
997 disk_format
=disk_format
)
999 new_image
= self
.glance
.images
.create(name
=image_dict
['name'])
1000 if image_dict
['location'].startswith("http"):
1001 # TODO there is not a method to direct download. It must be downloaded locally with requests
1002 raise vimconn
.vimconnNotImplemented("Cannot create image from URL")
1004 with
open(image_dict
['location']) as fimage
:
1005 self
.glance
.images
.upload(new_image
.id, fimage
)
1006 #new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
1007 # container_format="bare", data=fimage, disk_format=disk_format)
1008 metadata_to_load
= image_dict
.get('metadata')
1009 # TODO location is a reserved word for current openstack versions. fixed for VIO please check for openstack
1010 if self
.vim_type
== "VIO":
1011 metadata_to_load
['upload_location'] = image_dict
['location']
1013 metadata_to_load
['location'] = image_dict
['location']
1014 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1016 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1017 self
._format
_exception
(e
)
1018 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1019 if retry
==max_retries
:
1021 self
._format
_exception
(e
)
1022 except IOError as e
: #can not open the file
1023 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
1024 http_code
=vimconn
.HTTP_Bad_Request
)
1026 def delete_image(self
, image_id
):
1027 '''Deletes a tenant image from openstack VIM. Returns the old id
1030 self
._reload
_connection
()
1031 self
.glance
.images
.delete(image_id
)
1033 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, gl1Exceptions
.HTTPNotFound
, ConnectionError
) as e
: #TODO remove
1034 self
._format
_exception
(e
)
1036 def get_image_id_from_path(self
, path
):
1037 '''Get the image id from image path in the VIM database. Returns the image_id'''
1039 self
._reload
_connection
()
1040 images
= self
.glance
.images
.list()
1041 for image
in images
:
1042 if image
.metadata
.get("location")==path
:
1044 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
1045 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1046 self
._format
_exception
(e
)
1048 def get_image_list(self
, filter_dict
={}):
1049 '''Obtain tenant images from VIM
1053 checksum: image checksum
1054 Returns the image list of dictionaries:
1055 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1058 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1060 self
._reload
_connection
()
1061 filter_dict_os
= filter_dict
.copy()
1062 #First we filter by the available filter fields: name, id. The others are removed.
1063 image_list
= self
.glance
.images
.list()
1065 for image
in image_list
:
1067 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1069 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1071 if filter_dict
.get("checksum") and image
["checksum"] != filter_dict
["checksum"]:
1074 filtered_list
.append(image
.copy())
1075 except gl1Exceptions
.HTTPNotFound
:
1077 return filtered_list
1078 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1079 self
._format
_exception
(e
)
1081 def __wait_for_vm(self
, vm_id
, status
):
1082 """wait until vm is in the desired status and return True.
1083 If the VM gets in ERROR status, return false.
1084 If the timeout is reached generate an exception"""
1086 while elapsed_time
< server_timeout
:
1087 vm_status
= self
.nova
.servers
.get(vm_id
).status
1088 if vm_status
== status
:
1090 if vm_status
== 'ERROR':
1095 # if we exceeded the timeout rollback
1096 if elapsed_time
>= server_timeout
:
1097 raise vimconn
.vimconnException('Timeout waiting for instance ' + vm_id
+ ' to get ' + status
,
1098 http_code
=vimconn
.HTTP_Request_Timeout
)
1100 def _get_openstack_availablity_zones(self
):
1102 Get from openstack availability zones available
1106 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1107 openstack_availability_zone
= [str(zone
.zoneName
) for zone
in openstack_availability_zone
1108 if zone
.zoneName
!= 'internal']
1109 return openstack_availability_zone
1110 except Exception as e
:
1113 def _set_availablity_zones(self
):
1115 Set vim availablity zone
1119 if 'availability_zone' in self
.config
:
1120 vim_availability_zones
= self
.config
.get('availability_zone')
1121 if isinstance(vim_availability_zones
, str):
1122 self
.availability_zone
= [vim_availability_zones
]
1123 elif isinstance(vim_availability_zones
, list):
1124 self
.availability_zone
= vim_availability_zones
1126 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1128 def _get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
1130 Return thge availability zone to be used by the created VM.
1131 :return: The VIM availability zone to be used or None
1133 if availability_zone_index
is None:
1134 if not self
.config
.get('availability_zone'):
1136 elif isinstance(self
.config
.get('availability_zone'), str):
1137 return self
.config
['availability_zone']
1139 # TODO consider using a different parameter at config for default AV and AV list match
1140 return self
.config
['availability_zone'][0]
1142 vim_availability_zones
= self
.availability_zone
1143 # check if VIM offer enough availability zones describe in the VNFD
1144 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
1145 # check if all the names of NFV AV match VIM AV names
1146 match_by_index
= False
1147 for av
in availability_zone_list
:
1148 if av
not in vim_availability_zones
:
1149 match_by_index
= True
1152 return vim_availability_zones
[availability_zone_index
]
1154 return availability_zone_list
[availability_zone_index
]
1156 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
1158 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
1159 availability_zone_index
=None, availability_zone_list
=None):
1160 """Adds a VM instance to VIM
1162 start: indicates if VM must start or boot in pause mode. Ignored
1163 image_id,flavor_id: iamge and flavor uuid
1164 net_list: list of interfaces, each one is a dictionary with:
1166 net_id: network uuid to connect
1167 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
1168 model: interface model, ignored #TODO
1169 mac_address: used for SR-IOV ifaces #TODO for other types
1170 use: 'data', 'bridge', 'mgmt'
1171 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
1172 vim_id: filled/added by this function
1173 floating_ip: True/False (or it can be None)
1174 'cloud_config': (optional) dictionary with:
1175 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1176 'users': (optional) list of users to be inserted, each item is a dict with:
1177 'name': (mandatory) user name,
1178 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1179 'user-data': (optional) string is a text script to be passed directly to cloud-init
1180 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1181 'dest': (mandatory) string with the destination absolute path
1182 'encoding': (optional, by default text). Can be one of:
1183 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1184 'content' (mandatory): string with the content of the file
1185 'permissions': (optional) string with file permissions, typically octal notation '0644'
1186 'owner': (optional) file owner, string with the format 'owner:group'
1187 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1188 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1189 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1190 'size': (mandatory) string with the size of the disk in GB
1191 'vim_id' (optional) should use this existing volume id
1192 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1193 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1194 availability_zone_index is None
1195 #TODO ip, security groups
1196 Returns a tuple with the instance identifier and created_items or raises an exception on error
1197 created_items can be None or a dictionary where this method can include key-values that will be passed to
1198 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1199 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1202 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
1208 external_network
= [] # list of external networks to be connected to instance, later on used to create floating_ip
1209 no_secured_ports
= [] # List of port-is with port-security disabled
1210 self
._reload
_connection
()
1211 # metadata_vpci = {} # For a specific neutron plugin
1212 block_device_mapping
= None
1214 for net
in net_list
:
1215 if not net
.get("net_id"): # skip non connected iface
1219 "network_id": net
["net_id"],
1220 "name": net
.get("name"),
1221 "admin_state_up": True
1223 if self
.config
.get("security_groups") and net
.get("port_security") is not False and \
1224 not self
.config
.get("no_port_security_extension"):
1225 if not self
.security_groups_id
:
1226 self
._get
_ids
_from
_name
()
1227 port_dict
["security_groups"] = self
.security_groups_id
1229 if net
["type"]=="virtual":
1232 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1233 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1235 # if "VF" not in metadata_vpci:
1236 # metadata_vpci["VF"]=[]
1237 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1238 port_dict
["binding:vnic_type"]="direct"
1239 # VIO specific Changes
1240 if self
.vim_type
== "VIO":
1241 # Need to create port with port_security_enabled = False and no-security-groups
1242 port_dict
["port_security_enabled"]=False
1243 port_dict
["provider_security_groups"]=[]
1244 port_dict
["security_groups"]=[]
1245 else: # For PT PCI-PASSTHROUGH
1246 # VIO specific Changes
1247 # Current VIO release does not support port with type 'direct-physical'
1248 # So no need to create virtual port in case of PCI-device.
1249 # Will update port_dict code when support gets added in next VIO release
1250 if self
.vim_type
== "VIO":
1251 raise vimconn
.vimconnNotSupportedException(
1252 "Current VIO release does not support full passthrough (PT)")
1254 # if "PF" not in metadata_vpci:
1255 # metadata_vpci["PF"]=[]
1256 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1257 port_dict
["binding:vnic_type"]="direct-physical"
1258 if not port_dict
["name"]:
1259 port_dict
["name"]=name
1260 if net
.get("mac_address"):
1261 port_dict
["mac_address"]=net
["mac_address"]
1262 if net
.get("ip_address"):
1263 port_dict
["fixed_ips"] = [{'ip_address': net
["ip_address"]}]
1264 # TODO add 'subnet_id': <subnet_id>
1265 new_port
= self
.neutron
.create_port({"port": port_dict
})
1266 created_items
["port:" + str(new_port
["port"]["id"])] = True
1267 net
["mac_adress"] = new_port
["port"]["mac_address"]
1268 net
["vim_id"] = new_port
["port"]["id"]
1269 # if try to use a network without subnetwork, it will return a emtpy list
1270 fixed_ips
= new_port
["port"].get("fixed_ips")
1272 net
["ip"] = fixed_ips
[0].get("ip_address")
1276 port
= {"port-id": new_port
["port"]["id"]}
1277 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1278 port
["tag"] = new_port
["port"]["name"]
1279 net_list_vim
.append(port
)
1281 if net
.get('floating_ip', False):
1282 net
['exit_on_floating_ip_error'] = True
1283 external_network
.append(net
)
1284 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
1285 net
['exit_on_floating_ip_error'] = False
1286 external_network
.append(net
)
1287 net
['floating_ip'] = self
.config
.get('use_floating_ip')
1289 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1290 # As a workaround we wait until the VM is active and then disable the port-security
1291 if net
.get("port_security") == False and not self
.config
.get("no_port_security_extension"):
1292 no_secured_ports
.append(new_port
["port"]["id"])
1295 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1296 # if len(metadata["pci_assignement"]) >255:
1297 # #limit the metadata size
1298 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1299 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1302 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1303 name
, image_id
, flavor_id
, str(net_list_vim
), description
)
1306 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1308 # Create additional volumes in case these are present in disk_list
1309 base_disk_index
= ord('b')
1311 block_device_mapping
= {}
1312 for disk
in disk_list
:
1313 if disk
.get('vim_id'):
1314 block_device_mapping
['_vd' + chr(base_disk_index
)] = disk
['vim_id']
1316 if 'image_id' in disk
:
1317 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1318 chr(base_disk_index
), imageRef
=disk
['image_id'])
1320 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1321 chr(base_disk_index
))
1322 created_items
["volume:" + str(volume
.id)] = True
1323 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
1324 base_disk_index
+= 1
1326 # Wait until created volumes are with status available
1328 while elapsed_time
< volume_timeout
:
1329 for created_item
in created_items
:
1330 v
, _
, volume_id
= created_item
.partition(":")
1332 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
1334 else: # all ready: break from while
1338 # If we exceeded the timeout rollback
1339 if elapsed_time
>= volume_timeout
:
1340 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
1341 http_code
=vimconn
.HTTP_Request_Timeout
)
1342 # get availability Zone
1343 vm_av_zone
= self
._get
_vm
_availability
_zone
(availability_zone_index
, availability_zone_list
)
1345 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1346 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1347 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
1348 self
.config
.get("security_groups"), vm_av_zone
,
1349 self
.config
.get('keypair'), userdata
, config_drive
,
1350 block_device_mapping
))
1351 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
,
1352 security_groups
=self
.config
.get("security_groups"),
1353 # TODO remove security_groups in future versions. Already at neutron port
1354 availability_zone
=vm_av_zone
,
1355 key_name
=self
.config
.get('keypair'),
1357 config_drive
=config_drive
,
1358 block_device_mapping
=block_device_mapping
1359 ) # , description=description)
1361 vm_start_time
= time
.time()
1362 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1363 if no_secured_ports
:
1364 self
.__wait
_for
_vm
(server
.id, 'ACTIVE')
1366 for port_id
in no_secured_ports
:
1368 self
.neutron
.update_port(port_id
,
1369 {"port": {"port_security_enabled": False, "security_groups": None}})
1370 except Exception as e
:
1371 raise vimconn
.vimconnException("It was not possible to disable port security for port {}".format(
1373 # print "DONE :-)", server
1376 if external_network
:
1377 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
1378 for floating_network
in external_network
:
1383 ip
= floating_ips
.pop(0)
1384 if ip
.get("port_id", False) or ip
.get('tenant_id') != server
.tenant_id
:
1386 if isinstance(floating_network
['floating_ip'], str):
1387 if ip
.get("floating_network_id") != floating_network
['floating_ip']:
1389 free_floating_ip
= ip
.get("floating_ip_address")
1391 if isinstance(floating_network
['floating_ip'], str) and \
1392 floating_network
['floating_ip'].lower() != "true":
1393 pool_id
= floating_network
['floating_ip']
1395 # Find the external network
1396 external_nets
= list()
1397 for net
in self
.neutron
.list_networks()['networks']:
1398 if net
['router:external']:
1399 external_nets
.append(net
)
1401 if len(external_nets
) == 0:
1402 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
1403 "network is present",
1404 http_code
=vimconn
.HTTP_Conflict
)
1405 if len(external_nets
) > 1:
1406 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
1407 "external networks are present",
1408 http_code
=vimconn
.HTTP_Conflict
)
1410 pool_id
= external_nets
[0].get('id')
1411 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
1413 # self.logger.debug("Creating floating IP")
1414 new_floating_ip
= self
.neutron
.create_floatingip(param
)
1415 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
1416 except Exception as e
:
1417 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create new floating_ip " +
1418 str(e
), http_code
=vimconn
.HTTP_Conflict
)
1420 fix_ip
= floating_network
.get('ip')
1423 server
.add_floating_ip(free_floating_ip
, fix_ip
)
1425 except Exception as e
:
1426 # openstack need some time after VM creation to asign an IP. So retry if fails
1427 vm_status
= self
.nova
.servers
.get(server
.id).status
1428 if vm_status
!= 'ACTIVE' and vm_status
!= 'ERROR':
1429 if time
.time() - vm_start_time
< server_timeout
:
1432 raise vimconn
.vimconnException(
1433 "Cannot create floating_ip: {} {}".format(type(e
).__name
__, e
),
1434 http_code
=vimconn
.HTTP_Conflict
)
1436 except Exception as e
:
1437 if not floating_network
['exit_on_floating_ip_error']:
1438 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
1442 return server
.id, created_items
1443 # except nvExceptions.NotFound as e:
1444 # error_value=-vimconn.HTTP_Not_Found
1445 # error_text= "vm instance %s not found" % vm_id
1446 # except TypeError as e:
1447 # raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
1449 except Exception as e
:
1452 server_id
= server
.id
1454 self
.delete_vminstance(server_id
, created_items
)
1455 except Exception as e2
:
1456 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
1458 self
._format
_exception
(e
)
1460 def get_vminstance(self
,vm_id
):
1461 '''Returns the VM instance information from VIM'''
1462 #self.logger.debug("Getting VM from VIM")
1464 self
._reload
_connection
()
1465 server
= self
.nova
.servers
.find(id=vm_id
)
1466 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1467 return server
.to_dict()
1468 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1469 self
._format
_exception
(e
)
1471 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1473 Get a console for the virtual machine
1475 vm_id: uuid of the VM
1476 console_type, can be:
1477 "novnc" (by default), "xvpvnc" for VNC types,
1478 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1479 Returns dict with the console parameters:
1480 protocol: ssh, ftp, http, https, ...
1481 server: usually ip address
1482 port: the http, ssh, ... port
1483 suffix: extra text, e.g. the http path and query string
1485 self
.logger
.debug("Getting VM CONSOLE from VIM")
1487 self
._reload
_connection
()
1488 server
= self
.nova
.servers
.find(id=vm_id
)
1489 if console_type
== None or console_type
== "novnc":
1490 console_dict
= server
.get_vnc_console("novnc")
1491 elif console_type
== "xvpvnc":
1492 console_dict
= server
.get_vnc_console(console_type
)
1493 elif console_type
== "rdp-html5":
1494 console_dict
= server
.get_rdp_console(console_type
)
1495 elif console_type
== "spice-html5":
1496 console_dict
= server
.get_spice_console(console_type
)
1498 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1500 console_dict1
= console_dict
.get("console")
1502 console_url
= console_dict1
.get("url")
1505 protocol_index
= console_url
.find("//")
1506 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1507 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1508 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1509 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1510 console_dict
={"protocol": console_url
[0:protocol_index
],
1511 "server": console_url
[protocol_index
+2:port_index
],
1512 "port": console_url
[port_index
:suffix_index
],
1513 "suffix": console_url
[suffix_index
+1:]
1517 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1519 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1520 self
._format
_exception
(e
)
1522 def delete_vminstance(self
, vm_id
, created_items
=None):
1523 '''Removes a VM instance from VIM. Returns the old identifier
1525 #print "osconnector: Getting VM from VIM"
1526 if created_items
== None:
1529 self
._reload
_connection
()
1530 # delete VM ports attached to this networks before the virtual machine
1531 for k
, v
in created_items
.items():
1532 if not v
: # skip already deleted
1535 k_item
, _
, k_id
= k
.partition(":")
1536 if k_item
== "port":
1537 self
.neutron
.delete_port(k_id
)
1538 except Exception as e
:
1539 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
1541 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1542 # #dettach volumes attached
1543 # server = self.nova.servers.get(vm_id)
1544 # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
1545 # #for volume in volumes_attached_dict:
1546 # # self.cinder.volumes.detach(volume['id'])
1549 self
.nova
.servers
.delete(vm_id
)
1551 # delete volumes. Although having detached, they should have in active status before deleting
1552 # we ensure in this loop
1555 while keep_waiting
and elapsed_time
< volume_timeout
:
1556 keep_waiting
= False
1557 for k
, v
in created_items
.items():
1558 if not v
: # skip already deleted
1561 k_item
, _
, k_id
= k
.partition(":")
1562 if k_item
== "volume":
1563 if self
.cinder
.volumes
.get(k_id
).status
!= 'available':
1566 self
.cinder
.volumes
.delete(k_id
)
1567 except Exception as e
:
1568 self
.logger
.error("Error deleting volume: {}: {}".format(type(e
).__name
__, e
))
1573 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1574 self
._format
_exception
(e
)
1576 def refresh_vms_status(self
, vm_list
):
1577 '''Get the status of the virtual machines and their interfaces/ports
1578 Params: the list of VM identifiers
1579 Returns a dictionary with:
1580 vm_id: #VIM id of this Virtual Machine
1581 status: #Mandatory. Text with one of:
1582 # DELETED (not found at vim)
1583 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1584 # OTHER (Vim reported other status not understood)
1585 # ERROR (VIM indicates an ERROR status)
1586 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1587 # CREATING (on building process), ERROR
1588 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1590 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1591 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1593 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1594 mac_address: #Text format XX:XX:XX:XX:XX:XX
1595 vim_net_id: #network id where this interface is connected
1596 vim_interface_id: #interface/port VIM id
1597 ip_address: #null, or text with IPv4, IPv6 address
1598 compute_node: #identification of compute node where PF,VF interface is allocated
1599 pci: #PCI address of the NIC that hosts the PF,VF
1600 vlan: #physical VLAN used for VF
1603 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1604 for vm_id
in vm_list
:
1607 vm_vim
= self
.get_vminstance(vm_id
)
1608 if vm_vim
['status'] in vmStatus2manoFormat
:
1609 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1611 vm
['status'] = "OTHER"
1612 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1614 vm
['vim_info'] = self
.serialize(vm_vim
)
1616 vm
["interfaces"] = []
1617 if vm_vim
.get('fault'):
1618 vm
['error_msg'] = str(vm_vim
['fault'])
1621 self
._reload
_connection
()
1622 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
1623 for port
in port_dict
["ports"]:
1625 interface
['vim_info'] = self
.serialize(port
)
1626 interface
["mac_address"] = port
.get("mac_address")
1627 interface
["vim_net_id"] = port
["network_id"]
1628 interface
["vim_interface_id"] = port
["id"]
1629 # check if OS-EXT-SRV-ATTR:host is there,
1630 # in case of non-admin credentials, it will be missing
1631 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1632 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1633 interface
["pci"] = None
1635 # check if binding:profile is there,
1636 # in case of non-admin credentials, it will be missing
1637 if port
.get('binding:profile'):
1638 if port
['binding:profile'].get('pci_slot'):
1639 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1640 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1641 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1642 pci
= port
['binding:profile']['pci_slot']
1643 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1644 interface
["pci"] = pci
1645 interface
["vlan"] = None
1646 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1647 network
= self
.neutron
.show_network(port
["network_id"])
1648 if network
['network'].get('provider:network_type') == 'vlan' and \
1649 port
.get("binding:vnic_type") == "direct":
1650 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1652 #look for floating ip address
1654 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1655 if floating_ip_dict
.get("floatingips"):
1656 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1660 for subnet
in port
["fixed_ips"]:
1661 ips
.append(subnet
["ip_address"])
1662 interface
["ip_address"] = ";".join(ips
)
1663 vm
["interfaces"].append(interface
)
1664 except Exception as e
:
1665 self
.logger
.error("Error getting vm interface information {}: {}".format(type(e
).__name
__, e
),
1667 except vimconn
.vimconnNotFoundException
as e
:
1668 self
.logger
.error("Exception getting vm status: %s", str(e
))
1669 vm
['status'] = "DELETED"
1670 vm
['error_msg'] = str(e
)
1671 except vimconn
.vimconnException
as e
:
1672 self
.logger
.error("Exception getting vm status: %s", str(e
))
1673 vm
['status'] = "VIM_ERROR"
1674 vm
['error_msg'] = str(e
)
1678 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1679 '''Send and action over a VM instance from VIM
1680 Returns None or the console dict if the action was successfully sent to the VIM'''
1681 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1683 self
._reload
_connection
()
1684 server
= self
.nova
.servers
.find(id=vm_id
)
1685 if "start" in action_dict
:
1686 if action_dict
["start"]=="rebuild":
1689 if server
.status
=="PAUSED":
1691 elif server
.status
=="SUSPENDED":
1693 elif server
.status
=="SHUTOFF":
1695 elif "pause" in action_dict
:
1697 elif "resume" in action_dict
:
1699 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1701 elif "forceOff" in action_dict
:
1703 elif "terminate" in action_dict
:
1705 elif "createImage" in action_dict
:
1706 server
.create_image()
1707 #"path":path_schema,
1708 #"description":description_schema,
1709 #"name":name_schema,
1710 #"metadata":metadata_schema,
1711 #"imageRef": id_schema,
1712 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1713 elif "rebuild" in action_dict
:
1714 server
.rebuild(server
.image
['id'])
1715 elif "reboot" in action_dict
:
1716 server
.reboot() #reboot_type='SOFT'
1717 elif "console" in action_dict
:
1718 console_type
= action_dict
["console"]
1719 if console_type
== None or console_type
== "novnc":
1720 console_dict
= server
.get_vnc_console("novnc")
1721 elif console_type
== "xvpvnc":
1722 console_dict
= server
.get_vnc_console(console_type
)
1723 elif console_type
== "rdp-html5":
1724 console_dict
= server
.get_rdp_console(console_type
)
1725 elif console_type
== "spice-html5":
1726 console_dict
= server
.get_spice_console(console_type
)
1728 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1729 http_code
=vimconn
.HTTP_Bad_Request
)
1731 console_url
= console_dict
["console"]["url"]
1733 protocol_index
= console_url
.find("//")
1734 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1735 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1736 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1737 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1738 console_dict2
={"protocol": console_url
[0:protocol_index
],
1739 "server": console_url
[protocol_index
+2 : port_index
],
1740 "port": int(console_url
[port_index
+1 : suffix_index
]),
1741 "suffix": console_url
[suffix_index
+1:]
1743 return console_dict2
1744 except Exception as e
:
1745 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1748 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1749 self
._format
_exception
(e
)
1750 #TODO insert exception vimconn.HTTP_Unauthorized
1752 ####### VIO Specific Changes #########
1753 def _generate_vlanID(self
):
1755 Method to get unused vlanID
1763 networks
= self
.get_network_list()
1764 for net
in networks
:
1765 if net
.get('provider:segmentation_id'):
1766 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1767 used_vlanIDs
= set(usedVlanIDs
)
1769 #find unused VLAN ID
1770 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1772 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1773 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1774 if vlanID
not in used_vlanIDs
:
1776 except Exception as exp
:
1777 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1779 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1780 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1783 def _generate_multisegment_vlanID(self
):
1785 Method to get unused vlanID
1793 networks
= self
.get_network_list()
1794 for net
in networks
:
1795 if net
.get('provider:network_type') == "vlan" and net
.get('provider:segmentation_id'):
1796 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1797 elif net
.get('segments'):
1798 for segment
in net
.get('segments'):
1799 if segment
.get('provider:network_type') == "vlan" and segment
.get('provider:segmentation_id'):
1800 usedVlanIDs
.append(segment
.get('provider:segmentation_id'))
1801 used_vlanIDs
= set(usedVlanIDs
)
1803 #find unused VLAN ID
1804 for vlanID_range
in self
.config
.get('multisegment_vlan_range'):
1806 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1807 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1808 if vlanID
not in used_vlanIDs
:
1810 except Exception as exp
:
1811 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1813 raise vimconn
.vimconnConflictException("Unable to create the VLAN segment."\
1814 " All VLAN IDs {} are in use.".format(self
.config
.get('multisegment_vlan_range')))
1817 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
1819 Method to validate user given vlanID ranges
1823 for vlanID_range
in input_vlan_range
:
1824 vlan_range
= vlanID_range
.replace(" ", "")
1826 vlanID_pattern
= r
'(\d)*-(\d)*$'
1827 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1829 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}.You must provide "\
1830 "'{}' in format [start_ID - end_ID].".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1832 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1833 if start_vlanid
<= 0 :
1834 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1835 "Start ID can not be zero. For VLAN "\
1836 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1837 if end_vlanid
> 4094 :
1838 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1839 "End VLAN ID can not be greater than 4094. For VLAN "\
1840 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1842 if start_vlanid
> end_vlanid
:
1843 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1844 "You must provide '{}' in format start_ID - end_ID and "\
1845 "start_ID < end_ID ".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1849 def new_external_port(self
, port_data
):
1850 #TODO openstack if needed
1851 '''Adds a external port to VIM'''
1852 '''Returns the port identifier'''
1853 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1855 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1856 #TODO openstack if needed
1857 '''Connects a external port to a network'''
1858 '''Returns status code of the VIM response'''
1859 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1861 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1862 '''Adds a new user to openstack VIM'''
1863 '''Returns the user identifier'''
1864 self
.logger
.debug("osconnector: Adding a new user to VIM")
1866 self
._reload
_connection
()
1867 user
=self
.keystone
.users
.create(user_name
, password
=user_passwd
, default_project
=tenant_id
)
1868 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1870 except ksExceptions
.ConnectionError
as e
:
1871 error_value
=-vimconn
.HTTP_Bad_Request
1872 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1873 except ksExceptions
.ClientException
as e
: #TODO remove
1874 error_value
=-vimconn
.HTTP_Bad_Request
1875 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1876 #TODO insert exception vimconn.HTTP_Unauthorized
1877 #if reaching here is because an exception
1878 self
.logger
.debug("new_user " + error_text
)
1879 return error_value
, error_text
1881 def delete_user(self
, user_id
):
1882 '''Delete a user from openstack VIM'''
1883 '''Returns the user identifier'''
1885 print("osconnector: Deleting a user from VIM")
1887 self
._reload
_connection
()
1888 self
.keystone
.users
.delete(user_id
)
1890 except ksExceptions
.ConnectionError
as e
:
1891 error_value
=-vimconn
.HTTP_Bad_Request
1892 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1893 except ksExceptions
.NotFound
as e
:
1894 error_value
=-vimconn
.HTTP_Not_Found
1895 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1896 except ksExceptions
.ClientException
as e
: #TODO remove
1897 error_value
=-vimconn
.HTTP_Bad_Request
1898 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1899 #TODO insert exception vimconn.HTTP_Unauthorized
1900 #if reaching here is because an exception
1901 self
.logger
.debug("delete_tenant " + error_text
)
1902 return error_value
, error_text
1904 def get_hosts_info(self
):
1905 '''Get the information of deployed hosts
1906 Returns the hosts content'''
1908 print("osconnector: Getting Host info from VIM")
1911 self
._reload
_connection
()
1912 hypervisors
= self
.nova
.hypervisors
.list()
1913 for hype
in hypervisors
:
1914 h_list
.append( hype
.to_dict() )
1915 return 1, {"hosts":h_list
}
1916 except nvExceptions
.NotFound
as e
:
1917 error_value
=-vimconn
.HTTP_Not_Found
1918 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1919 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1920 error_value
=-vimconn
.HTTP_Bad_Request
1921 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1922 #TODO insert exception vimconn.HTTP_Unauthorized
1923 #if reaching here is because an exception
1924 self
.logger
.debug("get_hosts_info " + error_text
)
1925 return error_value
, error_text
1927 def get_hosts(self
, vim_tenant
):
1928 '''Get the hosts and deployed instances
1929 Returns the hosts content'''
1930 r
, hype_dict
= self
.get_hosts_info()
1933 hypervisors
= hype_dict
["hosts"]
1935 servers
= self
.nova
.servers
.list()
1936 for hype
in hypervisors
:
1937 for server
in servers
:
1938 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1940 hype
['vm'].append(server
.id)
1942 hype
['vm'] = [server
.id]
1944 except nvExceptions
.NotFound
as e
:
1945 error_value
=-vimconn
.HTTP_Not_Found
1946 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1947 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1948 error_value
=-vimconn
.HTTP_Bad_Request
1949 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1950 #TODO insert exception vimconn.HTTP_Unauthorized
1951 #if reaching here is because an exception
1952 self
.logger
.debug("get_hosts " + error_text
)
1953 return error_value
, error_text
1955 def new_classification(self
, name
, ctype
, definition
):
1957 'Adding a new (Traffic) Classification to VIM, named %s', name
)
1960 self
._reload
_connection
()
1961 if ctype
not in supportedClassificationTypes
:
1962 raise vimconn
.vimconnNotSupportedException(
1963 'OpenStack VIM connector doesn\'t support provided '
1964 'Classification Type {}, supported ones are: '
1965 '{}'.format(ctype
, supportedClassificationTypes
))
1966 if not self
._validate
_classification
(ctype
, definition
):
1967 raise vimconn
.vimconnException(
1968 'Incorrect Classification definition '
1969 'for the type specified.')
1970 classification_dict
= definition
1971 classification_dict
['name'] = name
1973 new_class
= self
.neutron
.create_sfc_flow_classifier(
1974 {'flow_classifier': classification_dict
})
1975 return new_class
['flow_classifier']['id']
1976 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1977 neExceptions
.NeutronException
, ConnectionError
) as e
:
1979 'Creation of Classification failed.')
1980 self
._format
_exception
(e
)
1982 def get_classification(self
, class_id
):
1983 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
1984 filter_dict
= {"id": class_id
}
1985 class_list
= self
.get_classification_list(filter_dict
)
1986 if len(class_list
) == 0:
1987 raise vimconn
.vimconnNotFoundException(
1988 "Classification '{}' not found".format(class_id
))
1989 elif len(class_list
) > 1:
1990 raise vimconn
.vimconnConflictException(
1991 "Found more than one Classification with this criteria")
1992 classification
= class_list
[0]
1993 return classification
1995 def get_classification_list(self
, filter_dict
={}):
1996 self
.logger
.debug("Getting Classifications from VIM filter: '%s'",
1999 filter_dict_os
= filter_dict
.copy()
2000 self
._reload
_connection
()
2001 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2002 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2003 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
2005 classification_list
= classification_dict
["flow_classifiers"]
2006 self
.__classification
_os
2mano
(classification_list
)
2007 return classification_list
2008 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2009 neExceptions
.NeutronException
, ConnectionError
) as e
:
2010 self
._format
_exception
(e
)
2012 def delete_classification(self
, class_id
):
2013 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
2015 self
._reload
_connection
()
2016 self
.neutron
.delete_sfc_flow_classifier(class_id
)
2018 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2019 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2020 ConnectionError
) as e
:
2021 self
._format
_exception
(e
)
2023 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
2025 "Adding a new Service Function Instance to VIM, named '%s'", name
)
2028 self
._reload
_connection
()
2032 if len(ingress_ports
) != 1:
2033 raise vimconn
.vimconnNotSupportedException(
2034 "OpenStack VIM connector can only have "
2035 "1 ingress port per SFI")
2036 if len(egress_ports
) != 1:
2037 raise vimconn
.vimconnNotSupportedException(
2038 "OpenStack VIM connector can only have "
2039 "1 egress port per SFI")
2040 sfi_dict
= {'name': name
,
2041 'ingress': ingress_ports
[0],
2042 'egress': egress_ports
[0],
2043 'service_function_parameters': {
2044 'correlation': correlation
}}
2045 new_sfi
= self
.neutron
.create_sfc_port_pair({'port_pair': sfi_dict
})
2046 return new_sfi
['port_pair']['id']
2047 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2048 neExceptions
.NeutronException
, ConnectionError
) as e
:
2051 self
.neutron
.delete_sfc_port_pair(
2052 new_sfi
['port_pair']['id'])
2055 'Creation of Service Function Instance failed, with '
2056 'subsequent deletion failure as well.')
2057 self
._format
_exception
(e
)
2059 def get_sfi(self
, sfi_id
):
2061 'Getting Service Function Instance %s from VIM', sfi_id
)
2062 filter_dict
= {"id": sfi_id
}
2063 sfi_list
= self
.get_sfi_list(filter_dict
)
2064 if len(sfi_list
) == 0:
2065 raise vimconn
.vimconnNotFoundException(
2066 "Service Function Instance '{}' not found".format(sfi_id
))
2067 elif len(sfi_list
) > 1:
2068 raise vimconn
.vimconnConflictException(
2069 'Found more than one Service Function Instance '
2070 'with this criteria')
2074 def get_sfi_list(self
, filter_dict
={}):
2075 self
.logger
.debug("Getting Service Function Instances from "
2076 "VIM filter: '%s'", str(filter_dict
))
2078 self
._reload
_connection
()
2079 filter_dict_os
= filter_dict
.copy()
2080 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2081 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2082 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
2083 sfi_list
= sfi_dict
["port_pairs"]
2084 self
.__sfi
_os
2mano
(sfi_list
)
2086 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2087 neExceptions
.NeutronException
, ConnectionError
) as e
:
2088 self
._format
_exception
(e
)
2090 def delete_sfi(self
, sfi_id
):
2091 self
.logger
.debug("Deleting Service Function Instance '%s' "
2094 self
._reload
_connection
()
2095 self
.neutron
.delete_sfc_port_pair(sfi_id
)
2097 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2098 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2099 ConnectionError
) as e
:
2100 self
._format
_exception
(e
)
2102 def new_sf(self
, name
, sfis
, sfc_encap
=True):
2103 self
.logger
.debug("Adding a new Service Function to VIM, "
2107 self
._reload
_connection
()
2108 # correlation = None
2110 # correlation = 'nsh'
2111 for instance
in sfis
:
2112 sfi
= self
.get_sfi(instance
)
2113 if sfi
.get('sfc_encap') != sfc_encap
:
2114 raise vimconn
.vimconnNotSupportedException(
2115 "OpenStack VIM connector requires all SFIs of the "
2116 "same SF to share the same SFC Encapsulation")
2117 sf_dict
= {'name': name
,
2119 new_sf
= self
.neutron
.create_sfc_port_pair_group({
2120 'port_pair_group': sf_dict
})
2121 return new_sf
['port_pair_group']['id']
2122 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2123 neExceptions
.NeutronException
, ConnectionError
) as e
:
2126 self
.neutron
.delete_sfc_port_pair_group(
2127 new_sf
['port_pair_group']['id'])
2130 'Creation of Service Function failed, with '
2131 'subsequent deletion failure as well.')
2132 self
._format
_exception
(e
)
2134 def get_sf(self
, sf_id
):
2135 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
2136 filter_dict
= {"id": sf_id
}
2137 sf_list
= self
.get_sf_list(filter_dict
)
2138 if len(sf_list
) == 0:
2139 raise vimconn
.vimconnNotFoundException(
2140 "Service Function '{}' not found".format(sf_id
))
2141 elif len(sf_list
) > 1:
2142 raise vimconn
.vimconnConflictException(
2143 "Found more than one Service Function with this criteria")
2147 def get_sf_list(self
, filter_dict
={}):
2148 self
.logger
.debug("Getting Service Function from VIM filter: '%s'",
2151 self
._reload
_connection
()
2152 filter_dict_os
= filter_dict
.copy()
2153 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2154 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2155 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
2156 sf_list
= sf_dict
["port_pair_groups"]
2157 self
.__sf
_os
2mano
(sf_list
)
2159 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2160 neExceptions
.NeutronException
, ConnectionError
) as e
:
2161 self
._format
_exception
(e
)
2163 def delete_sf(self
, sf_id
):
2164 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
2166 self
._reload
_connection
()
2167 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
2169 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2170 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2171 ConnectionError
) as e
:
2172 self
._format
_exception
(e
)
2174 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
2175 self
.logger
.debug("Adding a new Service Function Path to VIM, "
2179 self
._reload
_connection
()
2180 # In networking-sfc the MPLS encapsulation is legacy
2181 # should be used when no full SFC Encapsulation is intended
2182 correlation
= 'mpls'
2185 sfp_dict
= {'name': name
,
2186 'flow_classifiers': classifications
,
2187 'port_pair_groups': sfs
,
2188 'chain_parameters': {'correlation': correlation
}}
2190 sfp_dict
['chain_id'] = spi
2191 new_sfp
= self
.neutron
.create_sfc_port_chain({'port_chain': sfp_dict
})
2192 return new_sfp
["port_chain"]["id"]
2193 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2194 neExceptions
.NeutronException
, ConnectionError
) as e
:
2197 self
.neutron
.delete_sfc_port_chain(new_sfp
['port_chain']['id'])
2200 'Creation of Service Function Path failed, with '
2201 'subsequent deletion failure as well.')
2202 self
._format
_exception
(e
)
2204 def get_sfp(self
, sfp_id
):
2205 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
2206 filter_dict
= {"id": sfp_id
}
2207 sfp_list
= self
.get_sfp_list(filter_dict
)
2208 if len(sfp_list
) == 0:
2209 raise vimconn
.vimconnNotFoundException(
2210 "Service Function Path '{}' not found".format(sfp_id
))
2211 elif len(sfp_list
) > 1:
2212 raise vimconn
.vimconnConflictException(
2213 "Found more than one Service Function Path with this criteria")
2217 def get_sfp_list(self
, filter_dict
={}):
2218 self
.logger
.debug("Getting Service Function Paths from VIM filter: "
2219 "'%s'", str(filter_dict
))
2221 self
._reload
_connection
()
2222 filter_dict_os
= filter_dict
.copy()
2223 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2224 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2225 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
2226 sfp_list
= sfp_dict
["port_chains"]
2227 self
.__sfp
_os
2mano
(sfp_list
)
2229 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2230 neExceptions
.NeutronException
, ConnectionError
) as e
:
2231 self
._format
_exception
(e
)
2233 def delete_sfp(self
, sfp_id
):
2235 "Deleting Service Function Path '%s' from VIM", sfp_id
)
2237 self
._reload
_connection
()
2238 self
.neutron
.delete_sfc_port_chain(sfp_id
)
2240 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2241 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2242 ConnectionError
) as e
:
2243 self
._format
_exception
(e
)