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")
113 raise TypeError('url param can not be NoneType')
114 self
.persistent_info
= persistent_info
115 self
.availability_zone
= persistent_info
.get('availability_zone', None)
116 self
.session
= persistent_info
.get('session', {'reload_client': True})
117 self
.nova
= self
.session
.get('nova')
118 self
.neutron
= self
.session
.get('neutron')
119 self
.cinder
= self
.session
.get('cinder')
120 self
.glance
= self
.session
.get('glance')
121 # self.glancev1 = self.session.get('glancev1')
122 self
.keystone
= self
.session
.get('keystone')
123 self
.api_version3
= self
.session
.get('api_version3')
124 self
.vim_type
= self
.config
.get("vim_type")
126 self
.vim_type
= self
.vim_type
.upper()
127 if self
.config
.get("use_internal_endpoint"):
128 self
.endpoint_type
= "internalURL"
130 self
.endpoint_type
= None
132 self
.logger
= logging
.getLogger('openmano.vim.openstack')
134 ####### VIO Specific Changes #########
135 if self
.vim_type
== "VIO":
136 self
.logger
= logging
.getLogger('openmano.vim.vio')
139 self
.logger
.setLevel( getattr(logging
, log_level
))
141 def __getitem__(self
, index
):
142 """Get individuals parameters.
144 if index
== 'project_domain_id':
145 return self
.config
.get("project_domain_id")
146 elif index
== 'user_domain_id':
147 return self
.config
.get("user_domain_id")
149 return vimconn
.vimconnector
.__getitem
__(self
, index
)
151 def __setitem__(self
, index
, value
):
152 """Set individuals parameters and it is marked as dirty so to force connection reload.
154 if index
== 'project_domain_id':
155 self
.config
["project_domain_id"] = value
156 elif index
== 'user_domain_id':
157 self
.config
["user_domain_id"] = value
159 vimconn
.vimconnector
.__setitem
__(self
, index
, value
)
160 self
.session
['reload_client'] = True
162 def _reload_connection(self
):
163 '''Called before any operation, it check if credentials has changed
164 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
166 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
167 if self
.session
['reload_client']:
168 if self
.config
.get('APIversion'):
169 self
.api_version3
= self
.config
['APIversion'] == 'v3.3' or self
.config
['APIversion'] == '3'
170 else: # get from ending auth_url that end with v3 or with v2.0
171 self
.api_version3
= self
.url
.endswith("/v3") or self
.url
.endswith("/v3/")
172 self
.session
['api_version3'] = self
.api_version3
173 if self
.api_version3
:
174 if self
.config
.get('project_domain_id') or self
.config
.get('project_domain_name'):
175 project_domain_id_default
= None
177 project_domain_id_default
= 'default'
178 if self
.config
.get('user_domain_id') or self
.config
.get('user_domain_name'):
179 user_domain_id_default
= None
181 user_domain_id_default
= 'default'
182 auth
= v3
.Password(auth_url
=self
.url
,
184 password
=self
.passwd
,
185 project_name
=self
.tenant_name
,
186 project_id
=self
.tenant_id
,
187 project_domain_id
=self
.config
.get('project_domain_id', project_domain_id_default
),
188 user_domain_id
=self
.config
.get('user_domain_id', user_domain_id_default
),
189 project_domain_name
=self
.config
.get('project_domain_name'),
190 user_domain_name
=self
.config
.get('user_domain_name'))
192 auth
= v2
.Password(auth_url
=self
.url
,
194 password
=self
.passwd
,
195 tenant_name
=self
.tenant_name
,
196 tenant_id
=self
.tenant_id
)
197 sess
= session
.Session(auth
=auth
, verify
=self
.verify
)
198 if self
.api_version3
:
199 self
.keystone
= ksClient_v3
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
201 self
.keystone
= ksClient_v2
.Client(session
=sess
, endpoint_type
=self
.endpoint_type
)
202 self
.session
['keystone'] = self
.keystone
203 # In order to enable microversion functionality an explicit microversion must be specified in 'config'.
204 # This implementation approach is due to the warning message in
205 # https://developer.openstack.org/api-guide/compute/microversions.html
206 # where it is stated that microversion backwards compatibility is not guaranteed and clients should
207 # always require an specific microversion.
208 # To be able to use 'device role tagging' functionality define 'microversion: 2.32' in datacenter config
209 version
= self
.config
.get("microversion")
212 self
.nova
= self
.session
['nova'] = nClient
.Client(str(version
), session
=sess
, endpoint_type
=self
.endpoint_type
)
213 self
.neutron
= self
.session
['neutron'] = neClient
.Client('2.0', session
=sess
, endpoint_type
=self
.endpoint_type
)
214 self
.cinder
= self
.session
['cinder'] = cClient
.Client(2, session
=sess
, endpoint_type
=self
.endpoint_type
)
215 if self
.endpoint_type
== "internalURL":
216 glance_service_id
= self
.keystone
.services
.list(name
="glance")[0].id
217 glance_endpoint
= self
.keystone
.endpoints
.list(glance_service_id
, interface
="internal")[0].url
219 glance_endpoint
= None
220 self
.glance
= self
.session
['glance'] = glClient
.Client(2, session
=sess
, endpoint
=glance_endpoint
)
221 #using version 1 of glance client in new_image()
222 # self.glancev1 = self.session['glancev1'] = glClient.Client('1', session=sess,
223 # endpoint=glance_endpoint)
224 self
.session
['reload_client'] = False
225 self
.persistent_info
['session'] = self
.session
226 # add availablity zone info inside self.persistent_info
227 self
._set
_availablity
_zones
()
228 self
.persistent_info
['availability_zone'] = self
.availability_zone
230 def __net_os2mano(self
, net_list_dict
):
231 '''Transform the net openstack format to mano format
232 net_list_dict can be a list of dict or a single dict'''
233 if type(net_list_dict
) is dict:
234 net_list_
=(net_list_dict
,)
235 elif type(net_list_dict
) is list:
236 net_list_
=net_list_dict
238 raise TypeError("param net_list_dict must be a list or a dictionary")
239 for net
in net_list_
:
240 if net
.get('provider:network_type') == "vlan":
245 def __classification_os2mano(self
, class_list_dict
):
246 """Transform the openstack format (Flow Classifier) to mano format
247 (Classification) class_list_dict can be a list of dict or a single dict
249 if isinstance(class_list_dict
, dict):
250 class_list_
= [class_list_dict
]
251 elif isinstance(class_list_dict
, list):
252 class_list_
= class_list_dict
255 "param class_list_dict must be a list or a dictionary")
256 for classification
in class_list_
:
257 id = classification
.pop('id')
258 name
= classification
.pop('name')
259 description
= classification
.pop('description')
260 project_id
= classification
.pop('project_id')
261 tenant_id
= classification
.pop('tenant_id')
262 original_classification
= copy
.deepcopy(classification
)
263 classification
.clear()
264 classification
['ctype'] = 'legacy_flow_classifier'
265 classification
['definition'] = original_classification
266 classification
['id'] = id
267 classification
['name'] = name
268 classification
['description'] = description
269 classification
['project_id'] = project_id
270 classification
['tenant_id'] = tenant_id
272 def __sfi_os2mano(self
, sfi_list_dict
):
273 """Transform the openstack format (Port Pair) to mano format (SFI)
274 sfi_list_dict can be a list of dict or a single dict
276 if isinstance(sfi_list_dict
, dict):
277 sfi_list_
= [sfi_list_dict
]
278 elif isinstance(sfi_list_dict
, list):
279 sfi_list_
= sfi_list_dict
282 "param sfi_list_dict must be a list or a dictionary")
283 for sfi
in sfi_list_
:
284 sfi
['ingress_ports'] = []
285 sfi
['egress_ports'] = []
286 if sfi
.get('ingress'):
287 sfi
['ingress_ports'].append(sfi
['ingress'])
288 if sfi
.get('egress'):
289 sfi
['egress_ports'].append(sfi
['egress'])
292 params
= sfi
.get('service_function_parameters')
295 correlation
= params
.get('correlation')
298 sfi
['sfc_encap'] = sfc_encap
299 del sfi
['service_function_parameters']
301 def __sf_os2mano(self
, sf_list_dict
):
302 """Transform the openstack format (Port Pair Group) to mano format (SF)
303 sf_list_dict can be a list of dict or a single dict
305 if isinstance(sf_list_dict
, dict):
306 sf_list_
= [sf_list_dict
]
307 elif isinstance(sf_list_dict
, list):
308 sf_list_
= sf_list_dict
311 "param sf_list_dict must be a list or a dictionary")
313 del sf
['port_pair_group_parameters']
314 sf
['sfis'] = sf
['port_pairs']
317 def __sfp_os2mano(self
, sfp_list_dict
):
318 """Transform the openstack format (Port Chain) to mano format (SFP)
319 sfp_list_dict can be a list of dict or a single dict
321 if isinstance(sfp_list_dict
, dict):
322 sfp_list_
= [sfp_list_dict
]
323 elif isinstance(sfp_list_dict
, list):
324 sfp_list_
= sfp_list_dict
327 "param sfp_list_dict must be a list or a dictionary")
328 for sfp
in sfp_list_
:
329 params
= sfp
.pop('chain_parameters')
332 correlation
= params
.get('correlation')
335 sfp
['sfc_encap'] = sfc_encap
336 sfp
['spi'] = sfp
.pop('chain_id')
337 sfp
['classifications'] = sfp
.pop('flow_classifiers')
338 sfp
['service_functions'] = sfp
.pop('port_pair_groups')
340 # placeholder for now; read TODO note below
341 def _validate_classification(self
, type, definition
):
342 # only legacy_flow_classifier Type is supported at this point
344 # TODO(igordcard): this method should be an abstract method of an
345 # abstract Classification class to be implemented by the specific
346 # Types. Also, abstract vimconnector should call the validation
347 # method before the implemented VIM connectors are called.
349 def _format_exception(self
, exception
):
350 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
351 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
352 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
354 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
355 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
356 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
357 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
358 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
359 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
360 elif isinstance(exception
, nvExceptions
.Conflict
):
361 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
362 elif isinstance(exception
, vimconn
.vimconnException
):
365 self
.logger
.error("General Exception " + str(exception
), exc_info
=True)
366 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
368 def get_tenant_list(self
, filter_dict
={}):
369 '''Obtain tenants of VIM
370 filter_dict can contain the following keys:
371 name: filter by tenant name
372 id: filter by tenant uuid/id
374 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
376 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
378 self
._reload
_connection
()
379 if self
.api_version3
:
380 project_class_list
= self
.keystone
.projects
.list(name
=filter_dict
.get("name"))
382 project_class_list
= self
.keystone
.tenants
.findall(**filter_dict
)
384 for project
in project_class_list
:
385 if filter_dict
.get('id') and filter_dict
["id"] != project
.id:
387 project_list
.append(project
.to_dict())
389 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
390 self
._format
_exception
(e
)
392 def new_tenant(self
, tenant_name
, tenant_description
):
393 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
394 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
396 self
._reload
_connection
()
397 if self
.api_version3
:
398 project
= self
.keystone
.projects
.create(tenant_name
, self
.config
.get("project_domain_id", "default"),
399 description
=tenant_description
, is_domain
=False)
401 project
= self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
403 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
404 self
._format
_exception
(e
)
406 def delete_tenant(self
, tenant_id
):
407 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
408 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
410 self
._reload
_connection
()
411 if self
.api_version3
:
412 self
.keystone
.projects
.delete(tenant_id
)
414 self
.keystone
.tenants
.delete(tenant_id
)
416 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
417 self
._format
_exception
(e
)
419 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
420 '''Adds a tenant network to VIM. Returns the network identifier'''
421 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
422 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
425 self
._reload
_connection
()
426 network_dict
= {'name': net_name
, 'admin_state_up': True}
427 if net_type
=="data" or net_type
=="ptp":
428 if self
.config
.get('dataplane_physical_net') == None:
429 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
430 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
431 network_dict
["provider:network_type"] = "vlan"
433 network_dict
["provider:network_type"] = vlan
435 ####### VIO Specific Changes #########
436 if self
.vim_type
== "VIO":
438 network_dict
["provider:segmentation_id"] = vlan
440 if self
.config
.get('dataplane_net_vlan_range') is None:
441 raise vimconn
.vimconnConflictException("You must provide "\
442 "'dataplane_net_vlan_range' in format [start_ID - end_ID]"\
443 "at config value before creating sriov network with vlan tag")
445 network_dict
["provider:segmentation_id"] = self
._genrate
_vlanID
()
447 network_dict
["shared"]=shared
448 new_net
=self
.neutron
.create_network({'network':network_dict
})
450 #create subnetwork, even if there is no profile
453 if not ip_profile
.get('subnet_address'):
454 #Fake subnet is required
455 subnet_rand
= random
.randint(0, 255)
456 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
457 if 'ip_version' not in ip_profile
:
458 ip_profile
['ip_version'] = "IPv4"
459 subnet
= {"name":net_name
+"-subnet",
460 "network_id": new_net
["network"]["id"],
461 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
462 "cidr": ip_profile
['subnet_address']
464 # Gateway should be set to None if not needed. Otherwise openstack assigns one by default
465 if ip_profile
.get('gateway_address'):
466 subnet
['gateway_ip'] = ip_profile
['gateway_address']
468 subnet
['gateway_ip'] = None
469 if ip_profile
.get('dns_address'):
470 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
471 if 'dhcp_enabled' in ip_profile
:
472 subnet
['enable_dhcp'] = False if \
473 ip_profile
['dhcp_enabled']=="false" or ip_profile
['dhcp_enabled']==False else True
474 if ip_profile
.get('dhcp_start_address'):
475 subnet
['allocation_pools'] = []
476 subnet
['allocation_pools'].append(dict())
477 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
478 if ip_profile
.get('dhcp_count'):
479 #parts = ip_profile['dhcp_start_address'].split('.')
480 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
481 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
482 ip_int
+= ip_profile
['dhcp_count'] - 1
483 ip_str
= str(netaddr
.IPAddress(ip_int
))
484 subnet
['allocation_pools'][0]['end'] = ip_str
485 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
486 self
.neutron
.create_subnet({"subnet": subnet
} )
487 return new_net
["network"]["id"]
488 except Exception as e
:
490 self
.neutron
.delete_network(new_net
['network']['id'])
491 self
._format
_exception
(e
)
493 def get_network_list(self
, filter_dict
={}):
494 '''Obtain tenant networks of VIM
500 admin_state_up: boolean
502 Returns the network list of dictionaries
504 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
506 self
._reload
_connection
()
507 filter_dict_os
= filter_dict
.copy()
508 if self
.api_version3
and "tenant_id" in filter_dict_os
:
509 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id') #T ODO check
510 net_dict
= self
.neutron
.list_networks(**filter_dict_os
)
511 net_list
= net_dict
["networks"]
512 self
.__net
_os
2mano
(net_list
)
514 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
515 self
._format
_exception
(e
)
517 def get_network(self
, net_id
):
518 '''Obtain details of network from VIM
519 Returns the network information from a network id'''
520 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
521 filter_dict
={"id": net_id
}
522 net_list
= self
.get_network_list(filter_dict
)
524 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
525 elif len(net_list
)>1:
526 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
529 for subnet_id
in net
.get("subnets", () ):
531 subnet
= self
.neutron
.show_subnet(subnet_id
)
532 except Exception as e
:
533 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
534 subnet
= {"id": subnet_id
, "fault": str(e
)}
535 subnets
.append(subnet
)
536 net
["subnets"] = subnets
537 net
["encapsulation"] = net
.get('provider:network_type')
538 net
["segmentation_id"] = net
.get('provider:segmentation_id')
541 def delete_network(self
, net_id
):
542 '''Deletes a tenant network from VIM. Returns the old network identifier'''
543 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
545 self
._reload
_connection
()
546 #delete VM ports attached to this networks before the network
547 ports
= self
.neutron
.list_ports(network_id
=net_id
)
548 for p
in ports
['ports']:
550 self
.neutron
.delete_port(p
["id"])
551 except Exception as e
:
552 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
553 self
.neutron
.delete_network(net_id
)
555 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
556 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
557 self
._format
_exception
(e
)
559 def refresh_nets_status(self
, net_list
):
560 '''Get the status of the networks
561 Params: the list of network identifiers
562 Returns a dictionary with:
563 net_id: #VIM id of this network
564 status: #Mandatory. Text with one of:
565 # DELETED (not found at vim)
566 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
567 # OTHER (Vim reported other status not understood)
568 # ERROR (VIM indicates an ERROR status)
569 # ACTIVE, INACTIVE, DOWN (admin down),
570 # BUILD (on building process)
572 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
573 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
577 for net_id
in net_list
:
580 net_vim
= self
.get_network(net_id
)
581 if net_vim
['status'] in netStatus2manoFormat
:
582 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
584 net
["status"] = "OTHER"
585 net
["error_msg"] = "VIM status reported " + net_vim
['status']
587 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
588 net
['status'] = 'DOWN'
590 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
591 except yaml
.representer
.RepresenterError
:
592 net
['vim_info'] = str(net_vim
)
593 if net_vim
.get('fault'): #TODO
594 net
['error_msg'] = str(net_vim
['fault'])
595 except vimconn
.vimconnNotFoundException
as e
:
596 self
.logger
.error("Exception getting net status: %s", str(e
))
597 net
['status'] = "DELETED"
598 net
['error_msg'] = str(e
)
599 except vimconn
.vimconnException
as e
:
600 self
.logger
.error("Exception getting net status: %s", str(e
))
601 net
['status'] = "VIM_ERROR"
602 net
['error_msg'] = str(e
)
603 net_dict
[net_id
] = net
606 def get_flavor(self
, flavor_id
):
607 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
608 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
610 self
._reload
_connection
()
611 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
612 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
613 return flavor
.to_dict()
614 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
615 self
._format
_exception
(e
)
617 def get_flavor_id_from_data(self
, flavor_dict
):
618 """Obtain flavor id that match the flavor description
619 Returns the flavor_id or raises a vimconnNotFoundException
620 flavor_dict: contains the required ram, vcpus, disk
621 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
622 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
623 vimconnNotFoundException is raised
625 exact_match
= False if self
.config
.get('use_existing_flavors') else True
627 self
._reload
_connection
()
628 flavor_candidate_id
= None
629 flavor_candidate_data
= (10000, 10000, 10000)
630 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
632 numas
= flavor_dict
.get("extended", {}).get("numas")
635 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemted")
637 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
639 # numas = extended.get("numas")
640 for flavor
in self
.nova
.flavors
.list():
641 epa
= flavor
.get_keys()
645 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
646 if flavor_data
== flavor_target
:
648 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
649 flavor_candidate_id
= flavor
.id
650 flavor_candidate_data
= flavor_data
651 if not exact_match
and flavor_candidate_id
:
652 return flavor_candidate_id
653 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
654 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
655 self
._format
_exception
(e
)
657 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
658 '''Adds a tenant flavor to openstack VIM
659 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
660 Returns the flavor identifier
662 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
666 name
=flavor_data
['name']
667 while retry
<max_retries
:
670 self
._reload
_connection
()
671 if change_name_if_used
:
674 fl
=self
.nova
.flavors
.list()
676 fl_names
.append(f
.name
)
677 while name
in fl_names
:
679 name
= flavor_data
['name']+"-" + str(name_suffix
)
681 ram
= flavor_data
.get('ram',64)
682 vcpus
= flavor_data
.get('vcpus',1)
685 extended
= flavor_data
.get("extended")
687 numas
=extended
.get("numas")
689 numa_nodes
= len(numas
)
691 return -1, "Can not add flavor with more than one numa"
692 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
693 numa_properties
["hw:mem_page_size"] = "large"
694 numa_properties
["hw:cpu_policy"] = "dedicated"
695 numa_properties
["hw:numa_mempolicy"] = "strict"
696 if self
.vim_type
== "VIO":
697 numa_properties
["vmware:extra_config"] = '{"numa.nodeAffinity":"0"}'
698 numa_properties
["vmware:latency_sensitivity_level"] = "high"
700 #overwrite ram and vcpus
701 #check if key 'memory' is present in numa else use ram value at flavor
703 ram
= numa
['memory']*1024
704 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
705 if 'paired-threads' in numa
:
706 vcpus
= numa
['paired-threads']*2
707 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
708 numa_properties
["hw:cpu_thread_policy"] = "require"
709 numa_properties
["hw:cpu_policy"] = "dedicated"
710 elif 'cores' in numa
:
711 vcpus
= numa
['cores']
712 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
713 numa_properties
["hw:cpu_thread_policy"] = "isolate"
714 numa_properties
["hw:cpu_policy"] = "dedicated"
715 elif 'threads' in numa
:
716 vcpus
= numa
['threads']
717 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
718 numa_properties
["hw:cpu_thread_policy"] = "prefer"
719 numa_properties
["hw:cpu_policy"] = "dedicated"
720 # for interface in numa.get("interfaces",() ):
721 # if interface["dedicated"]=="yes":
722 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
723 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
726 new_flavor
=self
.nova
.flavors
.create(name
,
729 flavor_data
.get('disk',0),
730 is_public
=flavor_data
.get('is_public', True)
734 new_flavor
.set_keys(numa_properties
)
736 except nvExceptions
.Conflict
as e
:
737 if change_name_if_used
and retry
< max_retries
:
739 self
._format
_exception
(e
)
740 #except nvExceptions.BadRequest as e:
741 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
742 self
._format
_exception
(e
)
744 def delete_flavor(self
,flavor_id
):
745 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
748 self
._reload
_connection
()
749 self
.nova
.flavors
.delete(flavor_id
)
751 #except nvExceptions.BadRequest as e:
752 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
753 self
._format
_exception
(e
)
755 def new_image(self
,image_dict
):
757 Adds a tenant image to VIM. imge_dict is a dictionary with:
759 disk_format: qcow2, vhd, vmdk, raw (by default), ...
760 location: path or URI
761 public: "yes" or "no"
762 metadata: metadata of the image
767 while retry
<max_retries
:
770 self
._reload
_connection
()
771 #determine format http://docs.openstack.org/developer/glance/formats.html
772 if "disk_format" in image_dict
:
773 disk_format
=image_dict
["disk_format"]
774 else: #autodiscover based on extension
775 if image_dict
['location'].endswith(".qcow2"):
777 elif image_dict
['location'].endswith(".vhd"):
779 elif image_dict
['location'].endswith(".vmdk"):
781 elif image_dict
['location'].endswith(".vdi"):
783 elif image_dict
['location'].endswith(".iso"):
785 elif image_dict
['location'].endswith(".aki"):
787 elif image_dict
['location'].endswith(".ari"):
789 elif image_dict
['location'].endswith(".ami"):
793 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
794 new_image
= self
.glance
.images
.create(name
=image_dict
['name'])
795 if image_dict
['location'].startswith("http"):
796 # TODO there is not a method to direct download. It must be downloaded locally with requests
797 raise vimconn
.vimconnNotImplemented("Cannot create image from URL")
799 with
open(image_dict
['location']) as fimage
:
800 self
.glance
.images
.upload(new_image
.id, fimage
)
801 #new_image = self.glancev1.images.create(name=image_dict['name'], is_public=image_dict.get('public',"yes")=="yes",
802 # container_format="bare", data=fimage, disk_format=disk_format)
803 metadata_to_load
= image_dict
.get('metadata')
804 #TODO location is a reserved word for current openstack versions. Use another word
805 metadata_to_load
['location'] = image_dict
['location']
806 self
.glance
.images
.update(new_image
.id, **metadata_to_load
)
808 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
809 self
._format
_exception
(e
)
810 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
811 if retry
==max_retries
:
813 self
._format
_exception
(e
)
814 except IOError as e
: #can not open the file
815 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
816 http_code
=vimconn
.HTTP_Bad_Request
)
818 def delete_image(self
, image_id
):
819 '''Deletes a tenant image from openstack VIM. Returns the old id
822 self
._reload
_connection
()
823 self
.glance
.images
.delete(image_id
)
825 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
826 self
._format
_exception
(e
)
828 def get_image_id_from_path(self
, path
):
829 '''Get the image id from image path in the VIM database. Returns the image_id'''
831 self
._reload
_connection
()
832 images
= self
.glance
.images
.list()
834 if image
.metadata
.get("location")==path
:
836 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
837 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
838 self
._format
_exception
(e
)
840 def get_image_list(self
, filter_dict
={}):
841 '''Obtain tenant images from VIM
845 checksum: image checksum
846 Returns the image list of dictionaries:
847 [{<the fields at Filter_dict plus some VIM specific>}, ...]
850 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
852 self
._reload
_connection
()
853 filter_dict_os
= filter_dict
.copy()
854 #First we filter by the available filter fields: name, id. The others are removed.
855 image_list
= self
.glance
.images
.list()
857 for image
in image_list
:
859 if filter_dict
.get("name") and image
["name"] != filter_dict
["name"]:
861 if filter_dict
.get("id") and image
["id"] != filter_dict
["id"]:
863 if filter_dict
.get("checksum") and image
["checksum"] != filter_dict
["checksum"]:
866 filtered_list
.append(image
.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 'vim_id' (optional) should use this existing volume id
984 availability_zone_index: Index of availability_zone_list to use for this this VM. None if not AV required
985 availability_zone_list: list of availability zones given by user in the VNFD descriptor. Ignore if
986 availability_zone_index is None
987 #TODO ip, security groups
988 Returns a tuple with the instance identifier and created_items or raises an exception on error
989 created_items can be None or a dictionary where this method can include key-values that will be passed to
990 the method delete_vminstance and action_vminstance. Can be used to store created ports, volumes, etc.
991 Format is vimconnector dependent, but do not use nested dictionaries and a value of None should be the same
994 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
1000 external_network
= [] # list of external networks to be connected to instance, later on used to create floating_ip
1001 no_secured_ports
= [] # List of port-is with port-security disabled
1002 self
._reload
_connection
()
1003 # metadata_vpci = {} # For a specific neutron plugin
1004 block_device_mapping
= None
1005 for net
in net_list
:
1006 if not net
.get("net_id"): # skip non connected iface
1010 "network_id": net
["net_id"],
1011 "name": net
.get("name"),
1012 "admin_state_up": True
1014 if net
["type"]=="virtual":
1017 # metadata_vpci[ net["net_id"] ] = [[ net["vpci"], "" ]]
1018 elif net
["type"] == "VF" or net
["type"] == "SR-IOV": # for VF
1020 # if "VF" not in metadata_vpci:
1021 # metadata_vpci["VF"]=[]
1022 # metadata_vpci["VF"].append([ net["vpci"], "" ])
1023 port_dict
["binding:vnic_type"]="direct"
1024 # VIO specific Changes
1025 if self
.vim_type
== "VIO":
1026 # Need to create port with port_security_enabled = False and no-security-groups
1027 port_dict
["port_security_enabled"]=False
1028 port_dict
["provider_security_groups"]=[]
1029 port_dict
["security_groups"]=[]
1030 else: # For PT PCI-PASSTHROUGH
1031 # VIO specific Changes
1032 # Current VIO release does not support port with type 'direct-physical'
1033 # So no need to create virtual port in case of PCI-device.
1034 # Will update port_dict code when support gets added in next VIO release
1035 if self
.vim_type
== "VIO":
1036 raise vimconn
.vimconnNotSupportedException(
1037 "Current VIO release does not support full passthrough (PT)")
1039 # if "PF" not in metadata_vpci:
1040 # metadata_vpci["PF"]=[]
1041 # metadata_vpci["PF"].append([ net["vpci"], "" ])
1042 port_dict
["binding:vnic_type"]="direct-physical"
1043 if not port_dict
["name"]:
1044 port_dict
["name"]=name
1045 if net
.get("mac_address"):
1046 port_dict
["mac_address"]=net
["mac_address"]
1047 if net
.get("ip_address"):
1048 port_dict
["fixed_ips"] = [{'ip_address': net
["ip_address"]}]
1049 # TODO add 'subnet_id': <subnet_id>
1050 new_port
= self
.neutron
.create_port({"port": port_dict
})
1051 created_items
["port:" + str(new_port
["port"]["id"])] = True
1052 net
["mac_adress"] = new_port
["port"]["mac_address"]
1053 net
["vim_id"] = new_port
["port"]["id"]
1054 # if try to use a network without subnetwork, it will return a emtpy list
1055 fixed_ips
= new_port
["port"].get("fixed_ips")
1057 net
["ip"] = fixed_ips
[0].get("ip_address")
1061 port
= {"port-id": new_port
["port"]["id"]}
1062 if float(self
.nova
.api_version
.get_string()) >= 2.32:
1063 port
["tag"] = new_port
["port"]["name"]
1064 net_list_vim
.append(port
)
1066 if net
.get('floating_ip', False):
1067 net
['exit_on_floating_ip_error'] = True
1068 external_network
.append(net
)
1069 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
1070 net
['exit_on_floating_ip_error'] = False
1071 external_network
.append(net
)
1072 net
['floating_ip'] = self
.config
.get('use_floating_ip')
1074 # If port security is disabled when the port has not yet been attached to the VM, then all vm traffic is dropped.
1075 # As a workaround we wait until the VM is active and then disable the port-security
1076 if net
.get("port_security") == False and not self
.config
.get("no_port_security_extension"):
1077 no_secured_ports
.append(new_port
["port"]["id"])
1080 # metadata = {"pci_assignement": json.dumps(metadata_vpci)}
1081 # if len(metadata["pci_assignement"]) >255:
1082 # #limit the metadata size
1083 # #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
1084 # self.logger.warn("Metadata deleted since it exceeds the expected length (255) ")
1087 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s'",
1088 name
, image_id
, flavor_id
, str(net_list_vim
), description
)
1090 security_groups
= self
.config
.get('security_groups')
1091 if type(security_groups
) is str:
1092 security_groups
= ( security_groups
, )
1094 config_drive
, userdata
= self
._create
_user
_data
(cloud_config
)
1096 # Create additional volumes in case these are present in disk_list
1097 base_disk_index
= ord('b')
1099 block_device_mapping
= {}
1100 for disk
in disk_list
:
1101 if disk
.get('vim_id'):
1102 block_device_mapping
['_vd' + chr(base_disk_index
)] = disk
['vim_id']
1104 if 'image_id' in disk
:
1105 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1106 chr(base_disk_index
), imageRef
=disk
['image_id'])
1108 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
1109 chr(base_disk_index
))
1110 created_items
["volume:" + str(volume
.id)] = True
1111 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
1112 base_disk_index
+= 1
1114 # Wait until created volumes are with status available
1116 while elapsed_time
< volume_timeout
:
1117 for created_item
in created_items
:
1118 v
, _
, volume_id
= created_item
.partition(":")
1120 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
1122 else: # all ready: break from while
1126 # If we exceeded the timeout rollback
1127 if elapsed_time
>= volume_timeout
:
1128 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
1129 http_code
=vimconn
.HTTP_Request_Timeout
)
1130 # get availability Zone
1131 vm_av_zone
= self
._get
_vm
_availability
_zone
(availability_zone_index
, availability_zone_list
)
1133 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, security_groups={}, "
1134 "availability_zone={}, key_name={}, userdata={}, config_drive={}, "
1135 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
1136 security_groups
, vm_av_zone
, self
.config
.get('keypair'),
1137 userdata
, config_drive
, block_device_mapping
))
1138 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
,
1139 security_groups
=security_groups
,
1140 availability_zone
=vm_av_zone
,
1141 key_name
=self
.config
.get('keypair'),
1143 config_drive
=config_drive
,
1144 block_device_mapping
=block_device_mapping
1145 ) # , description=description)
1147 vm_start_time
= time
.time()
1148 # Previously mentioned workaround to wait until the VM is active and then disable the port-security
1149 if no_secured_ports
:
1150 self
.__wait
_for
_vm
(server
.id, 'ACTIVE')
1152 for port_id
in no_secured_ports
:
1154 self
.neutron
.update_port(port_id
,
1155 {"port": {"port_security_enabled": False, "security_groups": None}})
1156 except Exception as e
:
1157 raise vimconn
.vimconnException("It was not possible to disable port security for port {}".format(
1159 # print "DONE :-)", server
1162 if external_network
:
1163 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
1164 for floating_network
in external_network
:
1169 ip
= floating_ips
.pop(0)
1170 if ip
.get("port_id", False) or ip
.get('tenant_id') != server
.tenant_id
:
1172 if isinstance(floating_network
['floating_ip'], str):
1173 if ip
.get("floating_network_id") != floating_network
['floating_ip']:
1175 free_floating_ip
= ip
.get("floating_ip_address")
1177 if isinstance(floating_network
['floating_ip'], str) and \
1178 floating_network
['floating_ip'].lower() != "true":
1179 pool_id
= floating_network
['floating_ip']
1181 # Find the external network
1182 external_nets
= list()
1183 for net
in self
.neutron
.list_networks()['networks']:
1184 if net
['router:external']:
1185 external_nets
.append(net
)
1187 if len(external_nets
) == 0:
1188 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
1189 "network is present",
1190 http_code
=vimconn
.HTTP_Conflict
)
1191 if len(external_nets
) > 1:
1192 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
1193 "external networks are present",
1194 http_code
=vimconn
.HTTP_Conflict
)
1196 pool_id
= external_nets
[0].get('id')
1197 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
1199 # self.logger.debug("Creating floating IP")
1200 new_floating_ip
= self
.neutron
.create_floatingip(param
)
1201 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
1202 except Exception as e
:
1203 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create new floating_ip " +
1204 str(e
), http_code
=vimconn
.HTTP_Conflict
)
1206 fix_ip
= floating_network
.get('ip')
1209 server
.add_floating_ip(free_floating_ip
, fix_ip
)
1211 except Exception as e
:
1212 # openstack need some time after VM creation to asign an IP. So retry if fails
1213 vm_status
= self
.nova
.servers
.get(server
.id).status
1214 if vm_status
!= 'ACTIVE' and vm_status
!= 'ERROR':
1215 if time
.time() - vm_start_time
< server_timeout
:
1218 raise vimconn
.vimconnException(
1219 "Cannot create floating_ip: {} {}".format(type(e
).__name
__, e
),
1220 http_code
=vimconn
.HTTP_Conflict
)
1222 except Exception as e
:
1223 if not floating_network
['exit_on_floating_ip_error']:
1224 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
1228 return server
.id, created_items
1229 # except nvExceptions.NotFound as e:
1230 # error_value=-vimconn.HTTP_Not_Found
1231 # error_text= "vm instance %s not found" % vm_id
1232 # except TypeError as e:
1233 # raise vimconn.vimconnException(type(e).__name__ + ": "+ str(e), http_code=vimconn.HTTP_Bad_Request)
1235 except Exception as e
:
1238 server_id
= server
.id
1240 self
.delete_vminstance(server_id
, created_items
)
1241 except Exception as e2
:
1242 self
.logger
.error("new_vminstance rollback fail {}".format(e2
))
1244 self
._format
_exception
(e
)
1246 def get_vminstance(self
,vm_id
):
1247 '''Returns the VM instance information from VIM'''
1248 #self.logger.debug("Getting VM from VIM")
1250 self
._reload
_connection
()
1251 server
= self
.nova
.servers
.find(id=vm_id
)
1252 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
1253 return server
.to_dict()
1254 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1255 self
._format
_exception
(e
)
1257 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1259 Get a console for the virtual machine
1261 vm_id: uuid of the VM
1262 console_type, can be:
1263 "novnc" (by default), "xvpvnc" for VNC types,
1264 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1265 Returns dict with the console parameters:
1266 protocol: ssh, ftp, http, https, ...
1267 server: usually ip address
1268 port: the http, ssh, ... port
1269 suffix: extra text, e.g. the http path and query string
1271 self
.logger
.debug("Getting VM CONSOLE from VIM")
1273 self
._reload
_connection
()
1274 server
= self
.nova
.servers
.find(id=vm_id
)
1275 if console_type
== None or console_type
== "novnc":
1276 console_dict
= server
.get_vnc_console("novnc")
1277 elif console_type
== "xvpvnc":
1278 console_dict
= server
.get_vnc_console(console_type
)
1279 elif console_type
== "rdp-html5":
1280 console_dict
= server
.get_rdp_console(console_type
)
1281 elif console_type
== "spice-html5":
1282 console_dict
= server
.get_spice_console(console_type
)
1284 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1286 console_dict1
= console_dict
.get("console")
1288 console_url
= console_dict1
.get("url")
1291 protocol_index
= console_url
.find("//")
1292 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1293 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1294 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1295 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1296 console_dict
={"protocol": console_url
[0:protocol_index
],
1297 "server": console_url
[protocol_index
+2:port_index
],
1298 "port": console_url
[port_index
:suffix_index
],
1299 "suffix": console_url
[suffix_index
+1:]
1303 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1305 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1306 self
._format
_exception
(e
)
1308 def delete_vminstance(self
, vm_id
, created_items
=None):
1309 '''Removes a VM instance from VIM. Returns the old identifier
1311 #print "osconnector: Getting VM from VIM"
1312 if created_items
== None:
1315 self
._reload
_connection
()
1316 # delete VM ports attached to this networks before the virtual machine
1317 for k
, v
in created_items
.items():
1318 if not v
: # skip already deleted
1321 k_item
, _
, k_id
= k
.partition(":")
1322 if k_item
== "port":
1323 self
.neutron
.delete_port(k_id
)
1324 except Exception as e
:
1325 self
.logger
.error("Error deleting port: {}: {}".format(type(e
).__name
__, e
))
1327 # #commented because detaching the volumes makes the servers.delete not work properly ?!?
1328 # #dettach volumes attached
1329 # server = self.nova.servers.get(vm_id)
1330 # volumes_attached_dict = server._info['os-extended-volumes:volumes_attached'] #volume['id']
1331 # #for volume in volumes_attached_dict:
1332 # # self.cinder.volumes.detach(volume['id'])
1335 self
.nova
.servers
.delete(vm_id
)
1337 # delete volumes. Although having detached, they should have in active status before deleting
1338 # we ensure in this loop
1341 while keep_waiting
and elapsed_time
< volume_timeout
:
1342 keep_waiting
= False
1343 for k
, v
in created_items
.items():
1344 if not v
: # skip already deleted
1347 k_item
, _
, k_id
= k
.partition(":")
1348 if k_item
== "volume":
1349 if self
.cinder
.volumes
.get(k_id
).status
!= 'available':
1352 self
.cinder
.volumes
.delete(k_id
)
1353 except Exception as e
:
1354 self
.logger
.error("Error deleting volume: {}: {}".format(type(e
).__name
__, e
))
1359 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1360 self
._format
_exception
(e
)
1362 def refresh_vms_status(self
, vm_list
):
1363 '''Get the status of the virtual machines and their interfaces/ports
1364 Params: the list of VM identifiers
1365 Returns a dictionary with:
1366 vm_id: #VIM id of this Virtual Machine
1367 status: #Mandatory. Text with one of:
1368 # DELETED (not found at vim)
1369 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1370 # OTHER (Vim reported other status not understood)
1371 # ERROR (VIM indicates an ERROR status)
1372 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1373 # CREATING (on building process), ERROR
1374 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1376 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1377 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1379 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1380 mac_address: #Text format XX:XX:XX:XX:XX:XX
1381 vim_net_id: #network id where this interface is connected
1382 vim_interface_id: #interface/port VIM id
1383 ip_address: #null, or text with IPv4, IPv6 address
1384 compute_node: #identification of compute node where PF,VF interface is allocated
1385 pci: #PCI address of the NIC that hosts the PF,VF
1386 vlan: #physical VLAN used for VF
1389 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1390 for vm_id
in vm_list
:
1393 vm_vim
= self
.get_vminstance(vm_id
)
1394 if vm_vim
['status'] in vmStatus2manoFormat
:
1395 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1397 vm
['status'] = "OTHER"
1398 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1400 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1401 except yaml
.representer
.RepresenterError
:
1402 vm
['vim_info'] = str(vm_vim
)
1403 vm
["interfaces"] = []
1404 if vm_vim
.get('fault'):
1405 vm
['error_msg'] = str(vm_vim
['fault'])
1408 self
._reload
_connection
()
1409 port_dict
= self
.neutron
.list_ports(device_id
=vm_id
)
1410 for port
in port_dict
["ports"]:
1413 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1414 except yaml
.representer
.RepresenterError
:
1415 interface
['vim_info'] = str(port
)
1416 interface
["mac_address"] = port
.get("mac_address")
1417 interface
["vim_net_id"] = port
["network_id"]
1418 interface
["vim_interface_id"] = port
["id"]
1419 # check if OS-EXT-SRV-ATTR:host is there,
1420 # in case of non-admin credentials, it will be missing
1421 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1422 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1423 interface
["pci"] = None
1425 # check if binding:profile is there,
1426 # in case of non-admin credentials, it will be missing
1427 if port
.get('binding:profile'):
1428 if port
['binding:profile'].get('pci_slot'):
1429 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1430 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1431 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1432 pci
= port
['binding:profile']['pci_slot']
1433 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1434 interface
["pci"] = pci
1435 interface
["vlan"] = None
1436 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1437 network
= self
.neutron
.show_network(port
["network_id"])
1438 if network
['network'].get('provider:network_type') == 'vlan' and \
1439 port
.get("binding:vnic_type") == "direct":
1440 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1442 #look for floating ip address
1444 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1445 if floating_ip_dict
.get("floatingips"):
1446 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1450 for subnet
in port
["fixed_ips"]:
1451 ips
.append(subnet
["ip_address"])
1452 interface
["ip_address"] = ";".join(ips
)
1453 vm
["interfaces"].append(interface
)
1454 except Exception as e
:
1455 self
.logger
.error("Error getting vm interface information {}: {}".format(type(e
).__name
__, e
),
1457 except vimconn
.vimconnNotFoundException
as e
:
1458 self
.logger
.error("Exception getting vm status: %s", str(e
))
1459 vm
['status'] = "DELETED"
1460 vm
['error_msg'] = str(e
)
1461 except vimconn
.vimconnException
as e
:
1462 self
.logger
.error("Exception getting vm status: %s", str(e
))
1463 vm
['status'] = "VIM_ERROR"
1464 vm
['error_msg'] = str(e
)
1468 def action_vminstance(self
, vm_id
, action_dict
, created_items
={}):
1469 '''Send and action over a VM instance from VIM
1470 Returns None or the console dict if the action was successfully sent to the VIM'''
1471 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1473 self
._reload
_connection
()
1474 server
= self
.nova
.servers
.find(id=vm_id
)
1475 if "start" in action_dict
:
1476 if action_dict
["start"]=="rebuild":
1479 if server
.status
=="PAUSED":
1481 elif server
.status
=="SUSPENDED":
1483 elif server
.status
=="SHUTOFF":
1485 elif "pause" in action_dict
:
1487 elif "resume" in action_dict
:
1489 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1491 elif "forceOff" in action_dict
:
1493 elif "terminate" in action_dict
:
1495 elif "createImage" in action_dict
:
1496 server
.create_image()
1497 #"path":path_schema,
1498 #"description":description_schema,
1499 #"name":name_schema,
1500 #"metadata":metadata_schema,
1501 #"imageRef": id_schema,
1502 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1503 elif "rebuild" in action_dict
:
1504 server
.rebuild(server
.image
['id'])
1505 elif "reboot" in action_dict
:
1506 server
.reboot() #reboot_type='SOFT'
1507 elif "console" in action_dict
:
1508 console_type
= action_dict
["console"]
1509 if console_type
== None or console_type
== "novnc":
1510 console_dict
= server
.get_vnc_console("novnc")
1511 elif console_type
== "xvpvnc":
1512 console_dict
= server
.get_vnc_console(console_type
)
1513 elif console_type
== "rdp-html5":
1514 console_dict
= server
.get_rdp_console(console_type
)
1515 elif console_type
== "spice-html5":
1516 console_dict
= server
.get_spice_console(console_type
)
1518 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1519 http_code
=vimconn
.HTTP_Bad_Request
)
1521 console_url
= console_dict
["console"]["url"]
1523 protocol_index
= console_url
.find("//")
1524 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1525 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1526 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1527 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1528 console_dict2
={"protocol": console_url
[0:protocol_index
],
1529 "server": console_url
[protocol_index
+2 : port_index
],
1530 "port": int(console_url
[port_index
+1 : suffix_index
]),
1531 "suffix": console_url
[suffix_index
+1:]
1533 return console_dict2
1534 except Exception as e
:
1535 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1538 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1539 self
._format
_exception
(e
)
1540 #TODO insert exception vimconn.HTTP_Unauthorized
1542 ####### VIO Specific Changes #########
1543 def _genrate_vlanID(self
):
1545 Method to get unused vlanID
1553 networks
= self
.get_network_list()
1554 for net
in networks
:
1555 if net
.get('provider:segmentation_id'):
1556 usedVlanIDs
.append(net
.get('provider:segmentation_id'))
1557 used_vlanIDs
= set(usedVlanIDs
)
1559 #find unused VLAN ID
1560 for vlanID_range
in self
.config
.get('dataplane_net_vlan_range'):
1562 start_vlanid
, end_vlanid
= map(int, vlanID_range
.replace(" ", "").split("-"))
1563 for vlanID
in xrange(start_vlanid
, end_vlanid
+ 1):
1564 if vlanID
not in used_vlanIDs
:
1566 except Exception as exp
:
1567 raise vimconn
.vimconnException("Exception {} occurred while generating VLAN ID.".format(exp
))
1569 raise vimconn
.vimconnConflictException("Unable to create the SRIOV VLAN network."\
1570 " All given Vlan IDs {} are in use.".format(self
.config
.get('dataplane_net_vlan_range')))
1573 def _validate_vlan_ranges(self
, dataplane_net_vlan_range
):
1575 Method to validate user given vlanID ranges
1579 for vlanID_range
in dataplane_net_vlan_range
:
1580 vlan_range
= vlanID_range
.replace(" ", "")
1582 vlanID_pattern
= r
'(\d)*-(\d)*$'
1583 match_obj
= re
.match(vlanID_pattern
, vlan_range
)
1585 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}.You must provide "\
1586 "'dataplane_net_vlan_range' in format [start_ID - end_ID].".format(vlanID_range
))
1588 start_vlanid
, end_vlanid
= map(int,vlan_range
.split("-"))
1589 if start_vlanid
<= 0 :
1590 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1591 "Start ID can not be zero. For VLAN "\
1592 "networks valid IDs are 1 to 4094 ".format(vlanID_range
))
1593 if end_vlanid
> 4094 :
1594 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1595 "End VLAN ID can not be greater than 4094. For VLAN "\
1596 "networks valid IDs are 1 to 4094 ".format(vlanID_range
))
1598 if start_vlanid
> end_vlanid
:
1599 raise vimconn
.vimconnConflictException("Invalid dataplane_net_vlan_range {}."\
1600 "You must provide a 'dataplane_net_vlan_range' in format start_ID - end_ID and "\
1601 "start_ID < end_ID ".format(vlanID_range
))
1605 def new_external_port(self
, port_data
):
1606 #TODO openstack if needed
1607 '''Adds a external port to VIM'''
1608 '''Returns the port identifier'''
1609 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1611 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1612 #TODO openstack if needed
1613 '''Connects a external port to a network'''
1614 '''Returns status code of the VIM response'''
1615 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1617 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1618 '''Adds a new user to openstack VIM'''
1619 '''Returns the user identifier'''
1620 self
.logger
.debug("osconnector: Adding a new user to VIM")
1622 self
._reload
_connection
()
1623 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1624 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1626 except ksExceptions
.ConnectionError
as e
:
1627 error_value
=-vimconn
.HTTP_Bad_Request
1628 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1629 except ksExceptions
.ClientException
as e
: #TODO remove
1630 error_value
=-vimconn
.HTTP_Bad_Request
1631 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1632 #TODO insert exception vimconn.HTTP_Unauthorized
1633 #if reaching here is because an exception
1634 self
.logger
.debug("new_user " + error_text
)
1635 return error_value
, error_text
1637 def delete_user(self
, user_id
):
1638 '''Delete a user from openstack VIM'''
1639 '''Returns the user identifier'''
1641 print("osconnector: Deleting a user from VIM")
1643 self
._reload
_connection
()
1644 self
.keystone
.users
.delete(user_id
)
1646 except ksExceptions
.ConnectionError
as e
:
1647 error_value
=-vimconn
.HTTP_Bad_Request
1648 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1649 except ksExceptions
.NotFound
as e
:
1650 error_value
=-vimconn
.HTTP_Not_Found
1651 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1652 except ksExceptions
.ClientException
as e
: #TODO remove
1653 error_value
=-vimconn
.HTTP_Bad_Request
1654 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1655 #TODO insert exception vimconn.HTTP_Unauthorized
1656 #if reaching here is because an exception
1657 self
.logger
.debug("delete_tenant " + error_text
)
1658 return error_value
, error_text
1660 def get_hosts_info(self
):
1661 '''Get the information of deployed hosts
1662 Returns the hosts content'''
1664 print("osconnector: Getting Host info from VIM")
1667 self
._reload
_connection
()
1668 hypervisors
= self
.nova
.hypervisors
.list()
1669 for hype
in hypervisors
:
1670 h_list
.append( hype
.to_dict() )
1671 return 1, {"hosts":h_list
}
1672 except nvExceptions
.NotFound
as e
:
1673 error_value
=-vimconn
.HTTP_Not_Found
1674 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1675 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1676 error_value
=-vimconn
.HTTP_Bad_Request
1677 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1678 #TODO insert exception vimconn.HTTP_Unauthorized
1679 #if reaching here is because an exception
1680 self
.logger
.debug("get_hosts_info " + error_text
)
1681 return error_value
, error_text
1683 def get_hosts(self
, vim_tenant
):
1684 '''Get the hosts and deployed instances
1685 Returns the hosts content'''
1686 r
, hype_dict
= self
.get_hosts_info()
1689 hypervisors
= hype_dict
["hosts"]
1691 servers
= self
.nova
.servers
.list()
1692 for hype
in hypervisors
:
1693 for server
in servers
:
1694 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1696 hype
['vm'].append(server
.id)
1698 hype
['vm'] = [server
.id]
1700 except nvExceptions
.NotFound
as e
:
1701 error_value
=-vimconn
.HTTP_Not_Found
1702 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1703 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1704 error_value
=-vimconn
.HTTP_Bad_Request
1705 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1706 #TODO insert exception vimconn.HTTP_Unauthorized
1707 #if reaching here is because an exception
1708 self
.logger
.debug("get_hosts " + error_text
)
1709 return error_value
, error_text
1711 def new_classification(self
, name
, ctype
, definition
):
1713 'Adding a new (Traffic) Classification to VIM, named %s', name
)
1716 self
._reload
_connection
()
1717 if ctype
not in supportedClassificationTypes
:
1718 raise vimconn
.vimconnNotSupportedException(
1719 'OpenStack VIM connector doesn\'t support provided '
1720 'Classification Type {}, supported ones are: '
1721 '{}'.format(ctype
, supportedClassificationTypes
))
1722 if not self
._validate
_classification
(ctype
, definition
):
1723 raise vimconn
.vimconnException(
1724 'Incorrect Classification definition '
1725 'for the type specified.')
1726 classification_dict
= definition
1727 classification_dict
['name'] = name
1729 new_class
= self
.neutron
.create_sfc_flow_classifier(
1730 {'flow_classifier': classification_dict
})
1731 return new_class
['flow_classifier']['id']
1732 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1733 neExceptions
.NeutronException
, ConnectionError
) as e
:
1735 'Creation of Classification failed.')
1736 self
._format
_exception
(e
)
1738 def get_classification(self
, class_id
):
1739 self
.logger
.debug(" Getting Classification %s from VIM", class_id
)
1740 filter_dict
= {"id": class_id
}
1741 class_list
= self
.get_classification_list(filter_dict
)
1742 if len(class_list
) == 0:
1743 raise vimconn
.vimconnNotFoundException(
1744 "Classification '{}' not found".format(class_id
))
1745 elif len(class_list
) > 1:
1746 raise vimconn
.vimconnConflictException(
1747 "Found more than one Classification with this criteria")
1748 classification
= class_list
[0]
1749 return classification
1751 def get_classification_list(self
, filter_dict
={}):
1752 self
.logger
.debug("Getting Classifications from VIM filter: '%s'",
1755 filter_dict_os
= filter_dict
.copy()
1756 self
._reload
_connection
()
1757 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1758 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1759 classification_dict
= self
.neutron
.list_sfc_flow_classifiers(
1761 classification_list
= classification_dict
["flow_classifiers"]
1762 self
.__classification
_os
2mano
(classification_list
)
1763 return classification_list
1764 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1765 neExceptions
.NeutronException
, ConnectionError
) as e
:
1766 self
._format
_exception
(e
)
1768 def delete_classification(self
, class_id
):
1769 self
.logger
.debug("Deleting Classification '%s' from VIM", class_id
)
1771 self
._reload
_connection
()
1772 self
.neutron
.delete_sfc_flow_classifier(class_id
)
1774 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1775 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1776 ConnectionError
) as e
:
1777 self
._format
_exception
(e
)
1779 def new_sfi(self
, name
, ingress_ports
, egress_ports
, sfc_encap
=True):
1781 "Adding a new Service Function Instance to VIM, named '%s'", name
)
1784 self
._reload
_connection
()
1788 if len(ingress_ports
) != 1:
1789 raise vimconn
.vimconnNotSupportedException(
1790 "OpenStack VIM connector can only have "
1791 "1 ingress port per SFI")
1792 if len(egress_ports
) != 1:
1793 raise vimconn
.vimconnNotSupportedException(
1794 "OpenStack VIM connector can only have "
1795 "1 egress port per SFI")
1796 sfi_dict
= {'name': name
,
1797 'ingress': ingress_ports
[0],
1798 'egress': egress_ports
[0],
1799 'service_function_parameters': {
1800 'correlation': correlation
}}
1801 new_sfi
= self
.neutron
.create_sfc_port_pair({'port_pair': sfi_dict
})
1802 return new_sfi
['port_pair']['id']
1803 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1804 neExceptions
.NeutronException
, ConnectionError
) as e
:
1807 self
.neutron
.delete_sfc_port_pair(
1808 new_sfi
['port_pair']['id'])
1811 'Creation of Service Function Instance failed, with '
1812 'subsequent deletion failure as well.')
1813 self
._format
_exception
(e
)
1815 def get_sfi(self
, sfi_id
):
1817 'Getting Service Function Instance %s from VIM', sfi_id
)
1818 filter_dict
= {"id": sfi_id
}
1819 sfi_list
= self
.get_sfi_list(filter_dict
)
1820 if len(sfi_list
) == 0:
1821 raise vimconn
.vimconnNotFoundException(
1822 "Service Function Instance '{}' not found".format(sfi_id
))
1823 elif len(sfi_list
) > 1:
1824 raise vimconn
.vimconnConflictException(
1825 'Found more than one Service Function Instance '
1826 'with this criteria')
1830 def get_sfi_list(self
, filter_dict
={}):
1831 self
.logger
.debug("Getting Service Function Instances from "
1832 "VIM filter: '%s'", str(filter_dict
))
1834 self
._reload
_connection
()
1835 filter_dict_os
= filter_dict
.copy()
1836 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1837 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1838 sfi_dict
= self
.neutron
.list_sfc_port_pairs(**filter_dict_os
)
1839 sfi_list
= sfi_dict
["port_pairs"]
1840 self
.__sfi
_os
2mano
(sfi_list
)
1842 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1843 neExceptions
.NeutronException
, ConnectionError
) as e
:
1844 self
._format
_exception
(e
)
1846 def delete_sfi(self
, sfi_id
):
1847 self
.logger
.debug("Deleting Service Function Instance '%s' "
1850 self
._reload
_connection
()
1851 self
.neutron
.delete_sfc_port_pair(sfi_id
)
1853 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1854 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1855 ConnectionError
) as e
:
1856 self
._format
_exception
(e
)
1858 def new_sf(self
, name
, sfis
, sfc_encap
=True):
1859 self
.logger
.debug("Adding a new Service Function to VIM, "
1863 self
._reload
_connection
()
1864 # correlation = None
1866 # correlation = 'nsh'
1867 for instance
in sfis
:
1868 sfi
= self
.get_sfi(instance
)
1869 if sfi
.get('sfc_encap') != sfc_encap
:
1870 raise vimconn
.vimconnNotSupportedException(
1871 "OpenStack VIM connector requires all SFIs of the "
1872 "same SF to share the same SFC Encapsulation")
1873 sf_dict
= {'name': name
,
1875 new_sf
= self
.neutron
.create_sfc_port_pair_group({
1876 'port_pair_group': sf_dict
})
1877 return new_sf
['port_pair_group']['id']
1878 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1879 neExceptions
.NeutronException
, ConnectionError
) as e
:
1882 self
.neutron
.delete_sfc_port_pair_group(
1883 new_sf
['port_pair_group']['id'])
1886 'Creation of Service Function failed, with '
1887 'subsequent deletion failure as well.')
1888 self
._format
_exception
(e
)
1890 def get_sf(self
, sf_id
):
1891 self
.logger
.debug("Getting Service Function %s from VIM", sf_id
)
1892 filter_dict
= {"id": sf_id
}
1893 sf_list
= self
.get_sf_list(filter_dict
)
1894 if len(sf_list
) == 0:
1895 raise vimconn
.vimconnNotFoundException(
1896 "Service Function '{}' not found".format(sf_id
))
1897 elif len(sf_list
) > 1:
1898 raise vimconn
.vimconnConflictException(
1899 "Found more than one Service Function with this criteria")
1903 def get_sf_list(self
, filter_dict
={}):
1904 self
.logger
.debug("Getting Service Function from VIM filter: '%s'",
1907 self
._reload
_connection
()
1908 filter_dict_os
= filter_dict
.copy()
1909 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1910 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1911 sf_dict
= self
.neutron
.list_sfc_port_pair_groups(**filter_dict_os
)
1912 sf_list
= sf_dict
["port_pair_groups"]
1913 self
.__sf
_os
2mano
(sf_list
)
1915 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1916 neExceptions
.NeutronException
, ConnectionError
) as e
:
1917 self
._format
_exception
(e
)
1919 def delete_sf(self
, sf_id
):
1920 self
.logger
.debug("Deleting Service Function '%s' from VIM", sf_id
)
1922 self
._reload
_connection
()
1923 self
.neutron
.delete_sfc_port_pair_group(sf_id
)
1925 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1926 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1927 ConnectionError
) as e
:
1928 self
._format
_exception
(e
)
1930 def new_sfp(self
, name
, classifications
, sfs
, sfc_encap
=True, spi
=None):
1931 self
.logger
.debug("Adding a new Service Function Path to VIM, "
1935 self
._reload
_connection
()
1936 # In networking-sfc the MPLS encapsulation is legacy
1937 # should be used when no full SFC Encapsulation is intended
1941 sfp_dict
= {'name': name
,
1942 'flow_classifiers': classifications
,
1943 'port_pair_groups': sfs
,
1944 'chain_parameters': {'correlation': correlation
}}
1946 sfp_dict
['chain_id'] = spi
1947 new_sfp
= self
.neutron
.create_sfc_port_chain({'port_chain': sfp_dict
})
1948 return new_sfp
["port_chain"]["id"]
1949 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1950 neExceptions
.NeutronException
, ConnectionError
) as e
:
1953 self
.neutron
.delete_sfc_port_chain(new_sfp
['port_chain']['id'])
1956 'Creation of Service Function Path failed, with '
1957 'subsequent deletion failure as well.')
1958 self
._format
_exception
(e
)
1960 def get_sfp(self
, sfp_id
):
1961 self
.logger
.debug(" Getting Service Function Path %s from VIM", sfp_id
)
1962 filter_dict
= {"id": sfp_id
}
1963 sfp_list
= self
.get_sfp_list(filter_dict
)
1964 if len(sfp_list
) == 0:
1965 raise vimconn
.vimconnNotFoundException(
1966 "Service Function Path '{}' not found".format(sfp_id
))
1967 elif len(sfp_list
) > 1:
1968 raise vimconn
.vimconnConflictException(
1969 "Found more than one Service Function Path with this criteria")
1973 def get_sfp_list(self
, filter_dict
={}):
1974 self
.logger
.debug("Getting Service Function Paths from VIM filter: "
1975 "'%s'", str(filter_dict
))
1977 self
._reload
_connection
()
1978 filter_dict_os
= filter_dict
.copy()
1979 if self
.api_version3
and "tenant_id" in filter_dict_os
:
1980 filter_dict_os
['project_id'] = filter_dict_os
.pop('tenant_id')
1981 sfp_dict
= self
.neutron
.list_sfc_port_chains(**filter_dict_os
)
1982 sfp_list
= sfp_dict
["port_chains"]
1983 self
.__sfp
_os
2mano
(sfp_list
)
1985 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
,
1986 neExceptions
.NeutronException
, ConnectionError
) as e
:
1987 self
._format
_exception
(e
)
1989 def delete_sfp(self
, sfp_id
):
1991 "Deleting Service Function Path '%s' from VIM", sfp_id
)
1993 self
._reload
_connection
()
1994 self
.neutron
.delete_sfc_port_chain(sfp_id
)
1996 except (neExceptions
.ConnectionFailed
, neExceptions
.NeutronException
,
1997 ksExceptions
.ClientException
, neExceptions
.NeutronException
,
1998 ConnectionError
) as e
:
1999 self
._format
_exception
(e
)