1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefonica Investigacion y Desarrollo, S.A.U.
5 # This file is part of openmano
8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
9 # not use this file except in compliance with the License. You may obtain
10 # a copy of the License at
12 # http://www.apache.org/licenses/LICENSE-2.0
14 # Unless required by applicable law or agreed to in writing, software
15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17 # License for the specific language governing permissions and limitations
22 osconnector implements all the methods to interact with openstack using the python-neutronclient.
24 For the VNF forwarding graph, The OpenStack VIM connector calls the
25 networking-sfc Neutron extension methods, whose resources are mapped
26 to the VIM connector's SFC resources as follows:
27 - Classification (OSM) -> Flow Classifier (Neutron)
28 - Service Function Instance (OSM) -> Port Pair (Neutron)
29 - Service Function (OSM) -> Port Pair Group (Neutron)
30 - Service Function Path (OSM) -> Port Chain (Neutron)
32 __author__
= "Alfonso Tierno, Gerardo Garcia, Pablo Montes, xFlow Research, Igor D.C., Eduardo Sousa"
33 __date__
= "$22-sep-2017 23:59:59$"
35 from osm_ro
import vimconn
44 from pprint
import pformat
46 from novaclient
import client
as nClient
, exceptions
as nvExceptions
47 from keystoneauth1
.identity
import v2
, v3
48 from keystoneauth1
import session
49 import keystoneclient
.exceptions
as ksExceptions
50 import keystoneclient
.v3
.client
as ksClient_v3
51 import keystoneclient
.v2_0
.client
as ksClient_v2
52 from glanceclient
import client
as glClient
53 import glanceclient
.exc
as gl1Exceptions
54 from cinderclient
import client
as cClient
55 from http
.client
import HTTPException
# TODO py3 check that this base exception matches python2 httplib.HTTPException
56 from neutronclient
.neutron
import client
as neClient
57 from neutronclient
.common
import exceptions
as neExceptions
58 from requests
.exceptions
import ConnectionError
61 """contain the openstack virtual machine status to openmano status"""
62 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
64 'SUSPENDED': 'SUSPENDED',
67 'ERROR':'ERROR','DELETED':'DELETED'
69 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
72 supportedClassificationTypes
= ['legacy_flow_classifier']
74 #global var to have a timeout creating and deleting volumes
79 class SafeDumper(yaml
.SafeDumper
):
80 def represent_data(self
, data
):
81 # Openstack APIs use custom subclasses of dict and YAML safe dumper
82 # is designed to not handle that (reference issue 142 of pyyaml)
83 if isinstance(data
, dict) and data
.__class
__ != dict:
84 # A simple solution is to convert those items back to dicts
85 data
= dict(data
.items())
87 return super(SafeDumper
, self
).represent_data(data
)
90 class vimconnector(vimconn
.vimconnector
):
91 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
92 log_level
=None, config
={}, persistent_info
={}):
93 '''using common constructor parameters. In this case
94 'url' is the keystone authorization url,
95 'url_admin' is not use
97 api_version
= config
.get('APIversion')
98 if api_version
and api_version
not in ('v3.3', 'v2.0', '2', '3'):
99 raise vimconn
.vimconnException("Invalid value '{}' for config:APIversion. "
100 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version
))
101 vim_type
= config
.get('vim_type')
102 if vim_type
and vim_type
not in ('vio', 'VIO'):
103 raise vimconn
.vimconnException("Invalid value '{}' for config:vim_type."
104 "Allowed values are 'vio' or 'VIO'".format(vim_type
))
106 if config
.get('dataplane_net_vlan_range') is not None:
107 #validate vlan ranges provided by user
108 self
._validate
_vlan
_ranges
(config
.get('dataplane_net_vlan_range'), 'dataplane_net_vlan_range')
110 if config
.get('multisegment_vlan_range') is not None:
111 #validate vlan ranges provided by user
112 self
._validate
_vlan
_ranges
(config
.get('multisegment_vlan_range'), 'multisegment_vlan_range')
114 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
,
117 if self
.config
.get("insecure") and self
.config
.get("ca_cert"):
118 raise vimconn
.vimconnException("options insecure and ca_cert are mutually exclusive")
120 if self
.config
.get("insecure"):
122 if self
.config
.get("ca_cert"):
123 self
.verify
= self
.config
.get("ca_cert")
126 raise TypeError('url param can not be NoneType')
127 self
.persistent_info
= persistent_info
128 self
.availability_zone
= persistent_info
.get('availability_zone', None)
129 self
.session
= persistent_info
.get('session', {'reload_client': True})
130 self
.my_tenant_id
= self
.session
.get('my_tenant_id')
131 self
.nova
= self
.session
.get('nova')
132 self
.neutron
= self
.session
.get('neutron')
133 self
.cinder
= self
.session
.get('cinder')
134 self
.glance
= self
.session
.get('glance')
135 # self.glancev1 = self.session.get('glancev1')
136 self
.keystone
= self
.session
.get('keystone')
137 self
.api_version3
= self
.session
.get('api_version3')
138 self
.vim_type
= self
.config
.get("vim_type")
140 self
.vim_type
= self
.vim_type
.upper()
141 if self
.config
.get("use_internal_endpoint"):
142 self
.endpoint_type
= "internalURL"
144 self
.endpoint_type
= None
146 self
.logger
= logging
.getLogger('openmano.vim.openstack')
148 # allow security_groups to be a list or a single string
149 if isinstance(self
.config
.get('security_groups'), str):
150 self
.config
['security_groups'] = [self
.config
['security_groups']]
151 self
.security_groups_id
= None
153 ####### VIO Specific Changes #########
154 if self
.vim_type
== "VIO":
155 self
.logger
= logging
.getLogger('openmano.vim.vio')
158 self
.logger
.setLevel( getattr(logging
, log_level
))
160 def __getitem__(self
, index
):
161 """Get individuals parameters.
163 if index
== 'project_domain_id':
164 return self
.config
.get("project_domain_id")
165 elif index
== 'user_domain_id':
166 return self
.config
.get("user_domain_id")
168 return vimconn
.vimconnector
.__getitem
__(self
, index
)
170 def __setitem__(self
, index
, value
):
171 """Set individuals parameters and it is marked as dirty so to force connection reload.
173 if index
== 'project_domain_id':
174 self
.config
["project_domain_id"] = value
175 elif index
== 'user_domain_id':
176 self
.config
["user_domain_id"] = value
178 vimconn
.vimconnector
.__setitem
__(self
, index
, value
)
179 self
.session
['reload_client'] = True
181 def serialize(self
, value
):
182 """Serialization of python basic types.
184 In the case value is not serializable a message will be logged and a
185 simple representation of the data that cannot be converted back to
188 if isinstance(value
, str):
192 return yaml
.dump(value
, Dumper
=SafeDumper
,
193 default_flow_style
=True, width
=256)
194 except yaml
.representer
.RepresenterError
:
195 self
.logger
.debug('The following entity cannot be serialized in YAML:\n\n%s\n\n', pformat(value
),
199 def _reload_connection(self
):
200 '''Called before any operation, it check if credentials has changed
201 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
203 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
204 if self
.session
['reload_client']:
205 if self
.config
.get('APIversion'):
206 self
.api_version3
= self
.config
['APIversion'] == 'v3.3' or self
.config
['APIversion'] == '3'
207 else: # get from ending auth_url that end with v3 or with v2.0
208 self
.api_version3
= self
.url
.endswith("/v3") or self
.url
.endswith("/v3/")
209 self
.session
['api_version3'] = self
.api_version3
210 if self
.api_version3
:
211 if self
.config
.get('project_domain_id') or self
.config
.get('project_domain_name'):
212 project_domain_id_default
= None
214 project_domain_id_default
= 'default'
215 if self
.config
.get('user_domain_id') or self
.config
.get('user_domain_name'):
216 user_domain_id_default
= None
218 user_domain_id_default
= 'default'
219 auth
= v3
.Password(auth_url
=self
.url
,
221 password
=self
.passwd
,
222 project_name
=self
.tenant_name
,
223 project_id
=self
.tenant_id
,
224 project_domain_id
=self
.config
.get('project_domain_id', project_domain_id_default
),
225 user_domain_id
=self
.config
.get('user_domain_id', user_domain_id_default
),
226 project_domain_name
=self
.config
.get('project_domain_name'),
227 user_domain_name
=self
.config
.get('user_domain_name'))
229 auth
= v2
.Password(auth_url
=self
.url
,
231 password
=self
.passwd
,
232 tenant_name
=self
.tenant_name
,
233 tenant_id
=self
.tenant_id
)
234 sess
= session
.Session(auth
=auth
, verify
=self
.verify
)
235 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River Titanium cloud and StarlingX
236 region_name
= self
.config
.get('region_name')
237 if self
.api_version3
:
238 self
.keystone
= ksClient_v3
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
240 self
.keystone
= ksClient_v2
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
241 self
.session
['keystone'] = self
.keystone
242 # In order to enable microversion functionality an explicit microversion must be specified in 'config'.
243 # This implementation approach is due to the warning message in
244 # https://developer.openstack.org/api-guide/compute/microversions.html
245 # where it is stated that microversion backwards compatibility is not guaranteed and clients should
246 # always require an specific microversion.
247 # To be able to use 'device role tagging' functionality define 'microversion: 2.32' in datacenter config
248 version
= self
.config
.get("microversion")
251 # addedd region_name to keystone, nova, neutron and cinder to support distributed cloud for Wind River Titanium cloud and StarlingX
252 self
.nova
= self
.session
['nova'] = nClient
.Client(str(version
), session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
253 self
.neutron
= self
.session
['neutron'] = neClient
.Client('2.0', session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
254 self
.cinder
= self
.session
['cinder'] = cClient
.Client(2, session
=sess
, endpoint_type
=self
.endpoint_type
, region_name
=region_name
)
256 self
.my_tenant_id
= self
.session
['my_tenant_id'] = sess
.get_project_id()
257 except Exception as e
:
258 self
.logger
.error("Cannot get project_id from session", exc_info
=True)
259 if self
.endpoint_type
== "internalURL":
260 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
261 glance_endpoint
= self
.keystone
.endpoints
.list(glance_service_id
, interface
="internal")[0].url
263 glance_endpoint
= None
264 self
.glance
= self
.session
['glance'] = glClient
.Client(2, session
=sess
, endpoint
=glance_endpoint
)
265 # using version 1 of glance client in new_image()
266 # self.glancev1 = self.session['glancev1'] = glClient.Client('1', session=sess,
267 # endpoint=glance_endpoint)
268 self
.session
['reload_client'] = False
269 self
.persistent_info
['session'] = self
.session
270 # add availablity zone info inside self.persistent_info
271 self
._set
_availablity
_zones
()
272 self
.persistent_info
['availability_zone'] = self
.availability_zone
273 self
.security_groups_id
= None # force to get again security_groups_ids next time they are needed
275 def __net_os2mano(self
, net_list_dict
):
276 '''Transform the net openstack format to mano format
277 net_list_dict can be a list of dict or a single dict'''
278 if type(net_list_dict
) is dict:
279 net_list_
=(net_list_dict
,)
280 elif type(net_list_dict
) is list:
281 net_list_
=net_list_dict
283 raise TypeError("param net_list_dict must be a list or a dictionary")
284 for net
in net_list_
:
285 if net
.get('provider:network_type') == "vlan":
290 def __classification_os2mano(self
, class_list_dict
):
291 """Transform the openstack format (Flow Classifier) to mano format
292 (Classification) class_list_dict can be a list of dict or a single dict
294 if isinstance(class_list_dict
, dict):
295 class_list_
= [class_list_dict
]
296 elif isinstance(class_list_dict
, list):
297 class_list_
= class_list_dict
300 "param class_list_dict must be a list or a dictionary")
301 for classification
in class_list_
:
302 id = classification
.pop('id')
303 name
= classification
.pop('name')
304 description
= classification
.pop('description')
305 project_id
= classification
.pop('project_id')
306 tenant_id
= classification
.pop('tenant_id')
307 original_classification
= copy
.deepcopy(classification
)
308 classification
.clear()
309 classification
['ctype'] = 'legacy_flow_classifier'
310 classification
['definition'] = original_classification
311 classification
['id'] = id
312 classification
['name'] = name
313 classification
['description'] = description
314 classification
['project_id'] = project_id
315 classification
['tenant_id'] = tenant_id
317 def __sfi_os2mano(self
, sfi_list_dict
):
318 """Transform the openstack format (Port Pair) to mano format (SFI)
319 sfi_list_dict can be a list of dict or a single dict
321 if isinstance(sfi_list_dict
, dict):
322 sfi_list_
= [sfi_list_dict
]
323 elif isinstance(sfi_list_dict
, list):
324 sfi_list_
= sfi_list_dict
327 "param sfi_list_dict must be a list or a dictionary")
328 for sfi
in sfi_list_
:
329 sfi
['ingress_ports'] = []
330 sfi
['egress_ports'] = []
331 if sfi
.get('ingress'):
332 sfi
['ingress_ports'].append(sfi
['ingress'])
333 if sfi
.get('egress'):
334 sfi
['egress_ports'].append(sfi
['egress'])
337 params
= sfi
.get('service_function_parameters')
340 correlation
= params
.get('correlation')
343 sfi
['sfc_encap'] = sfc_encap
344 del sfi
['service_function_parameters']
346 def __sf_os2mano(self
, sf_list_dict
):
347 """Transform the openstack format (Port Pair Group) to mano format (SF)
348 sf_list_dict can be a list of dict or a single dict
350 if isinstance(sf_list_dict
, dict):
351 sf_list_
= [sf_list_dict
]
352 elif isinstance(sf_list_dict
, list):
353 sf_list_
= sf_list_dict
356 "param sf_list_dict must be a list or a dictionary")
358 del sf
['port_pair_group_parameters']
359 sf
['sfis'] = sf
['port_pairs']
362 def __sfp_os2mano(self
, sfp_list_dict
):
363 """Transform the openstack format (Port Chain) to mano format (SFP)
364 sfp_list_dict can be a list of dict or a single dict
366 if isinstance(sfp_list_dict
, dict):
367 sfp_list_
= [sfp_list_dict
]
368 elif isinstance(sfp_list_dict
, list):
369 sfp_list_
= sfp_list_dict
372 "param sfp_list_dict must be a list or a dictionary")
373 for sfp
in sfp_list_
:
374 params
= sfp
.pop('chain_parameters')
377 correlation
= params
.get('correlation')
380 sfp
['sfc_encap'] = sfc_encap
381 sfp
['spi'] = sfp
.pop('chain_id')
382 sfp
['classifications'] = sfp
.pop('flow_classifiers')
383 sfp
['service_functions'] = sfp
.pop('port_pair_groups')
385 # placeholder for now; read TODO note below
386 def _validate_classification(self
, type, definition
):
387 # only legacy_flow_classifier Type is supported at this point
389 # TODO(igordcard): this method should be an abstract method of an
390 # abstract Classification class to be implemented by the specific
391 # Types. Also, abstract vimconnector should call the validation
392 # method before the implemented VIM connectors are called.
394 def _format_exception(self
, exception
):
395 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
397 message_error
= exception
.message
399 if isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
, ksExceptions
.NotFound
,
400 gl1Exceptions
.HTTPNotFound
)):
401 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + message_error
)
402 elif isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
403 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
)):
404 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + message_error
)
405 elif isinstance(exception
, (KeyError, nvExceptions
.BadRequest
, ksExceptions
.BadRequest
)):
406 raise vimconn
.vimconnException(type(exception
).__name
__ + ": " + message_error
)
407 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
408 neExceptions
.NeutronException
)):
409 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + message_error
)
410 elif isinstance(exception
, nvExceptions
.Conflict
):
411 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + message_error
)
412 elif isinstance(exception
, vimconn
.vimconnException
):
415 self
.logger
.error("General Exception " + message_error
, exc_info
=True)
416 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + message_error
)
418 def _get_ids_from_name(self
):
420 Obtain ids from name of tenant and security_groups. Store at self .security_groups_id"
423 # get tenant_id if only tenant_name is supplied
424 self
._reload
_connection
()
425 if not self
.my_tenant_id
:
426 raise vimconn
.vimconnConnectionException("Error getting tenant information from name={} id={}".
427 format(self
.tenant_name
, self
.tenant_id
))
428 if self
.config
.get('security_groups') and not self
.security_groups_id
:
429 # convert from name to id
430 neutron_sg_list
= self
.neutron
.list_security_groups(tenant_id
=self
.my_tenant_id
)["security_groups"]
432 self
.security_groups_id
= []
433 for sg
in self
.config
.get('security_groups'):
434 for neutron_sg
in neutron_sg_list
:
435 if sg
in (neutron_sg
["id"], neutron_sg
["name"]):
436 self
.security_groups_id
.append(neutron_sg
["id"])
439 self
.security_groups_id
= None
440 raise vimconn
.vimconnConnectionException("Not found security group {} for this tenant".format(sg
))
442 def check_vim_connectivity(self
):
443 # just get network list to check connectivity and credentials
444 self
.get_network_list(filter_dict
={})
446 def get_tenant_list(self
, filter_dict
={}):
447 '''Obtain tenants of VIM
448 filter_dict can contain the following keys:
449 name: filter by tenant name
450 id: filter by tenant uuid/id
452 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
454 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
456 self
._reload
_connection
()
457 if self
.api_version3
:
458 project_class_list
= self
.keystone
.projects
.list(name
=filter_dict
.get("name"))
460 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
462 for project
in project_class_list
:
463 if filter_dict
.get('id') and filter_dict
["id"] != project
.id:
465 project_list
.append(project
.to_dict())
467 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
468 self
._format
_exception
(e
)
470 def new_tenant(self
, tenant_name
, tenant_description
):
471 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
472 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
474 self
._reload
_connection
()
475 if self
.api_version3
:
476 project
= self
.keystone
.projects
.create(tenant_name
, self
.config
.get("project_domain_id", "default"),
477 description
=tenant_description
, is_domain
=False)
479 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
481 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ksExceptions
.BadRequest
, ConnectionError
) as e
:
482 self
._format
_exception
(e
)
484 def delete_tenant(self
, tenant_id
):
485 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
486 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
488 self
._reload
_connection
()
489 if self
.api_version3
:
490 self
.keystone
.projects
.delete(tenant_id
)
492 self
.keystone
.tenants
.delete(tenant_id
)
494 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ksExceptions
.NotFound
, ConnectionError
) as e
:
495 self
._format
_exception
(e
)
497 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, provider_network_profile
=None):
498 """Adds a tenant network to VIM
500 'net_name': name of the network
502 'bridge': overlay isolated network
503 'data': underlay E-LAN network for Passthrough and SRIOV interfaces
504 'ptp': underlay E-LINE network for Passthrough and SRIOV interfaces.
505 'ip_profile': is a dict containing the IP parameters of the network
506 'ip_version': can be "IPv4" or "IPv6" (Currently only IPv4 is implemented)
507 'subnet_address': ip_prefix_schema, that is X.X.X.X/Y
508 'gateway_address': (Optional) ip_schema, that is X.X.X.X
509 'dns_address': (Optional) comma separated list of ip_schema, e.g. X.X.X.X[,X,X,X,X]
510 'dhcp_enabled': True or False
511 'dhcp_start_address': ip_schema, first IP to grant
512 'dhcp_count': number of IPs to grant.
513 'shared': if this network can be seen/use by other tenants/organization
514 'provider_network_profile': (optional) contains {segmentation-id: vlan, provider-network: vim_netowrk}
515 Returns a tuple with the network identifier and created_items, or raises an exception on error
516 created_items can be None or a dictionary where this method can include key-values that will be passed to
517 the method delete_network. Can be used to store created segments, created l2gw connections, etc.
518 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
521 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
522 # self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
526 if provider_network_profile
:
527 vlan
= provider_network_profile
.get("segmentation-id")
530 self
._reload
_connection
()
531 network_dict
= {'name': net_name
, 'admin_state_up': True}
532 if net_type
=="data" or net_type
=="ptp":
533 if self
.config
.get('dataplane_physical_net') == None:
534 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
535 if not self
.config
.get('multisegment_support'):
536 network_dict
["provider:physical_network"] = self
.config
[
537 'dataplane_physical_net'] # "physnet_sriov" #TODO physical
538 network_dict
["provider:network_type"] = "vlan"
540 network_dict
["provider:network_type"] = vlan
542 ###### Multi-segment case ######
545 segment1_dict
["provider:physical_network"] = ''
546 segment1_dict
["provider:network_type"] = 'vxlan'
547 segment_list
.append(segment1_dict
)
549 segment2_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net']
550 segment2_dict
["provider:network_type"] = "vlan"
551 if self
.config
.get('multisegment_vlan_range'):
552 vlanID
= self
._generate
_multisegment
_vlanID
()
553 segment2_dict
["provider:segmentation_id"] = vlanID
555 # raise vimconn.vimconnConflictException(
556 # "You must provide 'multisegment_vlan_range' at config dict before creating a multisegment network")
557 segment_list
.append(segment2_dict
)
558 network_dict
["segments"] = segment_list
560 ####### VIO Specific Changes #########
561 if self
.vim_type
== "VIO":
563 network_dict
["provider:segmentation_id"] = vlan
565 if self
.config
.get('dataplane_net_vlan_range') is None:
566 raise vimconn
.vimconnConflictException("You must provide "\
567 "'dataplane_net_vlan_range' in format [start_ID - end_ID]"\
568 "at config value before creating sriov network with vlan tag")
570 network_dict
["provider:segmentation_id"] = self
._generate
_vlanID
()
572 network_dict
["shared"] = shared
573 if self
.config
.get("disable_network_port_security"):
574 network_dict
["port_security_enabled"] = False
575 new_net
= self
.neutron
.create_network({'network':network_dict
})
577 # create subnetwork, even if there is no profile
580 if not ip_profile
.get('subnet_address'):
581 #Fake subnet is required
582 subnet_rand
= random
.randint(0, 255)
583 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
584 if 'ip_version' not in ip_profile
:
585 ip_profile
['ip_version'] = "IPv4"
586 subnet
= {"name": net_name
+"-subnet",
587 "network_id": new_net
["network"]["id"],
588 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
589 "cidr": ip_profile
['subnet_address']
591 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
592 if ip_profile
.get('gateway_address'):
593 subnet
['gateway_ip'] = ip_profile
['gateway_address']
595 subnet
['gateway_ip'] = None
596 if ip_profile
.get('dns_address'):
597 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
598 if 'dhcp_enabled' in ip_profile
:
599 subnet
['enable_dhcp'] = False if \
600 ip_profile
['dhcp_enabled']=="false" or ip_profile
['dhcp_enabled']==False else True
601 if ip_profile
.get('dhcp_start_address'):
602 subnet
['allocation_pools'] = []
603 subnet
['allocation_pools'].append(dict())
604 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
605 if ip_profile
.get('dhcp_count'):
606 #parts = ip_profile['dhcp_start_address'].split('.')
607 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
608 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
609 ip_int
+= ip_profile
['dhcp_count'] - 1
610 ip_str
= str(netaddr
.IPAddress(ip_int
))
611 subnet
['allocation_pools'][0]['end'] = ip_str
612 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
613 self
.neutron
.create_subnet({"subnet": subnet
} )
615 if net_type
== "data" and self
.config
.get('multisegment_support'):
616 if self
.config
.get('l2gw_support'):
617 l2gw_list
= self
.neutron
.list_l2_gateways().get("l2_gateways", ())
618 for l2gw
in l2gw_list
:
620 l2gw_conn
["l2_gateway_id"] = l2gw
["id"]
621 l2gw_conn
["network_id"] = new_net
["network"]["id"]
622 l2gw_conn
["segmentation_id"] = str(vlanID
)
623 new_l2gw_conn
= self
.neutron
.create_l2_gateway_connection({"l2_gateway_connection": l2gw_conn
})
624 created_items
["l2gwconn:" + str(new_l2gw_conn
["l2_gateway_connection"]["id"])] = True
625 return new_net
["network"]["id"], created_items
626 except Exception as e
:
627 #delete l2gw connections (if any) before deleting the network
628 for k
, v
in created_items
.items():
629 if not v
: # skip already deleted
632 k_item
, _
, k_id
= k
.partition(":")
633 if k_item
== "l2gwconn":
634 self
.neutron
.delete_l2_gateway_connection(k_id
)
635 except Exception as e2
:
636 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e2
).__name
__, e2
))
638 self
.neutron
.delete_network(new_net
['network']['id'])
639 self
._format
_exception
(e
)
641 def get_network_list(self
, filter_dict
={}):
642 '''Obtain tenant networks of VIM
648 admin_state_up: boolean
650 Returns the network list of dictionaries
652 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
654 self
._reload
_connection
()
655 filter_dict_os
= filter_dict
.copy()
656 if self
.api_version3
and "tenant_id" in filter_dict_os
:
657 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id') #T ODO check
658 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
659 net_list
= net_dict
["networks"]
660 self
.__net
_os
2mano
(net_list
)
662 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
663 self
._format
_exception
(e
)
665 def get_network(self
, net_id
):
666 '''Obtain details of network from VIM
667 Returns the network information from a network id'''
668 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
669 filter_dict
={"id": net_id
}
670 net_list
= self
.get_network_list(filter_dict
)
672 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
673 elif len(net_list
)>1:
674 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
677 for subnet_id
in net
.get("subnets", () ):
679 subnet
= self
.neutron
.show_subnet(subnet_id
)
680 except Exception as e
:
681 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
682 subnet
= {"id": subnet_id
, "fault": str(e
)}
683 subnets
.append(subnet
)
684 net
["subnets"] = subnets
685 net
["encapsulation"] = net
.get('provider:network_type')
686 net
["encapsulation_type"] = net
.get('provider:network_type')
687 net
["segmentation_id"] = net
.get('provider:segmentation_id')
688 net
["encapsulation_id"] = net
.get('provider:segmentation_id')
691 def delete_network(self
, net_id
, created_items
=None):
693 Removes a tenant network from VIM and its associated elements
694 :param net_id: VIM identifier of the network, provided by method new_network
695 :param created_items: dictionary with extra items to be deleted. provided by method new_network
696 Returns the network identifier or raises an exception upon error or when network is not found
698 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
699 if created_items
== None:
702 self
._reload
_connection
()
703 #delete l2gw connections (if any) before deleting the network
704 for k
, v
in created_items
.items():
705 if not v
: # skip already deleted
708 k_item
, _
, k_id
= k
.partition(":")
709 if k_item
== "l2gwconn":
710 self
.neutron
.delete_l2_gateway_connection(k_id
)
711 except Exception as e
:
712 self
.logger
.error("Error deleting l2 gateway connection: {}: {}".format(type(e
).__name
__, e
))
713 #delete VM ports attached to this networks before the network
714 ports
= self
.neutron
.list_ports(network_id
=net_id
)
715 for p
in ports
['ports']:
717 self
.neutron
.delete_port(p
["id"])
718 except Exception as e
:
719 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
720 self
.neutron
.delete_network(net_id
)
722 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
723 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
724 self
._format
_exception
(e
)
726 def refresh_nets_status(self
, net_list
):
727 '''Get the status of the networks
728 Params: the list of network identifiers
729 Returns a dictionary with:
730 net_id: #VIM id of this network
731 status: #Mandatory. Text with one of:
732 # DELETED (not found at vim)
733 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
734 # OTHER (Vim reported other status not understood)
735 # ERROR (VIM indicates an ERROR status)
736 # ACTIVE, INACTIVE, DOWN (admin down),
737 # BUILD (on building process)
739 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
740 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
744 for net_id
in net_list
:
747 net_vim
= self
.get_network(net_id
)
748 if net_vim
['status'] in netStatus2manoFormat
:
749 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
751 net
["status"] = "OTHER"
752 net
["error_msg"] = "VIM status reported " + net_vim
['status']
754 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
755 net
['status'] = 'DOWN'
757 net
['vim_info'] = self
.serialize(net_vim
)
759 if net_vim
.get('fault'): #TODO
760 net
['error_msg'] = str(net_vim
['fault'])
761 except vimconn
.vimconnNotFoundException
as e
:
762 self
.logger
.error("Exception getting net status: %s", str(e
))
763 net
['status'] = "DELETED"
764 net
['error_msg'] = str(e
)
765 except vimconn
.vimconnException
as e
:
766 self
.logger
.error("Exception getting net status: %s", str(e
))
767 net
['status'] = "VIM_ERROR"
768 net
['error_msg'] = str(e
)
769 net_dict
[net_id
] = net
772 def get_flavor(self
, flavor_id
):
773 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
774 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
776 self
._reload
_connection
()
777 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
778 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
779 return flavor
.to_dict()
780 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
781 self
._format
_exception
(e
)
783 def get_flavor_id_from_data(self
, flavor_dict
):
784 """Obtain flavor id that match the flavor description
785 Returns the flavor_id or raises a vimconnNotFoundException
786 flavor_dict: contains the required ram, vcpus, disk
787 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
788 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
789 vimconnNotFoundException is raised
791 exact_match
= False if self
.config
.get('use_existing_flavors') else True
793 self
._reload
_connection
()
794 flavor_candidate_id
= None
795 flavor_candidate_data
= (10000, 10000, 10000)
796 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
798 extended
= flavor_dict
.get("extended", {})
801 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemented")
803 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
805 # numas = extended.get("numas")
806 for flavor
in self
.nova
.flavors
.list():
807 epa
= flavor
.get_keys()
811 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
812 if flavor_data
== flavor_target
:
814 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
815 flavor_candidate_id
= flavor
.id
816 flavor_candidate_data
= flavor_data
817 if not exact_match
and flavor_candidate_id
:
818 return flavor_candidate_id
819 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
820 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
821 self
._format
_exception
(e
)
823 def process_resource_quota(self
, quota
, prefix
, extra_specs
):
830 extra_specs
["quota:" + prefix
+ "_limit"] = quota
['limit']
831 if 'reserve' in quota
:
832 extra_specs
["quota:" + prefix
+ "_reservation"] = quota
['reserve']
833 if 'shares' in quota
:
834 extra_specs
["quota:" + prefix
+ "_shares_level"] = "custom"
835 extra_specs
["quota:" + prefix
+ "_shares_share"] = quota
['shares']
837 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
838 '''Adds a tenant flavor to openstack VIM
839 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
840 Returns the flavor identifier
842 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
847 name
=flavor_data
['name']
848 while retry
<max_retries
:
851 self
._reload
_connection
()
852 if change_name_if_used
:
855 fl
=self
.nova
.flavors
.list()
857 fl_names
.append(f
.name
)
858 while name
in fl_names
:
860 name
= flavor_data
['name']+"-" + str(name_suffix
)
862 ram
= flavor_data
.get('ram',64)
863 vcpus
= flavor_data
.get('vcpus',1)
866 extended
= flavor_data
.get("extended")
868 numas
=extended
.get("numas")
870 numa_nodes
= len(numas
)
872 return -1, "Can not add flavor with more than one numa"
873 extra_specs
["hw:numa_nodes"] = str(numa_nodes
)
874 extra_specs
["hw:mem_page_size"] = "large"
875 extra_specs
["hw:cpu_policy"] = "dedicated"
876 extra_specs
["hw:numa_mempolicy"] = "strict"
877 if self
.vim_type
== "VIO":
878 extra_specs
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
879 extra_specs
["vmware:latency_sensitivity_level"] = "high"
881 #overwrite ram and vcpus
882 #check if key 'memory' is present in numa else use ram value at flavor
884 ram
= numa
['memory']*1024
885 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
886 extra_specs
["hw:cpu_sockets"] = 1
887 if 'paired-threads' in numa
:
888 vcpus
= numa
['paired-threads']*2
889 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
890 extra_specs
["hw:cpu_thread_policy"] = "require"
891 extra_specs
["hw:cpu_policy"] = "dedicated"
892 elif 'cores' in numa
:
893 vcpus
= numa
['cores']
894 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
895 extra_specs
["hw:cpu_thread_policy"] = "isolate"
896 extra_specs
["hw:cpu_policy"] = "dedicated"
897 elif 'threads' in numa
:
898 vcpus
= numa
['threads']
899 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
900 extra_specs
["hw:cpu_thread_policy"] = "prefer"
901 extra_specs
["hw:cpu_policy"] = "dedicated"
902 # for interface in numa.get("interfaces",() ):
903 # if interface["dedicated"]=="yes":
904 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
905 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
906 elif extended
.get("cpu-quota"):
907 self
.process_resource_quota(extended
.get("cpu-quota"), "cpu", extra_specs
)
908 if extended
.get("mem-quota"):
909 self
.process_resource_quota(extended
.get("mem-quota"), "memory", extra_specs
)
910 if extended
.get("vif-quota"):
911 self
.process_resource_quota(extended
.get("vif-quota"), "vif", extra_specs
)
912 if extended
.get("disk-io-quota"):
913 self
.process_resource_quota(extended
.get("disk-io-quota"), "disk_io", extra_specs
)
915 new_flavor
=self
.nova
.flavors
.create(name
,
918 flavor_data
.get('disk',0),
919 is_public
=flavor_data
.get('is_public', True)
923 new_flavor
.set_keys(extra_specs
)
925 except nvExceptions
.Conflict
as e
:
926 if change_name_if_used
and retry
< max_retries
:
928 self
._format
_exception
(e
)
929 #except nvExceptions.BadRequest as e:
930 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
, KeyError) as e
:
931 self
._format
_exception
(e
)
933 def delete_flavor(self
,flavor_id
):
934 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
937 self
._reload
_connection
()
938 self
.nova
.flavors
.delete(flavor_id
)
940 #except nvExceptions.BadRequest as e:
941 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
942 self
._format
_exception
(e
)
944 def new_image(self
,image_dict
):
946 Adds a tenant image to VIM. imge_dict is a dictionary with:
948 disk_format: qcow2, vhd, vmdk, raw (by default), ...
949 location: path or URI
950 public: "yes" or "no"
951 metadata: metadata of the image
956 while retry
<max_retries
:
959 self
._reload
_connection
()
960 #determine format http://docs.openstack.org/developer/glance/formats.html
961 if "disk_format" in image_dict
:
962 disk_format
=image_dict
["disk_format"]
963 else: #autodiscover based on extension
964 if image_dict
['location'].endswith(".qcow2"):
966 elif image_dict
['location'].endswith(".vhd"):
968 elif image_dict
['location'].endswith(".vmdk"):
970 elif image_dict
['location'].endswith(".vdi"):
972 elif image_dict
['location'].endswith(".iso"):
974 elif image_dict
['location'].endswith(".aki"):
976 elif image_dict
['location'].endswith(".ari"):
978 elif image_dict
['location'].endswith(".ami"):
982 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
983 if self
.vim_type
== "VIO":
984 container_format
= "bare"
985 if 'container_format' in image_dict
:
986 container_format
= image_dict
['container_format']
987 new_image
= self
.glance
.images
.create(name
=image_dict
['name'], container_format
=container_format
,
988 disk_format
=disk_format
)
990 new_image
= self
.glance
.images
.create(name
=image_dict
['name'])
991 if image_dict
['location'].startswith("http"):
992 # TODO there is not a method to direct download. It must be downloaded locally with requests
993 raise vimconn
.vimconnNotImplemented("Cannot create image from URL")
995 with
open(image_dict
['location']) as fimage
:
996 self
.glance
.images
.upload(new_image
.id, fimage
)
997 #new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
998 # container_format="bare", data=fimage, disk_format=disk_format)
999 metadata_to_load
= image_dict
.get('metadata')
1000 # TODO location is a reserved word for current openstack versions. fixed for VIO please check for openstack
1001 if self
.vim_type
== "VIO":
1002 metadata_to_load
['upload_location'] = image_dict
['location']
1004 metadata_to_load
['location'] = image_dict
['location']
1005 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
1007 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1008 self
._format
_exception
(e
)
1009 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1010 if retry
==max_retries
:
1012 self
._format
_exception
(e
)
1013 except IOError as e
: #can not open the file
1014 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
1015 http_code
=vimconn
.HTTP_Bad_Request
)
1017 def delete_image(self
, image_id
):
1018 '''Deletes a tenant image from openstack VIM. Returns the old id
1021 self
._reload
_connection
()
1022 self
.glance
.images
.delete(image_id
)
1024 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, gl1Exceptions
.HTTPNotFound
, ConnectionError
) as e
: #TODO remove
1025 self
._format
_exception
(e
)
1027 def get_image_id_from_path(self
, path
):
1028 '''Get the image id from image path in the VIM database. Returns the image_id'''
1030 self
._reload
_connection
()
1031 images
= self
.glance
.images
.list()
1032 for image
in images
:
1033 if image
.metadata
.get("location")==path
:
1035 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
1036 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1037 self
._format
_exception
(e
)
1039 def get_image_list(self
, filter_dict
={}):
1040 '''Obtain tenant images from VIM
1044 checksum: image checksum
1045 Returns the image list of dictionaries:
1046 [{<the fields at Filter_dict plus some VIM specific>}, ...]
1049 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
1051 self
._reload
_connection
()
1052 filter_dict_os
= filter_dict
.copy()
1053 #First we filter by the available filter fields: name, id. The others are removed.
1054 image_list
= self
.glance
.images
.list()
1056 for image
in image_list
:
1058 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
1060 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
1062 if filter_dict
.get("checksum") and image
["checksum"] != filter_dict
["checksum"]:
1065 filtered_list
.append(image
.copy())
1066 except gl1Exceptions
.HTTPNotFound
:
1068 return filtered_list
1069 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
1070 self
._format
_exception
(e
)
1072 def __wait_for_vm(self
, vm_id
, status
):
1073 """wait until vm is in the desired status and return True.
1074 If the VM gets in ERROR status, return false.
1075 If the timeout is reached generate an exception"""
1077 while elapsed_time
< server_timeout
:
1078 vm_status
= self
.nova
.servers
.get(vm_id
).status
1079 if vm_status
== status
:
1081 if vm_status
== 'ERROR':
1086 # if we exceeded the timeout rollback
1087 if elapsed_time
>= server_timeout
:
1088 raise vimconn
.vimconnException('Timeout waiting for instance ' + vm_id
+ ' to get ' + status
,
1089 http_code
=vimconn
.HTTP_Request_Timeout
)
1091 def _get_openstack_availablity_zones(self
):
1093 Get from openstack availability zones available
1097 openstack_availability_zone
= self
.nova
.availability_zones
.list()
1098 openstack_availability_zone
= [str(zone
.zoneName
) for zone
in openstack_availability_zone
1099 if zone
.zoneName
!= 'internal']
1100 return openstack_availability_zone
1101 except Exception as e
:
1104 def _set_availablity_zones(self
):
1106 Set vim availablity zone
1110 if 'availability_zone' in self
.config
:
1111 vim_availability_zones
= self
.config
.get('availability_zone')
1112 if isinstance(vim_availability_zones
, str):
1113 self
.availability_zone
= [vim_availability_zones
]
1114 elif isinstance(vim_availability_zones
, list):
1115 self
.availability_zone
= vim_availability_zones
1117 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
1119 def _get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
1121 Return thge availability zone to be used by the created VM.
1122 :return: The VIM availability zone to be used or None
1124 if availability_zone_index
is None:
1125 if not self
.config
.get('availability_zone'):
1127 elif isinstance(self
.config
.get('availability_zone'), str):
1128 return self
.config
['availability_zone']
1130 # TODO consider using a different parameter at config for default AV and AV list match
1131 return self
.config
['availability_zone'][0]
1133 vim_availability_zones
= self
.availability_zone
1134 # check if VIM offer enough availability zones describe in the VNFD
1135 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
1136 # check if all the names of NFV AV match VIM AV names
1137 match_by_index
= False
1138 for av
in availability_zone_list
:
1139 if av
not in vim_availability_zones
:
1140 match_by_index
= True
1143 return vim_availability_zones
[availability_zone_index
]
1145 return availability_zone_list
[availability_zone_index
]
1147 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
1149 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
1150 availability_zone_index
=None, availability_zone_list
=None):
1151 """Adds a VM instance to VIM
1153 start: indicates if VM must start or boot in pause mode. Ignored
1154 image_id,flavor_id: iamge and flavor uuid
1155 net_list: list of interfaces, each one is a dictionary with:
1157 net_id: network uuid to connect
1158 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
1159 model: interface model, ignored #TODO
1160 mac_address: used for SR-IOV ifaces #TODO for other types
1161 use: 'data', 'bridge', 'mgmt'
1162 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
1163 vim_id: filled/added by this function
1164 floating_ip: True/False (or it can be None)
1165 'cloud_config': (optional) dictionary with:
1166 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
1167 'users': (optional) list of users to be inserted, each item is a dict with:
1168 'name': (mandatory) user name,
1169 'key-pairs': (optional) list of strings with the public key to be inserted to the user
1170 'user-data': (optional) string is a text script to be passed directly to cloud-init
1171 'config-files': (optional). List of files to be transferred. Each item is a dict with:
1172 'dest': (mandatory) string with the destination absolute path
1173 'encoding': (optional, by default text). Can be one of:
1174 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
1175 'content' (mandatory): string with the content of the file
1176 'permissions': (optional) string with file permissions, typically octal notation '0644'
1177 'owner': (optional) file owner, string with the format 'owner:group'
1178 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
1179 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
1180 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
1181 'size': (mandatory) string with the size of the disk in GB
1182 'vim_id' (optional) should use this existing volume id
1183 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
1184 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
1185 availability_zone_index is None
1186 #TODO ip, security groups
1187 Returns a tuple with the instance identifier and created_items or raises an exception on error
1188 created_items can be None or a dictionary where this method can include key-values that will be passed to
1189 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
1190 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
1193 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
1199 external_network
= [] # list of external networks to be connected to instance, later on used to create floating_ip
1200 no_secured_ports
= [] # List of port-is with port-security disabled
1201 self
._reload
_connection
()
1202 # metadata_vpci = {} # For a specific neutron plugin
1203 block_device_mapping
= None
1205 for net
in net_list
:
1206 if not net
.get("net_id"): # skip non connected iface
1210 "network_id": net
["net_id"],
1211 "name": net
.get("name"),
1212 "admin_state_up": True
1214 if self
.config
.get("security_groups") and net
.get("port_security") is not False and \
1215 not self
.config
.get("no_port_security_extension"):
1216 if not self
.security_groups_id
:
1217 self
._get
_ids
_from
_name
()
1218 port_dict
["security_groups"] = self
.security_groups_id
1220 if net
["type"]=="virtual":
1223 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1224 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1226 # if "VF" not in metadata_vpci:
1227 # metadata_vpci["VF"]=[]
1228 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1229 port_dict
["binding:vnic_type"]="direct"
1230 # VIO specific Changes
1231 if self
.vim_type
== "VIO":
1232 # Need to create port with port_security_enabled = False and no-security-groups
1233 port_dict
["port_security_enabled"]=False
1234 port_dict
["provider_security_groups"]=[]
1235 port_dict
["security_groups"]=[]
1236 else: # For PT PCI-PASSTHROUGH
1237 # VIO specific Changes
1238 # Current VIO release does not support port with type 'direct-physical'
1239 # So no need to create virtual port in case of PCI-device.
1240 # Will update port_dict code when support gets added in next VIO release
1241 if self
.vim_type
== "VIO":
1242 raise vimconn
.vimconnNotSupportedException(
1243 "Current VIO release does not support full passthrough (PT)")
1245 # if "PF" not in metadata_vpci:
1246 # metadata_vpci["PF"]=[]
1247 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1248 port_dict
["binding:vnic_type"]="direct-physical"
1249 if not port_dict
["name"]:
1250 port_dict
["name"]=name
1251 if net
.get("mac_address"):
1252 port_dict
["mac_address"]=net
["mac_address"]
1253 if net
.get("ip_address"):
1254 port_dict
["fixed_ips"] = [{'ip_address': net
["ip_address"]}]
1255 # TODO add 'subnet_id': <subnet_id>
1256 new_port
= self
.neutron
.create_port({"port": port_dict
})
1257 created_items
["port:" + str(new_port
["port"]["id"])] = True
1258 net
["mac_adress"] = new_port
["port"]["mac_address"]
1259 net
["vim_id"] = new_port
["port"]["id"]
1260 # if try to use a network without subnetwork, it will return a emtpy list
1261 fixed_ips
= new_port
["port"].get("fixed_ips")
1263 net
["ip"] = fixed_ips
[0].get("ip_address")
1267 port
= {"port-id": new_port
["port"]["id"]}
1268 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1269 port
["tag"] = new_port
["port"]["name"]
1270 net_list_vim
.append(port
)
1272 if net
.get('floating_ip', False):
1273 net
['exit_on_floating_ip_error'] = True
1274 external_network
.append(net
)
1275 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
1276 net
['exit_on_floating_ip_error'] = False
1277 external_network
.append(net
)
1278 net
['floating_ip'] = self
.config
.get('use_floating_ip')
1280 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1281 # As a workaround we wait until the VM is active and then disable the port-security
1282 if net
.get("port_security") == False and not self
.config
.get("no_port_security_extension"):
1283 no_secured_ports
.append(new_port
["port"]["id"])
1286 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1287 # if len(metadata["pci_assignement"]) >255:
1288 # #limit the metadata size
1289 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1290 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1293 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1294 name
, image_id
, flavor_id
, str(net_list_vim
), description
)
1297 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1299 # Create additional volumes in case these are present in disk_list
1300 base_disk_index
= ord('b')
1302 block_device_mapping
= {}
1303 for disk
in disk_list
:
1304 if disk
.get('vim_id'):
1305 block_device_mapping
['_vd' + chr(base_disk_index
)] = disk
['vim_id']
1307 if 'image_id' in disk
:
1308 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1309 chr(base_disk_index
), imageRef
=disk
['image_id'])
1311 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1312 chr(base_disk_index
))
1313 created_items
["volume:" + str(volume
.id)] = True
1314 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
1315 base_disk_index
+= 1
1317 # Wait until created volumes are with status available
1319 while elapsed_time
< volume_timeout
:
1320 for created_item
in created_items
:
1321 v
, _
, volume_id
= created_item
.partition(":")
1323 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
1325 else: # all ready: break from while
1329 # If we exceeded the timeout rollback
1330 if elapsed_time
>= volume_timeout
:
1331 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
1332 http_code
=vimconn
.HTTP_Request_Timeout
)
1333 # get availability Zone
1334 vm_av_zone
= self
._get
_vm
_availability
_zone
(availability_zone_index
, availability_zone_list
)
1336 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1337 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1338 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
1339 self
.config
.get("security_groups"), vm_av_zone
,
1340 self
.config
.get('keypair'), userdata
, config_drive
,
1341 block_device_mapping
))
1342 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
,
1343 security_groups
=self
.config
.get("security_groups"),
1344 # TODO remove security_groups in future versions. Already at neutron port
1345 availability_zone
=vm_av_zone
,
1346 key_name
=self
.config
.get('keypair'),
1348 config_drive
=config_drive
,
1349 block_device_mapping
=block_device_mapping
1350 ) # , description=description)
1352 vm_start_time
= time
.time()
1353 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1354 if no_secured_ports
:
1355 self
.__wait
_for
_vm
(server
.id, 'ACTIVE')
1357 for port_id
in no_secured_ports
:
1359 self
.neutron
.update_port(port_id
,
1360 {"port": {"port_security_enabled": False, "security_groups": None}})
1361 except Exception as e
:
1362 raise vimconn
.vimconnException("It was not possible to disable port security for port {}".format(
1364 # print "DONE :-)", server
1367 if external_network
:
1368 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
1369 for floating_network
in external_network
:
1374 ip
= floating_ips
.pop(0)
1375 if ip
.get("port_id", False) or ip
.get('tenant_id') != server
.tenant_id
:
1377 if isinstance(floating_network
['floating_ip'], str):
1378 if ip
.get("floating_network_id") != floating_network
['floating_ip']:
1380 free_floating_ip
= ip
["id"]
1382 if isinstance(floating_network
['floating_ip'], str) and \
1383 floating_network
['floating_ip'].lower() != "true":
1384 pool_id
= floating_network
['floating_ip']
1386 # Find the external network
1387 external_nets
= list()
1388 for net
in self
.neutron
.list_networks()['networks']:
1389 if net
['router:external']:
1390 external_nets
.append(net
)
1392 if len(external_nets
) == 0:
1393 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
1394 "network is present",
1395 http_code
=vimconn
.HTTP_Conflict
)
1396 if len(external_nets
) > 1:
1397 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
1398 "external networks are present",
1399 http_code
=vimconn
.HTTP_Conflict
)
1401 pool_id
= external_nets
[0].get('id')
1402 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
1404 # self.logger.debug("Creating floating IP")
1405 new_floating_ip
= self
.neutron
.create_floatingip(param
)
1406 free_floating_ip
= new_floating_ip
['floatingip']['id']
1407 except Exception as e
:
1408 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create new floating_ip " +
1409 str(e
), http_code
=vimconn
.HTTP_Conflict
)
1413 # the vim_id key contains the neutron.port_id
1414 self
.neutron
.update_floatingip(free_floating_ip
,
1415 {"floatingip": {"port_id": floating_network
["vim_id"]}})
1416 # Using nove is deprecated on nova client 10.0
1418 except Exception as e
:
1419 # openstack need some time after VM creation to asign an IP. So retry if fails
1420 vm_status
= self
.nova
.servers
.get(server
.id).status
1421 if vm_status
!= 'ACTIVE' and vm_status
!= 'ERROR':
1422 if time
.time() - vm_start_time
< server_timeout
:
1425 raise vimconn
.vimconnException(
1426 "Cannot create floating_ip: {} {}".format(type(e
).__name
__, e
),
1427 http_code
=vimconn
.HTTP_Conflict
)
1429 except Exception as e
:
1430 if not floating_network
['exit_on_floating_ip_error']:
1431 self
.logger
.warning("Cannot create floating_ip. %s", str(e
))
1435 return server
.id, created_items
1436 # except nvExceptions.NotFound as e:
1437 # error_value=-vimconn.HTTP_Not_Found
1438 # error_text= "vm instance %s not found" % vm_id
1439 # except TypeError as e:
1440 # raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
1442 except Exception as e
:
1445 server_id
= server
.id
1447 self
.delete_vminstance(server_id
, created_items
)
1448 except Exception as e2
:
1449 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
1451 self
._format
_exception
(e
)
1453 def get_vminstance(self
,vm_id
):
1454 '''Returns the VM instance information from VIM'''
1455 #self.logger.debug("Getting VM from VIM")
1457 self
._reload
_connection
()
1458 server
= self
.nova
.servers
.find(id=vm_id
)
1459 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1460 return server
.to_dict()
1461 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1462 self
._format
_exception
(e
)
1464 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1466 Get a console for the virtual machine
1468 vm_id: uuid of the VM
1469 console_type, can be:
1470 "novnc" (by default), "xvpvnc" for VNC types,
1471 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1472 Returns dict with the console parameters:
1473 protocol: ssh, ftp, http, https, ...
1474 server: usually ip address
1475 port: the http, ssh, ... port
1476 suffix: extra text, e.g. the http path and query string
1478 self
.logger
.debug("Getting VM CONSOLE from VIM")
1480 self
._reload
_connection
()
1481 server
= self
.nova
.servers
.find(id=vm_id
)
1482 if console_type
== None or console_type
== "novnc":
1483 console_dict
= server
.get_vnc_console("novnc")
1484 elif console_type
== "xvpvnc":
1485 console_dict
= server
.get_vnc_console(console_type
)
1486 elif console_type
== "rdp-html5":
1487 console_dict
= server
.get_rdp_console(console_type
)
1488 elif console_type
== "spice-html5":
1489 console_dict
= server
.get_spice_console(console_type
)
1491 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1493 console_dict1
= console_dict
.get("console")
1495 console_url
= console_dict1
.get("url")
1498 protocol_index
= console_url
.find("//")
1499 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1500 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1501 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1502 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1503 console_dict
={"protocol": console_url
[0:protocol_index
],
1504 "server": console_url
[protocol_index
+2:port_index
],
1505 "port": console_url
[port_index
:suffix_index
],
1506 "suffix": console_url
[suffix_index
+1:]
1510 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1512 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1513 self
._format
_exception
(e
)
1515 def delete_vminstance(self
, vm_id
, created_items
=None):
1516 '''Removes a VM instance from VIM. Returns the old identifier
1518 #print "osconnector: Getting VM from VIM"
1519 if created_items
== None:
1522 self
._reload
_connection
()
1523 # delete VM ports attached to this networks before the virtual machine
1524 for k
, v
in created_items
.items():
1525 if not v
: # skip already deleted
1528 k_item
, _
, k_id
= k
.partition(":")
1529 if k_item
== "port":
1530 self
.neutron
.delete_port(k_id
)
1531 except Exception as e
:
1532 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
1534 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1535 # #dettach volumes attached
1536 # server = self.nova.servers.get(vm_id)
1537 # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
1538 # #for volume in volumes_attached_dict:
1539 # # self.cinder.volumes.detach(volume['id'])
1542 self
.nova
.servers
.delete(vm_id
)
1544 # delete volumes. Although having detached, they should have in active status before deleting
1545 # we ensure in this loop
1548 while keep_waiting
and elapsed_time
< volume_timeout
:
1549 keep_waiting
= False
1550 for k
, v
in created_items
.items():
1551 if not v
: # skip already deleted
1554 k_item
, _
, k_id
= k
.partition(":")
1555 if k_item
== "volume":
1556 if self
.cinder
.volumes
.get(k_id
).status
!= 'available':
1559 self
.cinder
.volumes
.delete(k_id
)
1560 except Exception as e
:
1561 self
.logger
.error("Error deleting volume: {}: {}".format(type(e
).__name
__, e
))
1566 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1567 self
._format
_exception
(e
)
1569 def refresh_vms_status(self
, vm_list
):
1570 '''Get the status of the virtual machines and their interfaces/ports
1571 Params: the list of VM identifiers
1572 Returns a dictionary with:
1573 vm_id: #VIM id of this Virtual Machine
1574 status: #Mandatory. Text with one of:
1575 # DELETED (not found at vim)
1576 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1577 # OTHER (Vim reported other status not understood)
1578 # ERROR (VIM indicates an ERROR status)
1579 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1580 # CREATING (on building process), ERROR
1581 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1583 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1584 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1586 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1587 mac_address: #Text format XX:XX:XX:XX:XX:XX
1588 vim_net_id: #network id where this interface is connected
1589 vim_interface_id: #interface/port VIM id
1590 ip_address: #null, or text with IPv4, IPv6 address
1591 compute_node: #identification of compute node where PF,VF interface is allocated
1592 pci: #PCI address of the NIC that hosts the PF,VF
1593 vlan: #physical VLAN used for VF
1596 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1597 for vm_id
in vm_list
:
1600 vm_vim
= self
.get_vminstance(vm_id
)
1601 if vm_vim
['status'] in vmStatus2manoFormat
:
1602 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1604 vm
['status'] = "OTHER"
1605 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1607 vm
['vim_info'] = self
.serialize(vm_vim
)
1609 vm
["interfaces"] = []
1610 if vm_vim
.get('fault'):
1611 vm
['error_msg'] = str(vm_vim
['fault'])
1614 self
._reload
_connection
()
1615 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
1616 for port
in port_dict
["ports"]:
1618 interface
['vim_info'] = self
.serialize(port
)
1619 interface
["mac_address"] = port
.get("mac_address")
1620 interface
["vim_net_id"] = port
["network_id"]
1621 interface
["vim_interface_id"] = port
["id"]
1622 # check if OS-EXT-SRV-ATTR:host is there,
1623 # in case of non-admin credentials, it will be missing
1624 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1625 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1626 interface
["pci"] = None
1628 # check if binding:profile is there,
1629 # in case of non-admin credentials, it will be missing
1630 if port
.get('binding:profile'):
1631 if port
['binding:profile'].get('pci_slot'):
1632 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1633 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1634 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1635 pci
= port
['binding:profile']['pci_slot']
1636 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1637 interface
["pci"] = pci
1638 interface
["vlan"] = None
1639 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1640 network
= self
.neutron
.show_network(port
["network_id"])
1641 if network
['network'].get('provider:network_type') == 'vlan' and \
1642 port
.get("binding:vnic_type") == "direct":
1643 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1645 #look for floating ip address
1647 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1648 if floating_ip_dict
.get("floatingips"):
1649 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1653 for subnet
in port
["fixed_ips"]:
1654 ips
.append(subnet
["ip_address"])
1655 interface
["ip_address"] = ";".join(ips
)
1656 vm
["interfaces"].append(interface
)
1657 except Exception as e
:
1658 self
.logger
.error("Error getting vm interface information {}: {}".format(type(e
).__name
__, e
),
1660 except vimconn
.vimconnNotFoundException
as e
:
1661 self
.logger
.error("Exception getting vm status: %s", str(e
))
1662 vm
['status'] = "DELETED"
1663 vm
['error_msg'] = str(e
)
1664 except vimconn
.vimconnException
as e
:
1665 self
.logger
.error("Exception getting vm status: %s", str(e
))
1666 vm
['status'] = "VIM_ERROR"
1667 vm
['error_msg'] = str(e
)
1671 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1672 '''Send and action over a VM instance from VIM
1673 Returns None or the console dict if the action was successfully sent to the VIM'''
1674 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1676 self
._reload
_connection
()
1677 server
= self
.nova
.servers
.find(id=vm_id
)
1678 if "start" in action_dict
:
1679 if action_dict
["start"]=="rebuild":
1682 if server
.status
=="PAUSED":
1684 elif server
.status
=="SUSPENDED":
1686 elif server
.status
=="SHUTOFF":
1688 elif "pause" in action_dict
:
1690 elif "resume" in action_dict
:
1692 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1694 elif "forceOff" in action_dict
:
1696 elif "terminate" in action_dict
:
1698 elif "createImage" in action_dict
:
1699 server
.create_image()
1700 #"path":path_schema,
1701 #"description":description_schema,
1702 #"name":name_schema,
1703 #"metadata":metadata_schema,
1704 #"imageRef": id_schema,
1705 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1706 elif "rebuild" in action_dict
:
1707 server
.rebuild(server
.image
['id'])
1708 elif "reboot" in action_dict
:
1709 server
.reboot() #reboot_type='SOFT'
1710 elif "console" in action_dict
:
1711 console_type
= action_dict
["console"]
1712 if console_type
== None or console_type
== "novnc":
1713 console_dict
= server
.get_vnc_console("novnc")
1714 elif console_type
== "xvpvnc":
1715 console_dict
= server
.get_vnc_console(console_type
)
1716 elif console_type
== "rdp-html5":
1717 console_dict
= server
.get_rdp_console(console_type
)
1718 elif console_type
== "spice-html5":
1719 console_dict
= server
.get_spice_console(console_type
)
1721 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1722 http_code
=vimconn
.HTTP_Bad_Request
)
1724 console_url
= console_dict
["console"]["url"]
1726 protocol_index
= console_url
.find("//")
1727 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1728 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1729 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1730 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1731 console_dict2
={"protocol": console_url
[0:protocol_index
],
1732 "server": console_url
[protocol_index
+2 : port_index
],
1733 "port": int(console_url
[port_index
+1 : suffix_index
]),
1734 "suffix": console_url
[suffix_index
+1:]
1736 return console_dict2
1737 except Exception as e
:
1738 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1741 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1742 self
._format
_exception
(e
)
1743 #TODO insert exception vimconn.HTTP_Unauthorized
1745 ####### VIO Specific Changes #########
1746 def _generate_vlanID(self
):
1748 Method to get unused vlanID
1756 networks
= self
.get_network_list()
1757 for net
in networks
:
1758 if net
.get('provider:segmentation_id'):
1759 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1760 used_vlanIDs
= set(usedVlanIDs
)
1762 #find unused VLAN ID
1763 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1765 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1766 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
1767 if vlanID
not in used_vlanIDs
:
1769 except Exception as exp
:
1770 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1772 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1773 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1776 def _generate_multisegment_vlanID(self
):
1778 Method to get unused vlanID
1786 networks
= self
.get_network_list()
1787 for net
in networks
:
1788 if net
.get('provider:network_type') == "vlan" and net
.get('provider:segmentation_id'):
1789 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1790 elif net
.get('segments'):
1791 for segment
in net
.get('segments'):
1792 if segment
.get('provider:network_type') == "vlan" and segment
.get('provider:segmentation_id'):
1793 usedVlanIDs
.append(segment
.get('provider:segmentation_id'))
1794 used_vlanIDs
= set(usedVlanIDs
)
1796 #find unused VLAN ID
1797 for vlanID_range
in self
.config
.get('multisegment_vlan_range'):
1799 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1800 for vlanID
in range(start_vlanid
, end_vlanid
+ 1):
1801 if vlanID
not in used_vlanIDs
:
1803 except Exception as exp
:
1804 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1806 raise vimconn
.vimconnConflictException("Unable to create the VLAN segment."\
1807 " All VLAN IDs {} are in use.".format(self
.config
.get('multisegment_vlan_range')))
1810 def _validate_vlan_ranges(self
, input_vlan_range
, text_vlan_range
):
1812 Method to validate user given vlanID ranges
1816 for vlanID_range
in input_vlan_range
:
1817 vlan_range
= vlanID_range
.replace(" ", "")
1819 vlanID_pattern
= r
'(\d)*-(\d)*$'
1820 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1822 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}.You must provide "\
1823 "'{}' in format [start_ID - end_ID].".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1825 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1826 if start_vlanid
<= 0 :
1827 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1828 "Start ID can not be zero. For VLAN "\
1829 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1830 if end_vlanid
> 4094 :
1831 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1832 "End VLAN ID can not be greater than 4094. For VLAN "\
1833 "networks valid IDs are 1 to 4094 ".format(text_vlan_range
, vlanID_range
))
1835 if start_vlanid
> end_vlanid
:
1836 raise vimconn
.vimconnConflictException("Invalid VLAN range for {}: {}."\
1837 "You must provide '{}' in format start_ID - end_ID and "\
1838 "start_ID < end_ID ".format(text_vlan_range
, vlanID_range
, text_vlan_range
))
1842 def new_external_port(self
, port_data
):
1843 #TODO openstack if needed
1844 '''Adds a external port to VIM'''
1845 '''Returns the port identifier'''
1846 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1848 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1849 #TODO openstack if needed
1850 '''Connects a external port to a network'''
1851 '''Returns status code of the VIM response'''
1852 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1854 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1855 '''Adds a new user to openstack VIM'''
1856 '''Returns the user identifier'''
1857 self
.logger
.debug("osconnector: Adding a new user to VIM")
1859 self
._reload
_connection
()
1860 user
=self
.keystone
.users
.create(user_name
, password
=user_passwd
, default_project
=tenant_id
)
1861 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1863 except ksExceptions
.ConnectionError
as e
:
1864 error_value
=-vimconn
.HTTP_Bad_Request
1865 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1866 except ksExceptions
.ClientException
as e
: #TODO remove
1867 error_value
=-vimconn
.HTTP_Bad_Request
1868 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1869 #TODO insert exception vimconn.HTTP_Unauthorized
1870 #if reaching here is because an exception
1871 self
.logger
.debug("new_user " + error_text
)
1872 return error_value
, error_text
1874 def delete_user(self
, user_id
):
1875 '''Delete a user from openstack VIM'''
1876 '''Returns the user identifier'''
1878 print("osconnector: Deleting a user from VIM")
1880 self
._reload
_connection
()
1881 self
.keystone
.users
.delete(user_id
)
1883 except ksExceptions
.ConnectionError
as e
:
1884 error_value
=-vimconn
.HTTP_Bad_Request
1885 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1886 except ksExceptions
.NotFound
as e
:
1887 error_value
=-vimconn
.HTTP_Not_Found
1888 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1889 except ksExceptions
.ClientException
as e
: #TODO remove
1890 error_value
=-vimconn
.HTTP_Bad_Request
1891 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1892 #TODO insert exception vimconn.HTTP_Unauthorized
1893 #if reaching here is because an exception
1894 self
.logger
.debug("delete_tenant " + error_text
)
1895 return error_value
, error_text
1897 def get_hosts_info(self
):
1898 '''Get the information of deployed hosts
1899 Returns the hosts content'''
1901 print("osconnector: Getting Host info from VIM")
1904 self
._reload
_connection
()
1905 hypervisors
= self
.nova
.hypervisors
.list()
1906 for hype
in hypervisors
:
1907 h_list
.append( hype
.to_dict() )
1908 return 1, {"hosts":h_list
}
1909 except nvExceptions
.NotFound
as e
:
1910 error_value
=-vimconn
.HTTP_Not_Found
1911 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1912 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1913 error_value
=-vimconn
.HTTP_Bad_Request
1914 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1915 #TODO insert exception vimconn.HTTP_Unauthorized
1916 #if reaching here is because an exception
1917 self
.logger
.debug("get_hosts_info " + error_text
)
1918 return error_value
, error_text
1920 def get_hosts(self
, vim_tenant
):
1921 '''Get the hosts and deployed instances
1922 Returns the hosts content'''
1923 r
, hype_dict
= self
.get_hosts_info()
1926 hypervisors
= hype_dict
["hosts"]
1928 servers
= self
.nova
.servers
.list()
1929 for hype
in hypervisors
:
1930 for server
in servers
:
1931 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1933 hype
['vm'].append(server
.id)
1935 hype
['vm'] = [server
.id]
1937 except nvExceptions
.NotFound
as e
:
1938 error_value
=-vimconn
.HTTP_Not_Found
1939 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1940 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1941 error_value
=-vimconn
.HTTP_Bad_Request
1942 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1943 #TODO insert exception vimconn.HTTP_Unauthorized
1944 #if reaching here is because an exception
1945 self
.logger
.debug("get_hosts " + error_text
)
1946 return error_value
, error_text
1948 def new_classification(self
, name
, ctype
, definition
):
1949 self
.logger
.debug('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):
2016 self
.logger
.debug("Adding a new Service Function Instance to VIM, named '%s'", name
)
2019 self
._reload
_connection
()
2023 if len(ingress_ports
) != 1:
2024 raise vimconn
.vimconnNotSupportedException(
2025 "OpenStack VIM connector can only have "
2026 "1 ingress port per SFI")
2027 if len(egress_ports
) != 1:
2028 raise vimconn
.vimconnNotSupportedException(
2029 "OpenStack VIM connector can only have "
2030 "1 egress port per SFI")
2031 sfi_dict
= {'name': name
,
2032 'ingress': ingress_ports
[0],
2033 'egress': egress_ports
[0],
2034 'service_function_parameters': {
2035 'correlation': correlation
}}
2036 new_sfi
= self
.neutron
.create_sfc_port_pair({'port_pair': sfi_dict
})
2037 return new_sfi
['port_pair']['id']
2038 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2039 neExceptions
.NeutronException
, ConnectionError
) as e
:
2042 self
.neutron
.delete_sfc_port_pair(
2043 new_sfi
['port_pair']['id'])
2046 'Creation of Service Function Instance failed, with '
2047 'subsequent deletion failure as well.')
2048 self
._format
_exception
(e
)
2050 def get_sfi(self
, sfi_id
):
2051 self
.logger
.debug('Getting Service Function Instance %s from VIM', sfi_id
)
2052 filter_dict
= {"id": sfi_id
}
2053 sfi_list
= self
.get_sfi_list(filter_dict
)
2054 if len(sfi_list
) == 0:
2055 raise vimconn
.vimconnNotFoundException("Service Function Instance '{}' not found".format(sfi_id
))
2056 elif len(sfi_list
) > 1:
2057 raise vimconn
.vimconnConflictException(
2058 'Found more than one Service Function Instance '
2059 'with this criteria')
2063 def get_sfi_list(self
, filter_dict
={}):
2064 self
.logger
.debug("Getting Service Function Instances from VIM filter: '%s'", str(filter_dict
))
2066 self
._reload
_connection
()
2067 filter_dict_os
= filter_dict
.copy()
2068 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2069 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2070 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
2071 sfi_list
= sfi_dict
["port_pairs"]
2072 self
.__sfi
_os
2mano
(sfi_list
)
2074 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2075 neExceptions
.NeutronException
, ConnectionError
) as e
:
2076 self
._format
_exception
(e
)
2078 def delete_sfi(self
, sfi_id
):
2079 self
.logger
.debug("Deleting Service Function Instance '%s' "
2082 self
._reload
_connection
()
2083 self
.neutron
.delete_sfc_port_pair(sfi_id
)
2085 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2086 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2087 ConnectionError
) as e
:
2088 self
._format
_exception
(e
)
2090 def new_sf(self
, name
, sfis
, sfc_encap
=True):
2091 self
.logger
.debug("Adding a new Service Function to VIM, named '%s'", name
)
2094 self
._reload
_connection
()
2095 # correlation = None
2097 # correlation = 'nsh'
2098 for instance
in sfis
:
2099 sfi
= self
.get_sfi(instance
)
2100 if sfi
.get('sfc_encap') != sfc_encap
:
2101 raise vimconn
.vimconnNotSupportedException(
2102 "OpenStack VIM connector requires all SFIs of the "
2103 "same SF to share the same SFC Encapsulation")
2104 sf_dict
= {'name': name
,
2106 new_sf
= self
.neutron
.create_sfc_port_pair_group({
2107 'port_pair_group': sf_dict
})
2108 return new_sf
['port_pair_group']['id']
2109 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2110 neExceptions
.NeutronException
, ConnectionError
) as e
:
2113 self
.neutron
.delete_sfc_port_pair_group(
2114 new_sf
['port_pair_group']['id'])
2117 'Creation of Service Function failed, with '
2118 'subsequent deletion failure as well.')
2119 self
._format
_exception
(e
)
2121 def get_sf(self
, sf_id
):
2122 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
2123 filter_dict
= {"id": sf_id
}
2124 sf_list
= self
.get_sf_list(filter_dict
)
2125 if len(sf_list
) == 0:
2126 raise vimconn
.vimconnNotFoundException(
2127 "Service Function '{}' not found".format(sf_id
))
2128 elif len(sf_list
) > 1:
2129 raise vimconn
.vimconnConflictException(
2130 "Found more than one Service Function with this criteria")
2134 def get_sf_list(self
, filter_dict
={}):
2135 self
.logger
.debug("Getting Service Function from VIM filter: '%s'",
2138 self
._reload
_connection
()
2139 filter_dict_os
= filter_dict
.copy()
2140 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2141 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2142 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
2143 sf_list
= sf_dict
["port_pair_groups"]
2144 self
.__sf
_os
2mano
(sf_list
)
2146 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2147 neExceptions
.NeutronException
, ConnectionError
) as e
:
2148 self
._format
_exception
(e
)
2150 def delete_sf(self
, sf_id
):
2151 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
2153 self
._reload
_connection
()
2154 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
2156 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2157 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2158 ConnectionError
) as e
:
2159 self
._format
_exception
(e
)
2161 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
2162 self
.logger
.debug("Adding a new Service Function Path to VIM, named '%s'", name
)
2165 self
._reload
_connection
()
2166 # In networking-sfc the MPLS encapsulation is legacy
2167 # should be used when no full SFC Encapsulation is intended
2168 correlation
= 'mpls'
2171 sfp_dict
= {'name': name
,
2172 'flow_classifiers': classifications
,
2173 'port_pair_groups': sfs
,
2174 'chain_parameters': {'correlation': correlation
}}
2176 sfp_dict
['chain_id'] = spi
2177 new_sfp
= self
.neutron
.create_sfc_port_chain({'port_chain': sfp_dict
})
2178 return new_sfp
["port_chain"]["id"]
2179 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2180 neExceptions
.NeutronException
, ConnectionError
) as e
:
2183 self
.neutron
.delete_sfc_port_chain(new_sfp
['port_chain']['id'])
2186 'Creation of Service Function Path failed, with '
2187 'subsequent deletion failure as well.')
2188 self
._format
_exception
(e
)
2190 def get_sfp(self
, sfp_id
):
2191 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
2192 filter_dict
= {"id": sfp_id
}
2193 sfp_list
= self
.get_sfp_list(filter_dict
)
2194 if len(sfp_list
) == 0:
2195 raise vimconn
.vimconnNotFoundException(
2196 "Service Function Path '{}' not found".format(sfp_id
))
2197 elif len(sfp_list
) > 1:
2198 raise vimconn
.vimconnConflictException(
2199 "Found more than one Service Function Path with this criteria")
2203 def get_sfp_list(self
, filter_dict
={}):
2204 self
.logger
.debug("Getting Service Function Paths from VIM filter: '%s'", str(filter_dict
))
2206 self
._reload
_connection
()
2207 filter_dict_os
= filter_dict
.copy()
2208 if self
.api_version3
and "tenant_id" in filter_dict_os
:
2209 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
2210 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
2211 sfp_list
= sfp_dict
["port_chains"]
2212 self
.__sfp
_os
2mano
(sfp_list
)
2214 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
2215 neExceptions
.NeutronException
, ConnectionError
) as e
:
2216 self
._format
_exception
(e
)
2218 def delete_sfp(self
, sfp_id
):
2219 self
.logger
.debug("Deleting Service Function Path '%s' from VIM", sfp_id
)
2221 self
._reload
_connection
()
2222 self
.neutron
.delete_sfc_port_chain(sfp_id
)
2224 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
2225 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
2226 ConnectionError
) as e
:
2227 self
._format
_exception
(e
)