1 # -*- coding: utf-8 -*-
4 # Copyright 2015 Telefónica Investigación 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."
36 __date__
= "$22-sep-2017 23:59:59$"
48 from novaclient
import client
as nClient
, exceptions
as nvExceptions
49 from keystoneauth1
.identity
import v2
, v3
50 from keystoneauth1
import session
51 import keystoneclient
.exceptions
as ksExceptions
52 import keystoneclient
.v3
.client
as ksClient_v3
53 import keystoneclient
.v2_0
.client
as ksClient_v2
54 from glanceclient
import client
as glClient
55 import glanceclient
.client
as gl1Client
56 import glanceclient
.exc
as gl1Exceptions
57 from cinderclient
import client
as cClient
58 from httplib
import HTTPException
59 from neutronclient
.neutron
import client
as neClient
60 from neutronclient
.common
import exceptions
as neExceptions
61 from requests
.exceptions
import ConnectionError
64 """contain the openstack virtual machine status to openmano status"""
65 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
67 'SUSPENDED': 'SUSPENDED',
70 'ERROR':'ERROR','DELETED':'DELETED'
72 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
75 supportedClassificationTypes
= ['legacy_flow_classifier']
77 #global var to have a timeout creating and deleting volumes
81 class vimconnector(vimconn
.vimconnector
):
82 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
83 log_level
=None, config
={}, persistent_info
={}):
84 '''using common constructor parameters. In this case
85 'url' is the keystone authorization url,
86 'url_admin' is not use
88 api_version
= config
.get('APIversion')
89 if api_version
and api_version
not in ('v3.3', 'v2.0', '2', '3'):
90 raise vimconn
.vimconnException("Invalid value '{}' for config:APIversion. "
91 "Allowed values are 'v3.3', 'v2.0', '2' or '3'".format(api_version
))
92 vim_type
= config
.get('vim_type')
93 if vim_type
and vim_type
not in ('vio', 'VIO'):
94 raise vimconn
.vimconnException("Invalid value '{}' for config:vim_type."
95 "Allowed values are 'vio' or 'VIO'".format(vim_type
))
97 if config
.get('dataplane_net_vlan_range') is not None:
98 #validate vlan ranges provided by user
99 self
._validate
_vlan
_ranges
(config
.get('dataplane_net_vlan_range'))
101 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
,
104 if self
.config
.get("insecure") and self
.config
.get("ca_cert"):
105 raise vimconn
.vimconnException("options insecure and ca_cert are mutually exclusive")
107 if self
.config
.get("insecure"):
109 if self
.config
.get("ca_cert"):
110 self
.verify
= self
.config
.get("ca_cert")
111 self
.verify
= self
.config
.get("insecure", False)
114 raise TypeError('url param can not be NoneType')
115 self
.persistent_info
= persistent_info
116 self
.availability_zone
= persistent_info
.get('availability_zone', None)
117 self
.session
= persistent_info
.get('session', {'reload_client': True})
118 self
.nova
= self
.session
.get('nova')
119 self
.neutron
= self
.session
.get('neutron')
120 self
.cinder
= self
.session
.get('cinder')
121 self
.glance
= self
.session
.get('glance')
122 self
.glancev1
= self
.session
.get('glancev1')
123 self
.keystone
= self
.session
.get('keystone')
124 self
.api_version3
= self
.session
.get('api_version3')
125 self
.vim_type
= self
.config
.get("vim_type")
127 self
.vim_type
= self
.vim_type
.upper()
128 if self
.config
.get("use_internal_endpoint"):
129 self
.endpoint_type
= "internalURL"
131 self
.endpoint_type
= None
133 self
.logger
= logging
.getLogger('openmano.vim.openstack')
135 ####### VIO Specific Changes #########
136 if self
.vim_type
== "VIO":
137 self
.logger
= logging
.getLogger('openmano.vim.vio')
140 self
.logger
.setLevel( getattr(logging
, log_level
))
142 def __getitem__(self
, index
):
143 """Get individuals parameters.
145 if index
== 'project_domain_id':
146 return self
.config
.get("project_domain_id")
147 elif index
== 'user_domain_id':
148 return self
.config
.get("user_domain_id")
150 return vimconn
.vimconnector
.__getitem
__(self
, index
)
152 def __setitem__(self
, index
, value
):
153 """Set individuals parameters and it is marked as dirty so to force connection reload.
155 if index
== 'project_domain_id':
156 self
.config
["project_domain_id"] = value
157 elif index
== 'user_domain_id':
158 self
.config
["user_domain_id"] = value
160 vimconn
.vimconnector
.__setitem
__(self
, index
, value
)
161 self
.session
['reload_client'] = True
163 def _reload_connection(self
):
164 '''Called before any operation, it check if credentials has changed
165 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
167 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
168 if self
.session
['reload_client']:
169 if self
.config
.get('APIversion'):
170 self
.api_version3
= self
.config
['APIversion'] == 'v3.3' or self
.config
['APIversion'] == '3'
171 else: # get from ending auth_url that end with v3 or with v2.0
172 self
.api_version3
= self
.url
.endswith("/v3") or self
.url
.endswith("/v3/")
173 self
.session
['api_version3'] = self
.api_version3
174 if self
.api_version3
:
175 if self
.config
.get('project_domain_id') or self
.config
.get('project_domain_name'):
176 project_domain_id_default
= None
178 project_domain_id_default
= 'default'
179 if self
.config
.get('user_domain_id') or self
.config
.get('user_domain_name'):
180 user_domain_id_default
= None
182 user_domain_id_default
= 'default'
183 auth
= v3
.Password(auth_url
=self
.url
,
185 password
=self
.passwd
,
186 project_name
=self
.tenant_name
,
187 project_id
=self
.tenant_id
,
188 project_domain_id
=self
.config
.get('project_domain_id', project_domain_id_default
),
189 user_domain_id
=self
.config
.get('user_domain_id', user_domain_id_default
),
190 project_domain_name
=self
.config
.get('project_domain_name'),
191 user_domain_name
=self
.config
.get('user_domain_name'))
193 auth
= v2
.Password(auth_url
=self
.url
,
195 password
=self
.passwd
,
196 tenant_name
=self
.tenant_name
,
197 tenant_id
=self
.tenant_id
)
198 sess
= session
.Session(auth
=auth
, verify
=self
.verify
)
199 if self
.api_version3
:
200 self
.keystone
= ksClient_v3
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
202 self
.keystone
= ksClient_v2
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
203 self
.session
['keystone'] = self
.keystone
204 # In order to enable microversion functionality an explicit microversion must be specified in 'config'.
205 # This implementation approach is due to the warning message in
206 # https://developer.openstack.org/api-guide/compute/microversions.html
207 # where it is stated that microversion backwards compatibility is not guaranteed and clients should
208 # always require an specific microversion.
209 # To be able to use 'device role tagging' functionality define 'microversion: 2.32' in datacenter config
210 version
= self
.config
.get("microversion")
213 self
.nova
= self
.session
['nova'] = nClient
.Client(str(version
), session
=sess
, endpoint_type
=self
.endpoint_type
)
214 self
.neutron
= self
.session
['neutron'] = neClient
.Client('2.0', session
=sess
, endpoint_type
=self
.endpoint_type
)
215 self
.cinder
= self
.session
['cinder'] = cClient
.Client(2, session
=sess
, endpoint_type
=self
.endpoint_type
)
216 if self
.endpoint_type
== "internalURL":
217 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
218 glance_endpoint
= self
.keystone
.endpoints
.list(glance_service_id
, interface
="internal")[0].url
220 glance_endpoint
= None
221 self
.glance
= self
.session
['glance'] = glClient
.Client(2, session
=sess
, endpoint
=glance_endpoint
)
222 #using version 1 of glance client in new_image()
223 self
.glancev1
= self
.session
['glancev1'] = glClient
.Client('1', session
=sess
,
224 endpoint
=glance_endpoint
)
225 self
.session
['reload_client'] = False
226 self
.persistent_info
['session'] = self
.session
227 # add availablity zone info inside self.persistent_info
228 self
._set
_availablity
_zones
()
229 self
.persistent_info
['availability_zone'] = self
.availability_zone
231 def __net_os2mano(self
, net_list_dict
):
232 '''Transform the net openstack format to mano format
233 net_list_dict can be a list of dict or a single dict'''
234 if type(net_list_dict
) is dict:
235 net_list_
=(net_list_dict
,)
236 elif type(net_list_dict
) is list:
237 net_list_
=net_list_dict
239 raise TypeError("param net_list_dict must be a list or a dictionary")
240 for net
in net_list_
:
241 if net
.get('provider:network_type') == "vlan":
246 def __classification_os2mano(self
, class_list_dict
):
247 """Transform the openstack format (Flow Classifier) to mano format
248 (Classification) class_list_dict can be a list of dict or a single dict
250 if isinstance(class_list_dict
, dict):
251 class_list_
= [class_list_dict
]
252 elif isinstance(class_list_dict
, list):
253 class_list_
= class_list_dict
256 "param class_list_dict must be a list or a dictionary")
257 for classification
in class_list_
:
258 id = classification
.pop('id')
259 name
= classification
.pop('name')
260 description
= classification
.pop('description')
261 project_id
= classification
.pop('project_id')
262 tenant_id
= classification
.pop('tenant_id')
263 original_classification
= copy
.deepcopy(classification
)
264 classification
.clear()
265 classification
['ctype'] = 'legacy_flow_classifier'
266 classification
['definition'] = original_classification
267 classification
['id'] = id
268 classification
['name'] = name
269 classification
['description'] = description
270 classification
['project_id'] = project_id
271 classification
['tenant_id'] = tenant_id
273 def __sfi_os2mano(self
, sfi_list_dict
):
274 """Transform the openstack format (Port Pair) to mano format (SFI)
275 sfi_list_dict can be a list of dict or a single dict
277 if isinstance(sfi_list_dict
, dict):
278 sfi_list_
= [sfi_list_dict
]
279 elif isinstance(sfi_list_dict
, list):
280 sfi_list_
= sfi_list_dict
283 "param sfi_list_dict must be a list or a dictionary")
284 for sfi
in sfi_list_
:
285 sfi
['ingress_ports'] = []
286 sfi
['egress_ports'] = []
287 if sfi
.get('ingress'):
288 sfi
['ingress_ports'].append(sfi
['ingress'])
289 if sfi
.get('egress'):
290 sfi
['egress_ports'].append(sfi
['egress'])
293 params
= sfi
.get('service_function_parameters')
296 correlation
= params
.get('correlation')
299 sfi
['sfc_encap'] = sfc_encap
300 del sfi
['service_function_parameters']
302 def __sf_os2mano(self
, sf_list_dict
):
303 """Transform the openstack format (Port Pair Group) to mano format (SF)
304 sf_list_dict can be a list of dict or a single dict
306 if isinstance(sf_list_dict
, dict):
307 sf_list_
= [sf_list_dict
]
308 elif isinstance(sf_list_dict
, list):
309 sf_list_
= sf_list_dict
312 "param sf_list_dict must be a list or a dictionary")
314 del sf
['port_pair_group_parameters']
315 sf
['sfis'] = sf
['port_pairs']
318 def __sfp_os2mano(self
, sfp_list_dict
):
319 """Transform the openstack format (Port Chain) to mano format (SFP)
320 sfp_list_dict can be a list of dict or a single dict
322 if isinstance(sfp_list_dict
, dict):
323 sfp_list_
= [sfp_list_dict
]
324 elif isinstance(sfp_list_dict
, list):
325 sfp_list_
= sfp_list_dict
328 "param sfp_list_dict must be a list or a dictionary")
329 for sfp
in sfp_list_
:
330 params
= sfp
.pop('chain_parameters')
333 correlation
= params
.get('correlation')
336 sfp
['sfc_encap'] = sfc_encap
337 sfp
['spi'] = sfp
.pop('chain_id')
338 sfp
['classifications'] = sfp
.pop('flow_classifiers')
339 sfp
['service_functions'] = sfp
.pop('port_pair_groups')
341 # placeholder for now; read TODO note below
342 def _validate_classification(self
, type, definition
):
343 # only legacy_flow_classifier Type is supported at this point
345 # TODO(igordcard): this method should be an abstract method of an
346 # abstract Classification class to be implemented by the specific
347 # Types. Also, abstract vimconnector should call the validation
348 # method before the implemented VIM connectors are called.
350 def _format_exception(self
, exception
):
351 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
352 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
353 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
355 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
356 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
357 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
358 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
359 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
360 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
361 elif isinstance(exception
, nvExceptions
.Conflict
):
362 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
363 elif isinstance(exception
, vimconn
.vimconnException
):
366 self
.logger
.error("General Exception " + str(exception
), exc_info
=True)
367 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
369 def get_tenant_list(self
, filter_dict
={}):
370 '''Obtain tenants of VIM
371 filter_dict can contain the following keys:
372 name: filter by tenant name
373 id: filter by tenant uuid/id
375 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
377 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
379 self
._reload
_connection
()
380 if self
.api_version3
:
381 project_class_list
= self
.keystone
.projects
.list(name
=filter_dict
.get("name"))
383 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
385 for project
in project_class_list
:
386 if filter_dict
.get('id') and filter_dict
["id"] != project
.id:
388 project_list
.append(project
.to_dict())
390 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
391 self
._format
_exception
(e
)
393 def new_tenant(self
, tenant_name
, tenant_description
):
394 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
395 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
397 self
._reload
_connection
()
398 if self
.api_version3
:
399 project
= self
.keystone
.projects
.create(tenant_name
, self
.config
.get("project_domain_id", "default"),
400 description
=tenant_description
, is_domain
=False)
402 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
404 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
405 self
._format
_exception
(e
)
407 def delete_tenant(self
, tenant_id
):
408 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
409 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
411 self
._reload
_connection
()
412 if self
.api_version3
:
413 self
.keystone
.projects
.delete(tenant_id
)
415 self
.keystone
.tenants
.delete(tenant_id
)
417 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
418 self
._format
_exception
(e
)
420 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
421 '''Adds a tenant network to VIM. Returns the network identifier'''
422 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
423 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
426 self
._reload
_connection
()
427 network_dict
= {'name': net_name
, 'admin_state_up': True}
428 if net_type
=="data" or net_type
=="ptp":
429 if self
.config
.get('dataplane_physical_net') == None:
430 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
431 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
432 network_dict
["provider:network_type"] = "vlan"
434 network_dict
["provider:network_type"] = vlan
436 ####### VIO Specific Changes #########
437 if self
.vim_type
== "VIO":
439 network_dict
["provider:segmentation_id"] = vlan
441 if self
.config
.get('dataplane_net_vlan_range') is None:
442 raise vimconn
.vimconnConflictException("You must provide "\
443 "'dataplane_net_vlan_range' in format [start_ID - end_ID]"\
444 "at config value before creating sriov network with vlan tag")
446 network_dict
["provider:segmentation_id"] = self
._genrate
_vlanID
()
448 network_dict
["shared"]=shared
449 new_net
=self
.neutron
.create_network({'network':network_dict
})
451 #create subnetwork, even if there is no profile
454 if not ip_profile
.get('subnet_address'):
455 #Fake subnet is required
456 subnet_rand
= random
.randint(0, 255)
457 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
458 if 'ip_version' not in ip_profile
:
459 ip_profile
['ip_version'] = "IPv4"
460 subnet
= {"name":net_name
+"-subnet",
461 "network_id": new_net
["network"]["id"],
462 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
463 "cidr": ip_profile
['subnet_address']
465 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
466 if ip_profile
.get('gateway_address'):
467 subnet
['gateway_ip'] = ip_profile
.get('gateway_address')
468 if ip_profile
.get('dns_address'):
469 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
470 if 'dhcp_enabled' in ip_profile
:
471 subnet
['enable_dhcp'] = False if \
472 ip_profile
['dhcp_enabled']=="false" or ip_profile
['dhcp_enabled']==False else True
473 if ip_profile
.get('dhcp_start_address'):
474 subnet
['allocation_pools'] = []
475 subnet
['allocation_pools'].append(dict())
476 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
477 if ip_profile
.get('dhcp_count'):
478 #parts = ip_profile['dhcp_start_address'].split('.')
479 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
480 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
481 ip_int
+= ip_profile
['dhcp_count'] - 1
482 ip_str
= str(netaddr
.IPAddress(ip_int
))
483 subnet
['allocation_pools'][0]['end'] = ip_str
484 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
485 self
.neutron
.create_subnet({"subnet": subnet
} )
486 return new_net
["network"]["id"]
487 except Exception as e
:
489 self
.neutron
.delete_network(new_net
['network']['id'])
490 self
._format
_exception
(e
)
492 def get_network_list(self
, filter_dict
={}):
493 '''Obtain tenant networks of VIM
499 admin_state_up: boolean
501 Returns the network list of dictionaries
503 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
505 self
._reload
_connection
()
506 filter_dict_os
= filter_dict
.copy()
507 if self
.api_version3
and "tenant_id" in filter_dict_os
:
508 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id') #T ODO check
509 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
510 net_list
= net_dict
["networks"]
511 self
.__net
_os
2mano
(net_list
)
513 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
514 self
._format
_exception
(e
)
516 def get_network(self
, net_id
):
517 '''Obtain details of network from VIM
518 Returns the network information from a network id'''
519 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
520 filter_dict
={"id": net_id
}
521 net_list
= self
.get_network_list(filter_dict
)
523 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
524 elif len(net_list
)>1:
525 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
528 for subnet_id
in net
.get("subnets", () ):
530 subnet
= self
.neutron
.show_subnet(subnet_id
)
531 except Exception as e
:
532 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
533 subnet
= {"id": subnet_id
, "fault": str(e
)}
534 subnets
.append(subnet
)
535 net
["subnets"] = subnets
536 net
["encapsulation"] = net
.get('provider:network_type')
537 net
["segmentation_id"] = net
.get('provider:segmentation_id')
540 def delete_network(self
, net_id
):
541 '''Deletes a tenant network from VIM. Returns the old network identifier'''
542 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
544 self
._reload
_connection
()
545 #delete VM ports attached to this networks before the network
546 ports
= self
.neutron
.list_ports(network_id
=net_id
)
547 for p
in ports
['ports']:
549 self
.neutron
.delete_port(p
["id"])
550 except Exception as e
:
551 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
552 self
.neutron
.delete_network(net_id
)
554 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
555 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
556 self
._format
_exception
(e
)
558 def refresh_nets_status(self
, net_list
):
559 '''Get the status of the networks
560 Params: the list of network identifiers
561 Returns a dictionary with:
562 net_id: #VIM id of this network
563 status: #Mandatory. Text with one of:
564 # DELETED (not found at vim)
565 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
566 # OTHER (Vim reported other status not understood)
567 # ERROR (VIM indicates an ERROR status)
568 # ACTIVE, INACTIVE, DOWN (admin down),
569 # BUILD (on building process)
571 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
572 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
576 for net_id
in net_list
:
579 net_vim
= self
.get_network(net_id
)
580 if net_vim
['status'] in netStatus2manoFormat
:
581 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
583 net
["status"] = "OTHER"
584 net
["error_msg"] = "VIM status reported " + net_vim
['status']
586 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
587 net
['status'] = 'DOWN'
589 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
590 except yaml
.representer
.RepresenterError
:
591 net
['vim_info'] = str(net_vim
)
592 if net_vim
.get('fault'): #TODO
593 net
['error_msg'] = str(net_vim
['fault'])
594 except vimconn
.vimconnNotFoundException
as e
:
595 self
.logger
.error("Exception getting net status: %s", str(e
))
596 net
['status'] = "DELETED"
597 net
['error_msg'] = str(e
)
598 except vimconn
.vimconnException
as e
:
599 self
.logger
.error("Exception getting net status: %s", str(e
))
600 net
['status'] = "VIM_ERROR"
601 net
['error_msg'] = str(e
)
602 net_dict
[net_id
] = net
605 def get_flavor(self
, flavor_id
):
606 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
607 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
609 self
._reload
_connection
()
610 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
611 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
612 return flavor
.to_dict()
613 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
614 self
._format
_exception
(e
)
616 def get_flavor_id_from_data(self
, flavor_dict
):
617 """Obtain flavor id that match the flavor description
618 Returns the flavor_id or raises a vimconnNotFoundException
619 flavor_dict: contains the required ram, vcpus, disk
620 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
621 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
622 vimconnNotFoundException is raised
624 exact_match
= False if self
.config
.get('use_existing_flavors') else True
626 self
._reload
_connection
()
627 flavor_candidate_id
= None
628 flavor_candidate_data
= (10000, 10000, 10000)
629 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
631 numas
= flavor_dict
.get("extended", {}).get("numas")
634 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemted")
636 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
638 # numas = extended.get("numas")
639 for flavor
in self
.nova
.flavors
.list():
640 epa
= flavor
.get_keys()
644 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
645 if flavor_data
== flavor_target
:
647 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
648 flavor_candidate_id
= flavor
.id
649 flavor_candidate_data
= flavor_data
650 if not exact_match
and flavor_candidate_id
:
651 return flavor_candidate_id
652 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
653 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
654 self
._format
_exception
(e
)
656 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
657 '''Adds a tenant flavor to openstack VIM
658 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
659 Returns the flavor identifier
661 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
665 name
=flavor_data
['name']
666 while retry
<max_retries
:
669 self
._reload
_connection
()
670 if change_name_if_used
:
673 fl
=self
.nova
.flavors
.list()
675 fl_names
.append(f
.name
)
676 while name
in fl_names
:
678 name
= flavor_data
['name']+"-" + str(name_suffix
)
680 ram
= flavor_data
.get('ram',64)
681 vcpus
= flavor_data
.get('vcpus',1)
684 extended
= flavor_data
.get("extended")
686 numas
=extended
.get("numas")
688 numa_nodes
= len(numas
)
690 return -1, "Can not add flavor with more than one numa"
691 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
692 numa_properties
["hw:mem_page_size"] = "large"
693 numa_properties
["hw:cpu_policy"] = "dedicated"
694 numa_properties
["hw:numa_mempolicy"] = "strict"
695 if self
.vim_type
== "VIO":
696 numa_properties
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
697 numa_properties
["vmware:latency_sensitivity_level"] = "high"
699 #overwrite ram and vcpus
700 #check if key 'memory' is present in numa else use ram value at flavor
702 ram
= numa
['memory']*1024
703 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
704 if 'paired-threads' in numa
:
705 vcpus
= numa
['paired-threads']*2
706 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
707 numa_properties
["hw:cpu_thread_policy"] = "require"
708 numa_properties
["hw:cpu_policy"] = "dedicated"
709 elif 'cores' in numa
:
710 vcpus
= numa
['cores']
711 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
712 numa_properties
["hw:cpu_thread_policy"] = "isolate"
713 numa_properties
["hw:cpu_policy"] = "dedicated"
714 elif 'threads' in numa
:
715 vcpus
= numa
['threads']
716 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
717 numa_properties
["hw:cpu_thread_policy"] = "prefer"
718 numa_properties
["hw:cpu_policy"] = "dedicated"
719 # for interface in numa.get("interfaces",() ):
720 # if interface["dedicated"]=="yes":
721 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
722 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
725 new_flavor
=self
.nova
.flavors
.create(name
,
728 flavor_data
.get('disk',0),
729 is_public
=flavor_data
.get('is_public', True)
733 new_flavor
.set_keys(numa_properties
)
735 except nvExceptions
.Conflict
as e
:
736 if change_name_if_used
and retry
< max_retries
:
738 self
._format
_exception
(e
)
739 #except nvExceptions.BadRequest as e:
740 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
741 self
._format
_exception
(e
)
743 def delete_flavor(self
,flavor_id
):
744 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
747 self
._reload
_connection
()
748 self
.nova
.flavors
.delete(flavor_id
)
750 #except nvExceptions.BadRequest as e:
751 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
752 self
._format
_exception
(e
)
754 def new_image(self
,image_dict
):
756 Adds a tenant image to VIM. imge_dict is a dictionary with:
758 disk_format: qcow2, vhd, vmdk, raw (by default), ...
759 location: path or URI
760 public: "yes" or "no"
761 metadata: metadata of the image
766 while retry
<max_retries
:
769 self
._reload
_connection
()
770 #determine format http://docs.openstack.org/developer/glance/formats.html
771 if "disk_format" in image_dict
:
772 disk_format
=image_dict
["disk_format"]
773 else: #autodiscover based on extension
774 if image_dict
['location'][-6:]==".qcow2":
776 elif image_dict
['location'][-4:]==".vhd":
778 elif image_dict
['location'][-5:]==".vmdk":
780 elif image_dict
['location'][-4:]==".vdi":
782 elif image_dict
['location'][-4:]==".iso":
784 elif image_dict
['location'][-4:]==".aki":
786 elif image_dict
['location'][-4:]==".ari":
788 elif image_dict
['location'][-4:]==".ami":
792 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
793 if image_dict
['location'][0:4]=="http":
794 new_image
= self
.glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
795 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
797 with
open(image_dict
['location']) as fimage
:
798 new_image
= self
.glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
799 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
800 #insert metadata. We cannot use 'new_image.properties.setdefault'
801 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
802 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
803 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
804 metadata_to_load
= image_dict
.get('metadata')
806 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
807 new_image_nova
.metadata
.setdefault(k
,v
)
809 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
810 self
._format
_exception
(e
)
811 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
812 if retry
==max_retries
:
814 self
._format
_exception
(e
)
815 except IOError as e
: #can not open the file
816 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
817 http_code
=vimconn
.HTTP_Bad_Request
)
819 def delete_image(self
, image_id
):
820 '''Deletes a tenant image from openstack VIM. Returns the old id
823 self
._reload
_connection
()
824 self
.nova
.images
.delete(image_id
)
826 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
827 self
._format
_exception
(e
)
829 def get_image_id_from_path(self
, path
):
830 '''Get the image id from image path in the VIM database. Returns the image_id'''
832 self
._reload
_connection
()
833 images
= self
.nova
.images
.list()
835 if image
.metadata
.get("location")==path
:
837 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
838 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
839 self
._format
_exception
(e
)
841 def get_image_list(self
, filter_dict
={}):
842 '''Obtain tenant images from VIM
846 checksum: image checksum
847 Returns the image list of dictionaries:
848 [{<the fields at Filter_dict plus some VIM specific>}, ...]
851 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
853 self
._reload
_connection
()
854 filter_dict_os
= filter_dict
.copy()
855 #First we filter by the available filter fields: name, id. The others are removed.
856 filter_dict_os
.pop('checksum', None)
857 image_list
= self
.nova
.images
.findall(**filter_dict_os
)
858 if len(image_list
) == 0:
860 #Then we filter by the rest of filter fields: checksum
862 for image
in image_list
:
864 image_class
= self
.glance
.images
.get(image
.id)
865 if 'checksum' not in filter_dict
or image_class
['checksum'] == filter_dict
.get('checksum'):
866 filtered_list
.append(image_class
.copy())
867 except gl1Exceptions
.HTTPNotFound
:
870 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
871 self
._format
_exception
(e
)
873 def __wait_for_vm(self
, vm_id
, status
):
874 """wait until vm is in the desired status and return True.
875 If the VM gets in ERROR status, return false.
876 If the timeout is reached generate an exception"""
878 while elapsed_time
< server_timeout
:
879 vm_status
= self
.nova
.servers
.get(vm_id
).status
880 if vm_status
== status
:
882 if vm_status
== 'ERROR':
887 # if we exceeded the timeout rollback
888 if elapsed_time
>= server_timeout
:
889 raise vimconn
.vimconnException('Timeout waiting for instance ' + vm_id
+ ' to get ' + status
,
890 http_code
=vimconn
.HTTP_Request_Timeout
)
892 def _get_openstack_availablity_zones(self
):
894 Get from openstack availability zones available
898 openstack_availability_zone
= self
.nova
.availability_zones
.list()
899 openstack_availability_zone
= [str(zone
.zoneName
) for zone
in openstack_availability_zone
900 if zone
.zoneName
!= 'internal']
901 return openstack_availability_zone
902 except Exception as e
:
905 def _set_availablity_zones(self
):
907 Set vim availablity zone
911 if 'availability_zone' in self
.config
:
912 vim_availability_zones
= self
.config
.get('availability_zone')
913 if isinstance(vim_availability_zones
, str):
914 self
.availability_zone
= [vim_availability_zones
]
915 elif isinstance(vim_availability_zones
, list):
916 self
.availability_zone
= vim_availability_zones
918 self
.availability_zone
= self
._get
_openstack
_availablity
_zones
()
920 def _get_vm_availability_zone(self
, availability_zone_index
, availability_zone_list
):
922 Return thge availability zone to be used by the created VM.
923 :return: The VIM availability zone to be used or None
925 if availability_zone_index
is None:
926 if not self
.config
.get('availability_zone'):
928 elif isinstance(self
.config
.get('availability_zone'), str):
929 return self
.config
['availability_zone']
931 # TODO consider using a different parameter at config for default AV and AV list match
932 return self
.config
['availability_zone'][0]
934 vim_availability_zones
= self
.availability_zone
935 # check if VIM offer enough availability zones describe in the VNFD
936 if vim_availability_zones
and len(availability_zone_list
) <= len(vim_availability_zones
):
937 # check if all the names of NFV AV match VIM AV names
938 match_by_index
= False
939 for av
in availability_zone_list
:
940 if av
not in vim_availability_zones
:
941 match_by_index
= True
944 return vim_availability_zones
[availability_zone_index
]
946 return availability_zone_list
[availability_zone_index
]
948 raise vimconn
.vimconnConflictException("No enough availability zones at VIM for this deployment")
950 def new_vminstance(self
, name
, description
, start
, image_id
, flavor_id
, net_list
, cloud_config
=None, disk_list
=None,
951 availability_zone_index
=None, availability_zone_list
=None):
952 """Adds a VM instance to VIM
954 start: indicates if VM must start or boot in pause mode. Ignored
955 image_id,flavor_id: iamge and flavor uuid
956 net_list: list of interfaces, each one is a dictionary with:
958 net_id: network uuid to connect
959 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
960 model: interface model, ignored #TODO
961 mac_address: used for SR-IOV ifaces #TODO for other types
962 use: 'data', 'bridge', 'mgmt'
963 type: 'virtual', 'PCI-PASSTHROUGH'('PF'), 'SR-IOV'('VF'), 'VFnotShared'
964 vim_id: filled/added by this function
965 floating_ip: True/False (or it can be None)
966 'cloud_config': (optional) dictionary with:
967 'key-pairs': (optional) list of strings with the public key to be inserted to the default user
968 'users': (optional) list of users to be inserted, each item is a dict with:
969 'name': (mandatory) user name,
970 'key-pairs': (optional) list of strings with the public key to be inserted to the user
971 'user-data': (optional) string is a text script to be passed directly to cloud-init
972 'config-files': (optional). List of files to be transferred. Each item is a dict with:
973 'dest': (mandatory) string with the destination absolute path
974 'encoding': (optional, by default text). Can be one of:
975 'b64', 'base64', 'gz', 'gz+b64', 'gz+base64', 'gzip+b64', 'gzip+base64'
976 'content' (mandatory): string with the content of the file
977 'permissions': (optional) string with file permissions, typically octal notation '0644'
978 'owner': (optional) file owner, string with the format 'owner:group'
979 'boot-data-drive': boolean to indicate if user-data must be passed using a boot drive (hard disk)
980 'disk_list': (optional) list with additional disks to the VM. Each item is a dict with:
981 'image_id': (optional). VIM id of an existing image. If not provided an empty disk must be mounted
982 'size': (mandatory) string with the size of the disk in GB
983 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
984 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
985 availability_zone_index is None
986 #TODO ip, security groups
987 Returns a tuple with the instance identifier and created_items or raises an exception on error
988 created_items can be None or a dictionary where this method can include key-values that will be passed to
989 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
990 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
993 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
999 external_network
= [] # list of external networks to be connected to instance, later on used to create floating_ip
1000 no_secured_ports
= [] # List of port-is with port-security disabled
1001 self
._reload
_connection
()
1002 # metadata_vpci = {} # For a specific neutron plugin
1003 block_device_mapping
= None
1004 for net
in net_list
:
1005 if not net
.get("net_id"): # skip non connected iface
1009 "network_id": net
["net_id"],
1010 "name": net
.get("name"),
1011 "admin_state_up": True
1013 if net
["type"]=="virtual":
1016 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1017 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1019 # if "VF" not in metadata_vpci:
1020 # metadata_vpci["VF"]=[]
1021 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1022 port_dict
["binding:vnic_type"]="direct"
1023 # VIO specific Changes
1024 if self
.vim_type
== "VIO":
1025 # Need to create port with port_security_enabled = False and no-security-groups
1026 port_dict
["port_security_enabled"]=False
1027 port_dict
["provider_security_groups"]=[]
1028 port_dict
["security_groups"]=[]
1029 else: # For PT PCI-PASSTHROUGH
1030 # VIO specific Changes
1031 # Current VIO release does not support port with type 'direct-physical'
1032 # So no need to create virtual port in case of PCI-device.
1033 # Will update port_dict code when support gets added in next VIO release
1034 if self
.vim_type
== "VIO":
1035 raise vimconn
.vimconnNotSupportedException(
1036 "Current VIO release does not support full passthrough (PT)")
1038 # if "PF" not in metadata_vpci:
1039 # metadata_vpci["PF"]=[]
1040 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1041 port_dict
["binding:vnic_type"]="direct-physical"
1042 if not port_dict
["name"]:
1043 port_dict
["name"]=name
1044 if net
.get("mac_address"):
1045 port_dict
["mac_address"]=net
["mac_address"]
1046 if net
.get("ip_address"):
1047 port_dict
["fixed_ips"] = [{'ip_address': net
["ip_address"]}]
1048 # TODO add 'subnet_id': <subnet_id>
1049 new_port
= self
.neutron
.create_port({"port": port_dict
})
1050 created_items
["port:" + str(new_port
["port"]["id"])] = True
1051 net
["mac_adress"] = new_port
["port"]["mac_address"]
1052 net
["vim_id"] = new_port
["port"]["id"]
1053 # if try to use a network without subnetwork, it will return a emtpy list
1054 fixed_ips
= new_port
["port"].get("fixed_ips")
1056 net
["ip"] = fixed_ips
[0].get("ip_address")
1060 port
= {"port-id": new_port
["port"]["id"]}
1061 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1062 port
["tag"] = new_port
["port"]["name"]
1063 net_list_vim
.append(port
)
1065 if net
.get('floating_ip', False):
1066 net
['exit_on_floating_ip_error'] = True
1067 external_network
.append(net
)
1068 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
1069 net
['exit_on_floating_ip_error'] = False
1070 external_network
.append(net
)
1071 net
['floating_ip'] = self
.config
.get('use_floating_ip')
1073 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1074 # As a workaround we wait until the VM is active and then disable the port-security
1075 if net
.get("port_security") == False and not self
.config
.get("no_port_security_extension"):
1076 no_secured_ports
.append(new_port
["port"]["id"])
1079 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1080 # if len(metadata["pci_assignement"]) >255:
1081 # #limit the metadata size
1082 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1083 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1086 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1087 name
, image_id
, flavor_id
, str(net_list_vim
), description
)
1089 security_groups
= self
.config
.get('security_groups')
1090 if type(security_groups
) is str:
1091 security_groups
= ( security_groups
, )
1093 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1095 # Create additional volumes in case these are present in disk_list
1096 base_disk_index
= ord('b')
1097 if disk_list
!= None:
1098 block_device_mapping
= {}
1099 for disk
in disk_list
:
1100 if 'image_id' in disk
:
1101 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
1102 chr(base_disk_index
), imageRef
= disk
['image_id'])
1104 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1105 chr(base_disk_index
))
1106 created_items
["volume:" + str(volume
.id)] = True
1107 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
1108 base_disk_index
+= 1
1110 # Wait until volumes are with status available
1113 while keep_waiting
and elapsed_time
< volume_timeout
:
1114 keep_waiting
= False
1115 for volume_id
in block_device_mapping
.itervalues():
1116 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
1122 # If we exceeded the timeout rollback
1123 if elapsed_time
>= volume_timeout
:
1124 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
1125 http_code
=vimconn
.HTTP_Request_Timeout
)
1126 # get availability Zone
1127 vm_av_zone
= self
._get
_vm
_availability
_zone
(availability_zone_index
, availability_zone_list
)
1129 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1130 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1131 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
1132 security_groups
, vm_av_zone
, self
.config
.get('keypair'),
1133 userdata
, config_drive
, block_device_mapping
))
1134 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
,
1135 security_groups
=security_groups
,
1136 availability_zone
=vm_av_zone
,
1137 key_name
=self
.config
.get('keypair'),
1139 config_drive
=config_drive
,
1140 block_device_mapping
=block_device_mapping
1141 ) # , description=description)
1143 vm_start_time
= time
.time()
1144 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1145 if no_secured_ports
:
1146 self
.__wait
_for
_vm
(server
.id, 'ACTIVE')
1148 for port_id
in no_secured_ports
:
1150 self
.neutron
.update_port(port_id
,
1151 {"port": {"port_security_enabled": False, "security_groups": None}})
1152 except Exception as e
:
1153 raise vimconn
.vimconnException("It was not possible to disable port security for port {}".format(
1155 # print "DONE :-)", server
1158 if external_network
:
1159 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
1160 for floating_network
in external_network
:
1165 ip
= floating_ips
.pop(0)
1166 if ip
.get("port_id", False) or ip
.get('tenant_id') != server
.tenant_id
:
1168 if isinstance(floating_network
['floating_ip'], str):
1169 if ip
.get("floating_network_id") != floating_network
['floating_ip']:
1171 free_floating_ip
= ip
.get("floating_ip_address")
1173 if isinstance(floating_network
['floating_ip'], str) and \
1174 floating_network
['floating_ip'].lower() != "true":
1175 pool_id
= floating_network
['floating_ip']
1177 # Find the external network
1178 external_nets
= list()
1179 for net
in self
.neutron
.list_networks()['networks']:
1180 if net
['router:external']:
1181 external_nets
.append(net
)
1183 if len(external_nets
) == 0:
1184 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
1185 "network is present",
1186 http_code
=vimconn
.HTTP_Conflict
)
1187 if len(external_nets
) > 1:
1188 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
1189 "external networks are present",
1190 http_code
=vimconn
.HTTP_Conflict
)
1192 pool_id
= external_nets
[0].get('id')
1193 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
1195 # self.logger.debug("Creating floating IP")
1196 new_floating_ip
= self
.neutron
.create_floatingip(param
)
1197 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
1198 except Exception as e
:
1199 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create new floating_ip " +
1200 str(e
), http_code
=vimconn
.HTTP_Conflict
)
1202 fix_ip
= floating_network
.get('ip')
1205 server
.add_floating_ip(free_floating_ip
, fix_ip
)
1207 except Exception as e
:
1208 # openstack need some time after VM creation to asign an IP. So retry if fails
1209 vm_status
= self
.nova
.servers
.get(server
.id).status
1210 if vm_status
!= 'ACTIVE' and vm_status
!= 'ERROR':
1211 if time
.time() - vm_start_time
< server_timeout
:
1214 raise vimconn
.vimconnException(
1215 "Cannot create floating_ip: {} {}".format(type(e
).__name
__, e
),
1216 http_code
=vimconn
.HTTP_Conflict
)
1218 except Exception as e
:
1219 if not floating_network
['exit_on_floating_ip_error']:
1220 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
1224 return server
.id, created_items
1225 # except nvExceptions.NotFound as e:
1226 # error_value=-vimconn.HTTP_Not_Found
1227 # error_text= "vm instance %s not found" % vm_id
1228 # except TypeError as e:
1229 # raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
1231 except Exception as e
:
1234 server_id
= server
.id
1236 self
.delete_vminstance(server_id
, created_items
)
1237 except Exception as e2
:
1238 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
1240 self
._format
_exception
(e
)
1242 def get_vminstance(self
,vm_id
):
1243 '''Returns the VM instance information from VIM'''
1244 #self.logger.debug("Getting VM from VIM")
1246 self
._reload
_connection
()
1247 server
= self
.nova
.servers
.find(id=vm_id
)
1248 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1249 return server
.to_dict()
1250 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1251 self
._format
_exception
(e
)
1253 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1255 Get a console for the virtual machine
1257 vm_id: uuid of the VM
1258 console_type, can be:
1259 "novnc" (by default), "xvpvnc" for VNC types,
1260 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1261 Returns dict with the console parameters:
1262 protocol: ssh, ftp, http, https, ...
1263 server: usually ip address
1264 port: the http, ssh, ... port
1265 suffix: extra text, e.g. the http path and query string
1267 self
.logger
.debug("Getting VM CONSOLE from VIM")
1269 self
._reload
_connection
()
1270 server
= self
.nova
.servers
.find(id=vm_id
)
1271 if console_type
== None or console_type
== "novnc":
1272 console_dict
= server
.get_vnc_console("novnc")
1273 elif console_type
== "xvpvnc":
1274 console_dict
= server
.get_vnc_console(console_type
)
1275 elif console_type
== "rdp-html5":
1276 console_dict
= server
.get_rdp_console(console_type
)
1277 elif console_type
== "spice-html5":
1278 console_dict
= server
.get_spice_console(console_type
)
1280 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1282 console_dict1
= console_dict
.get("console")
1284 console_url
= console_dict1
.get("url")
1287 protocol_index
= console_url
.find("//")
1288 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1289 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1290 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1291 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1292 console_dict
={"protocol": console_url
[0:protocol_index
],
1293 "server": console_url
[protocol_index
+2:port_index
],
1294 "port": console_url
[port_index
:suffix_index
],
1295 "suffix": console_url
[suffix_index
+1:]
1299 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1301 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1302 self
._format
_exception
(e
)
1304 def delete_vminstance(self
, vm_id
, created_items
=None):
1305 '''Removes a VM instance from VIM. Returns the old identifier
1307 #print "osconnector: Getting VM from VIM"
1308 if created_items
== None:
1311 self
._reload
_connection
()
1312 # delete VM ports attached to this networks before the virtual machine
1313 for k
, v
in created_items
.items():
1314 if not v
: # skip already deleted
1317 k_item
, _
, k_id
= k
.partition(":")
1318 if k_item
== "port":
1319 self
.neutron
.delete_port(k_id
)
1320 except Exception as e
:
1321 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
1323 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1324 # #dettach volumes attached
1325 # server = self.nova.servers.get(vm_id)
1326 # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
1327 # #for volume in volumes_attached_dict:
1328 # # self.cinder.volumes.detach(volume['id'])
1331 self
.nova
.servers
.delete(vm_id
)
1333 # delete volumes. Although having detached, they should have in active status before deleting
1334 # we ensure in this loop
1337 while keep_waiting
and elapsed_time
< volume_timeout
:
1338 keep_waiting
= False
1339 for k
, v
in created_items
.items():
1340 if not v
: # skip already deleted
1343 k_item
, _
, k_id
= k
.partition(":")
1344 if k_item
== "volume":
1345 if self
.cinder
.volumes
.get(k_id
).status
!= 'available':
1348 self
.cinder
.volumes
.delete(k_id
)
1349 except Exception as e
:
1350 self
.logger
.error("Error deleting volume: {}: {}".format(type(e
).__name
__, e
))
1355 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1356 self
._format
_exception
(e
)
1358 def refresh_vms_status(self
, vm_list
):
1359 '''Get the status of the virtual machines and their interfaces/ports
1360 Params: the list of VM identifiers
1361 Returns a dictionary with:
1362 vm_id: #VIM id of this Virtual Machine
1363 status: #Mandatory. Text with one of:
1364 # DELETED (not found at vim)
1365 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1366 # OTHER (Vim reported other status not understood)
1367 # ERROR (VIM indicates an ERROR status)
1368 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1369 # CREATING (on building process), ERROR
1370 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1372 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1373 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1375 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1376 mac_address: #Text format XX:XX:XX:XX:XX:XX
1377 vim_net_id: #network id where this interface is connected
1378 vim_interface_id: #interface/port VIM id
1379 ip_address: #null, or text with IPv4, IPv6 address
1380 compute_node: #identification of compute node where PF,VF interface is allocated
1381 pci: #PCI address of the NIC that hosts the PF,VF
1382 vlan: #physical VLAN used for VF
1385 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1386 for vm_id
in vm_list
:
1389 vm_vim
= self
.get_vminstance(vm_id
)
1390 if vm_vim
['status'] in vmStatus2manoFormat
:
1391 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1393 vm
['status'] = "OTHER"
1394 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1396 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1397 except yaml
.representer
.RepresenterError
:
1398 vm
['vim_info'] = str(vm_vim
)
1399 vm
["interfaces"] = []
1400 if vm_vim
.get('fault'):
1401 vm
['error_msg'] = str(vm_vim
['fault'])
1404 self
._reload
_connection
()
1405 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1406 for port
in port_dict
["ports"]:
1409 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1410 except yaml
.representer
.RepresenterError
:
1411 interface
['vim_info'] = str(port
)
1412 interface
["mac_address"] = port
.get("mac_address")
1413 interface
["vim_net_id"] = port
["network_id"]
1414 interface
["vim_interface_id"] = port
["id"]
1415 # check if OS-EXT-SRV-ATTR:host is there,
1416 # in case of non-admin credentials, it will be missing
1417 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1418 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1419 interface
["pci"] = None
1421 # check if binding:profile is there,
1422 # in case of non-admin credentials, it will be missing
1423 if port
.get('binding:profile'):
1424 if port
['binding:profile'].get('pci_slot'):
1425 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1426 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1427 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1428 pci
= port
['binding:profile']['pci_slot']
1429 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1430 interface
["pci"] = pci
1431 interface
["vlan"] = None
1432 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1433 network
= self
.neutron
.show_network(port
["network_id"])
1434 if network
['network'].get('provider:network_type') == 'vlan' and \
1435 port
.get("binding:vnic_type") == "direct":
1436 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1438 #look for floating ip address
1439 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1440 if floating_ip_dict
.get("floatingips"):
1441 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1443 for subnet
in port
["fixed_ips"]:
1444 ips
.append(subnet
["ip_address"])
1445 interface
["ip_address"] = ";".join(ips
)
1446 vm
["interfaces"].append(interface
)
1447 except Exception as e
:
1448 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1449 except vimconn
.vimconnNotFoundException
as e
:
1450 self
.logger
.error("Exception getting vm status: %s", str(e
))
1451 vm
['status'] = "DELETED"
1452 vm
['error_msg'] = str(e
)
1453 except vimconn
.vimconnException
as e
:
1454 self
.logger
.error("Exception getting vm status: %s", str(e
))
1455 vm
['status'] = "VIM_ERROR"
1456 vm
['error_msg'] = str(e
)
1460 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1461 '''Send and action over a VM instance from VIM
1462 Returns None or the console dict if the action was successfully sent to the VIM'''
1463 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1465 self
._reload
_connection
()
1466 server
= self
.nova
.servers
.find(id=vm_id
)
1467 if "start" in action_dict
:
1468 if action_dict
["start"]=="rebuild":
1471 if server
.status
=="PAUSED":
1473 elif server
.status
=="SUSPENDED":
1475 elif server
.status
=="SHUTOFF":
1477 elif "pause" in action_dict
:
1479 elif "resume" in action_dict
:
1481 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1483 elif "forceOff" in action_dict
:
1485 elif "terminate" in action_dict
:
1487 elif "createImage" in action_dict
:
1488 server
.create_image()
1489 #"path":path_schema,
1490 #"description":description_schema,
1491 #"name":name_schema,
1492 #"metadata":metadata_schema,
1493 #"imageRef": id_schema,
1494 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1495 elif "rebuild" in action_dict
:
1496 server
.rebuild(server
.image
['id'])
1497 elif "reboot" in action_dict
:
1498 server
.reboot() #reboot_type='SOFT'
1499 elif "console" in action_dict
:
1500 console_type
= action_dict
["console"]
1501 if console_type
== None or console_type
== "novnc":
1502 console_dict
= server
.get_vnc_console("novnc")
1503 elif console_type
== "xvpvnc":
1504 console_dict
= server
.get_vnc_console(console_type
)
1505 elif console_type
== "rdp-html5":
1506 console_dict
= server
.get_rdp_console(console_type
)
1507 elif console_type
== "spice-html5":
1508 console_dict
= server
.get_spice_console(console_type
)
1510 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1511 http_code
=vimconn
.HTTP_Bad_Request
)
1513 console_url
= console_dict
["console"]["url"]
1515 protocol_index
= console_url
.find("//")
1516 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1517 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1518 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1519 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1520 console_dict2
={"protocol": console_url
[0:protocol_index
],
1521 "server": console_url
[protocol_index
+2 : port_index
],
1522 "port": int(console_url
[port_index
+1 : suffix_index
]),
1523 "suffix": console_url
[suffix_index
+1:]
1525 return console_dict2
1526 except Exception as e
:
1527 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1530 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1531 self
._format
_exception
(e
)
1532 #TODO insert exception vimconn.HTTP_Unauthorized
1534 ####### VIO Specific Changes #########
1535 def _genrate_vlanID(self
):
1537 Method to get unused vlanID
1545 networks
= self
.get_network_list()
1546 for net
in networks
:
1547 if net
.get('provider:segmentation_id'):
1548 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1549 used_vlanIDs
= set(usedVlanIDs
)
1551 #find unused VLAN ID
1552 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1554 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1555 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1556 if vlanID
not in used_vlanIDs
:
1558 except Exception as exp
:
1559 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1561 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1562 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1565 def _validate_vlan_ranges(self
, dataplane_net_vlan_range
):
1567 Method to validate user given vlanID ranges
1571 for vlanID_range
in dataplane_net_vlan_range
:
1572 vlan_range
= vlanID_range
.replace(" ", "")
1574 vlanID_pattern
= r
'(\d)*-(\d)*$'
1575 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1577 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}.You must provide "\
1578 "'dataplane_net_vlan_range' in format [start_ID - end_ID].".format(vlanID_range
))
1580 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1581 if start_vlanid
<= 0 :
1582 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1583 "Start ID can not be zero. For VLAN "\
1584 "networks valid IDs are 1 to 4094 ".format(vlanID_range
))
1585 if end_vlanid
> 4094 :
1586 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1587 "End VLAN ID can not be greater than 4094. For VLAN "\
1588 "networks valid IDs are 1 to 4094 ".format(vlanID_range
))
1590 if start_vlanid
> end_vlanid
:
1591 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1592 "You must provide a 'dataplane_net_vlan_range' in format start_ID - end_ID and "\
1593 "start_ID < end_ID ".format(vlanID_range
))
1597 def new_external_port(self
, port_data
):
1598 #TODO openstack if needed
1599 '''Adds a external port to VIM'''
1600 '''Returns the port identifier'''
1601 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1603 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1604 #TODO openstack if needed
1605 '''Connects a external port to a network'''
1606 '''Returns status code of the VIM response'''
1607 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1609 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1610 '''Adds a new user to openstack VIM'''
1611 '''Returns the user identifier'''
1612 self
.logger
.debug("osconnector: Adding a new user to VIM")
1614 self
._reload
_connection
()
1615 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1616 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1618 except ksExceptions
.ConnectionError
as e
:
1619 error_value
=-vimconn
.HTTP_Bad_Request
1620 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1621 except ksExceptions
.ClientException
as e
: #TODO remove
1622 error_value
=-vimconn
.HTTP_Bad_Request
1623 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1624 #TODO insert exception vimconn.HTTP_Unauthorized
1625 #if reaching here is because an exception
1626 self
.logger
.debug("new_user " + error_text
)
1627 return error_value
, error_text
1629 def delete_user(self
, user_id
):
1630 '''Delete a user from openstack VIM'''
1631 '''Returns the user identifier'''
1633 print("osconnector: Deleting a user from VIM")
1635 self
._reload
_connection
()
1636 self
.keystone
.users
.delete(user_id
)
1638 except ksExceptions
.ConnectionError
as e
:
1639 error_value
=-vimconn
.HTTP_Bad_Request
1640 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1641 except ksExceptions
.NotFound
as e
:
1642 error_value
=-vimconn
.HTTP_Not_Found
1643 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1644 except ksExceptions
.ClientException
as e
: #TODO remove
1645 error_value
=-vimconn
.HTTP_Bad_Request
1646 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1647 #TODO insert exception vimconn.HTTP_Unauthorized
1648 #if reaching here is because an exception
1649 self
.logger
.debug("delete_tenant " + error_text
)
1650 return error_value
, error_text
1652 def get_hosts_info(self
):
1653 '''Get the information of deployed hosts
1654 Returns the hosts content'''
1656 print("osconnector: Getting Host info from VIM")
1659 self
._reload
_connection
()
1660 hypervisors
= self
.nova
.hypervisors
.list()
1661 for hype
in hypervisors
:
1662 h_list
.append( hype
.to_dict() )
1663 return 1, {"hosts":h_list
}
1664 except nvExceptions
.NotFound
as e
:
1665 error_value
=-vimconn
.HTTP_Not_Found
1666 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1667 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1668 error_value
=-vimconn
.HTTP_Bad_Request
1669 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1670 #TODO insert exception vimconn.HTTP_Unauthorized
1671 #if reaching here is because an exception
1672 self
.logger
.debug("get_hosts_info " + error_text
)
1673 return error_value
, error_text
1675 def get_hosts(self
, vim_tenant
):
1676 '''Get the hosts and deployed instances
1677 Returns the hosts content'''
1678 r
, hype_dict
= self
.get_hosts_info()
1681 hypervisors
= hype_dict
["hosts"]
1683 servers
= self
.nova
.servers
.list()
1684 for hype
in hypervisors
:
1685 for server
in servers
:
1686 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1688 hype
['vm'].append(server
.id)
1690 hype
['vm'] = [server
.id]
1692 except nvExceptions
.NotFound
as e
:
1693 error_value
=-vimconn
.HTTP_Not_Found
1694 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1695 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1696 error_value
=-vimconn
.HTTP_Bad_Request
1697 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1698 #TODO insert exception vimconn.HTTP_Unauthorized
1699 #if reaching here is because an exception
1700 self
.logger
.debug("get_hosts " + error_text
)
1701 return error_value
, error_text
1703 def new_classification(self
, name
, ctype
, definition
):
1705 'Adding a new (Traffic) Classification to VIM, named %s', name
)
1708 self
._reload
_connection
()
1709 if ctype
not in supportedClassificationTypes
:
1710 raise vimconn
.vimconnNotSupportedException(
1711 'OpenStack VIM connector doesn\'t support provided '
1712 'Classification Type {}, supported ones are: '
1713 '{}'.format(ctype
, supportedClassificationTypes
))
1714 if not self
._validate
_classification
(ctype
, definition
):
1715 raise vimconn
.vimconnException(
1716 'Incorrect Classification definition '
1717 'for the type specified.')
1718 classification_dict
= definition
1719 classification_dict
['name'] = name
1721 new_class
= self
.neutron
.create_sfc_flow_classifier(
1722 {'flow_classifier': classification_dict
})
1723 return new_class
['flow_classifier']['id']
1724 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1725 neExceptions
.NeutronException
, ConnectionError
) as e
:
1727 'Creation of Classification failed.')
1728 self
._format
_exception
(e
)
1730 def get_classification(self
, class_id
):
1731 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
1732 filter_dict
= {"id": class_id
}
1733 class_list
= self
.get_classification_list(filter_dict
)
1734 if len(class_list
) == 0:
1735 raise vimconn
.vimconnNotFoundException(
1736 "Classification '{}' not found".format(class_id
))
1737 elif len(class_list
) > 1:
1738 raise vimconn
.vimconnConflictException(
1739 "Found more than one Classification with this criteria")
1740 classification
= class_list
[0]
1741 return classification
1743 def get_classification_list(self
, filter_dict
={}):
1744 self
.logger
.debug("Getting Classifications from VIM filter: '%s'",
1747 filter_dict_os
= filter_dict
.copy()
1748 self
._reload
_connection
()
1749 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1750 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1751 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
1753 classification_list
= classification_dict
["flow_classifiers"]
1754 self
.__classification
_os
2mano
(classification_list
)
1755 return classification_list
1756 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1757 neExceptions
.NeutronException
, ConnectionError
) as e
:
1758 self
._format
_exception
(e
)
1760 def delete_classification(self
, class_id
):
1761 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
1763 self
._reload
_connection
()
1764 self
.neutron
.delete_sfc_flow_classifier(class_id
)
1766 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1767 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1768 ConnectionError
) as e
:
1769 self
._format
_exception
(e
)
1771 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
1773 "Adding a new Service Function Instance to VIM, named '%s'", name
)
1776 self
._reload
_connection
()
1780 if len(ingress_ports
) != 1:
1781 raise vimconn
.vimconnNotSupportedException(
1782 "OpenStack VIM connector can only have "
1783 "1 ingress port per SFI")
1784 if len(egress_ports
) != 1:
1785 raise vimconn
.vimconnNotSupportedException(
1786 "OpenStack VIM connector can only have "
1787 "1 egress port per SFI")
1788 sfi_dict
= {'name': name
,
1789 'ingress': ingress_ports
[0],
1790 'egress': egress_ports
[0],
1791 'service_function_parameters': {
1792 'correlation': correlation
}}
1793 new_sfi
= self
.neutron
.create_sfc_port_pair({'port_pair': sfi_dict
})
1794 return new_sfi
['port_pair']['id']
1795 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1796 neExceptions
.NeutronException
, ConnectionError
) as e
:
1799 self
.neutron
.delete_sfc_port_pair(
1800 new_sfi
['port_pair']['id'])
1803 'Creation of Service Function Instance failed, with '
1804 'subsequent deletion failure as well.')
1805 self
._format
_exception
(e
)
1807 def get_sfi(self
, sfi_id
):
1809 'Getting Service Function Instance %s from VIM', sfi_id
)
1810 filter_dict
= {"id": sfi_id
}
1811 sfi_list
= self
.get_sfi_list(filter_dict
)
1812 if len(sfi_list
) == 0:
1813 raise vimconn
.vimconnNotFoundException(
1814 "Service Function Instance '{}' not found".format(sfi_id
))
1815 elif len(sfi_list
) > 1:
1816 raise vimconn
.vimconnConflictException(
1817 'Found more than one Service Function Instance '
1818 'with this criteria')
1822 def get_sfi_list(self
, filter_dict
={}):
1823 self
.logger
.debug("Getting Service Function Instances from "
1824 "VIM filter: '%s'", str(filter_dict
))
1826 self
._reload
_connection
()
1827 filter_dict_os
= filter_dict
.copy()
1828 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1829 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1830 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
1831 sfi_list
= sfi_dict
["port_pairs"]
1832 self
.__sfi
_os
2mano
(sfi_list
)
1834 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1835 neExceptions
.NeutronException
, ConnectionError
) as e
:
1836 self
._format
_exception
(e
)
1838 def delete_sfi(self
, sfi_id
):
1839 self
.logger
.debug("Deleting Service Function Instance '%s' "
1842 self
._reload
_connection
()
1843 self
.neutron
.delete_sfc_port_pair(sfi_id
)
1845 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1846 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1847 ConnectionError
) as e
:
1848 self
._format
_exception
(e
)
1850 def new_sf(self
, name
, sfis
, sfc_encap
=True):
1851 self
.logger
.debug("Adding a new Service Function to VIM, "
1855 self
._reload
_connection
()
1856 # correlation = None
1858 # correlation = 'nsh'
1859 for instance
in sfis
:
1860 sfi
= self
.get_sfi(instance
)
1861 if sfi
.get('sfc_encap') != sfc_encap
:
1862 raise vimconn
.vimconnNotSupportedException(
1863 "OpenStack VIM connector requires all SFIs of the "
1864 "same SF to share the same SFC Encapsulation")
1865 sf_dict
= {'name': name
,
1867 new_sf
= self
.neutron
.create_sfc_port_pair_group({
1868 'port_pair_group': sf_dict
})
1869 return new_sf
['port_pair_group']['id']
1870 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1871 neExceptions
.NeutronException
, ConnectionError
) as e
:
1874 self
.neutron
.delete_sfc_port_pair_group(
1875 new_sf
['port_pair_group']['id'])
1878 'Creation of Service Function failed, with '
1879 'subsequent deletion failure as well.')
1880 self
._format
_exception
(e
)
1882 def get_sf(self
, sf_id
):
1883 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
1884 filter_dict
= {"id": sf_id
}
1885 sf_list
= self
.get_sf_list(filter_dict
)
1886 if len(sf_list
) == 0:
1887 raise vimconn
.vimconnNotFoundException(
1888 "Service Function '{}' not found".format(sf_id
))
1889 elif len(sf_list
) > 1:
1890 raise vimconn
.vimconnConflictException(
1891 "Found more than one Service Function with this criteria")
1895 def get_sf_list(self
, filter_dict
={}):
1896 self
.logger
.debug("Getting Service Function from VIM filter: '%s'",
1899 self
._reload
_connection
()
1900 filter_dict_os
= filter_dict
.copy()
1901 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1902 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1903 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
1904 sf_list
= sf_dict
["port_pair_groups"]
1905 self
.__sf
_os
2mano
(sf_list
)
1907 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1908 neExceptions
.NeutronException
, ConnectionError
) as e
:
1909 self
._format
_exception
(e
)
1911 def delete_sf(self
, sf_id
):
1912 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
1914 self
._reload
_connection
()
1915 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
1917 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1918 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1919 ConnectionError
) as e
:
1920 self
._format
_exception
(e
)
1922 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
1923 self
.logger
.debug("Adding a new Service Function Path to VIM, "
1927 self
._reload
_connection
()
1928 # In networking-sfc the MPLS encapsulation is legacy
1929 # should be used when no full SFC Encapsulation is intended
1933 sfp_dict
= {'name': name
,
1934 'flow_classifiers': classifications
,
1935 'port_pair_groups': sfs
,
1936 'chain_parameters': {'correlation': correlation
}}
1938 sfp_dict
['chain_id'] = spi
1939 new_sfp
= self
.neutron
.create_sfc_port_chain({'port_chain': sfp_dict
})
1940 return new_sfp
["port_chain"]["id"]
1941 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1942 neExceptions
.NeutronException
, ConnectionError
) as e
:
1945 self
.neutron
.delete_sfc_port_chain(new_sfp
['port_chain']['id'])
1948 'Creation of Service Function Path failed, with '
1949 'subsequent deletion failure as well.')
1950 self
._format
_exception
(e
)
1952 def get_sfp(self
, sfp_id
):
1953 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
1954 filter_dict
= {"id": sfp_id
}
1955 sfp_list
= self
.get_sfp_list(filter_dict
)
1956 if len(sfp_list
) == 0:
1957 raise vimconn
.vimconnNotFoundException(
1958 "Service Function Path '{}' not found".format(sfp_id
))
1959 elif len(sfp_list
) > 1:
1960 raise vimconn
.vimconnConflictException(
1961 "Found more than one Service Function Path with this criteria")
1965 def get_sfp_list(self
, filter_dict
={}):
1966 self
.logger
.debug("Getting Service Function Paths from VIM filter: "
1967 "'%s'", str(filter_dict
))
1969 self
._reload
_connection
()
1970 filter_dict_os
= filter_dict
.copy()
1971 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1972 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1973 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
1974 sfp_list
= sfp_dict
["port_chains"]
1975 self
.__sfp
_os
2mano
(sfp_list
)
1977 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1978 neExceptions
.NeutronException
, ConnectionError
) as e
:
1979 self
._format
_exception
(e
)
1981 def delete_sfp(self
, sfp_id
):
1983 "Deleting Service Function Path '%s' from VIM", sfp_id
)
1985 self
._reload
_connection
()
1986 self
.neutron
.delete_sfc_port_chain(sfp_id
)
1988 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1989 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1990 ConnectionError
) as e
:
1991 self
._format
_exception
(e
)