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-client.
27 __author__
="Alfonso Tierno, Gerardo Garcia"
28 __date__
="$22-jun-2014 11:19:29$"
36 from novaclient
import client
as nClient
, exceptions
as nvExceptions
37 import keystoneclient
.v2_0
.client
as ksClient
38 import keystoneclient
.exceptions
as ksExceptions
39 import glanceclient
.v2
.client
as glClient
40 import glanceclient
.client
as gl1Client
41 import glanceclient
.exc
as gl1Exceptions
42 from httplib
import HTTPException
43 from neutronclient
.neutron
import client
as neClient
44 from neutronclient
.common
import exceptions
as neExceptions
45 from requests
.exceptions
import ConnectionError
47 '''contain the openstack virtual machine status to openmano status'''
48 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
50 'SUSPENDED': 'SUSPENDED',
53 'ERROR':'ERROR','DELETED':'DELETED'
55 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
58 class vimconnector(vimconn
.vimconnector
):
59 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None, log_level
="DEBUG", config
={}):
60 '''using common constructor parameters. In this case
61 'url' is the keystone authorization url,
62 'url_admin' is not use
64 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
69 raise TypeError, 'url param can not be NoneType'
70 self
.k_creds
['auth_url'] = url
71 self
.n_creds
['auth_url'] = url
73 self
.k_creds
['tenant_name'] = tenant_name
74 self
.n_creds
['project_id'] = tenant_name
76 self
.k_creds
['tenant_id'] = tenant_id
77 self
.n_creds
['tenant_id'] = tenant_id
79 self
.k_creds
['username'] = user
80 self
.n_creds
['username'] = user
82 self
.k_creds
['password'] = passwd
83 self
.n_creds
['api_key'] = passwd
84 self
.reload_client
= True
85 self
.logger
= logging
.getLogger('openmano.vim.openstack')
87 def __setitem__(self
,index
, value
):
88 '''Set individuals parameters
89 Throw TypeError, KeyError
91 if index
=='tenant_id':
92 self
.reload_client
=True
93 self
.tenant_id
= value
95 self
.k_creds
['tenant_id'] = value
96 self
.n_creds
['tenant_id'] = value
98 del self
.k_creds
['tenant_name']
99 del self
.n_creds
['project_id']
100 elif index
=='tenant_name':
101 self
.reload_client
=True
102 self
.tenant_name
= value
104 self
.k_creds
['tenant_name'] = value
105 self
.n_creds
['project_id'] = value
107 del self
.k_creds
['tenant_name']
108 del self
.n_creds
['project_id']
110 self
.reload_client
=True
113 self
.k_creds
['username'] = value
114 self
.n_creds
['username'] = value
116 del self
.k_creds
['username']
117 del self
.n_creds
['username']
118 elif index
=='passwd':
119 self
.reload_client
=True
122 self
.k_creds
['password'] = value
123 self
.n_creds
['api_key'] = value
125 del self
.k_creds
['password']
126 del self
.n_creds
['api_key']
128 self
.reload_client
=True
131 self
.k_creds
['auth_url'] = value
132 self
.n_creds
['auth_url'] = value
134 raise TypeError, 'url param can not be NoneType'
136 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
138 def _reload_connection(self
):
139 '''Called before any operation, it check if credentials has changed
140 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
142 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
143 if self
.reload_client
:
145 if len(self
.n_creds
) <4:
146 raise ksExceptions
.ClientException("Not enough parameters to connect to openstack")
147 self
.nova
= nClient
.Client(2, **self
.n_creds
)
148 self
.keystone
= ksClient
.Client(**self
.k_creds
)
149 self
.glance_endpoint
= self
.keystone
.service_catalog
.url_for(service_type
='image', endpoint_type
='publicURL')
150 self
.glance
= glClient
.Client(self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
151 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
152 self
.neutron
= neClient
.Client('2.0', endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
153 self
.reload_client
= False
155 def __net_os2mano(self
, net_list_dict
):
156 '''Transform the net openstack format to mano format
157 net_list_dict can be a list of dict or a single dict'''
158 if type(net_list_dict
) is dict:
159 net_list_
=(net_list_dict
,)
160 elif type(net_list_dict
) is list:
161 net_list_
=net_list_dict
163 raise TypeError("param net_list_dict must be a list or a dictionary")
164 for net
in net_list_
:
165 if net
.get('provider:network_type') == "vlan":
172 def _format_exception(self
, exception
):
173 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
174 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
175 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
177 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
178 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
179 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
180 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
181 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
182 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
183 elif isinstance(exception
, nvExceptions
.Conflict
):
184 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
186 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
188 def get_tenant_list(self
, filter_dict
={}):
189 '''Obtain tenants of VIM
190 filter_dict can contain the following keys:
191 name: filter by tenant name
192 id: filter by tenant uuid/id
194 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
196 self
.logger
.debug("Getting tenant from VIM filter: '%s'", str(filter_dict
))
198 self
._reload
_connection
()
199 tenant_class_list
=self
.keystone
.tenants
.findall(**filter_dict
)
201 for tenant
in tenant_class_list
:
202 tenant_list
.append(tenant
.to_dict())
204 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
205 self
._format
_exception
(e
)
207 def new_tenant(self
, tenant_name
, tenant_description
):
208 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
209 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
211 self
._reload
_connection
()
212 tenant
=self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
214 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
215 self
._format
_exception
(e
)
217 def delete_tenant(self
, tenant_id
):
218 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
219 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
221 self
._reload
_connection
()
222 self
.keystone
.tenants
.delete(tenant_id
)
224 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
225 self
._format
_exception
(e
)
227 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
228 '''Adds a tenant network to VIM. Returns the network identifier'''
229 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
231 self
._reload
_connection
()
232 network_dict
= {'name': net_name
, 'admin_state_up': True}
233 if net_type
=="data" or net_type
=="ptp":
234 if self
.config
.get('dataplane_physical_net') == None:
235 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
236 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
237 network_dict
["provider:network_type"] = "vlan"
239 network_dict
["provider:network_type"] = vlan
240 network_dict
["shared"]=shared
241 new_net
=self
.neutron
.create_network({'network':network_dict
})
243 #create subnetwork, even if there is no profile
246 if 'subnet_address' not in ip_profile
:
247 #Fake subnet is required
248 ip_profile
['subnet_address'] = "192.168.111.0/24"
249 if 'ip_version' not in ip_profile
:
250 ip_profile
['ip_version'] = "IPv4"
251 subnet
={"name":net_name
+"-subnet",
252 "network_id": new_net
["network"]["id"],
253 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
254 "cidr": ip_profile
['subnet_address']
256 if 'gateway_address' in ip_profile
:
257 subnet
['gateway_ip'] = ip_profile
['gateway_address']
258 if 'dns_address' in ip_profile
:
259 #TODO: manage dns_address as a list of addresses separated by commas
260 subnet
['dns_nameservers'] = []
261 subnet
['dns_nameservers'].append(ip_profile
['dns_address'])
262 if 'dhcp_enabled' in ip_profile
:
263 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
264 if 'dhcp_start_address' in ip_profile
:
265 subnet
['allocation_pools']=[]
266 subnet
['allocation_pools'].append(dict())
267 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
268 if 'dhcp_count' in ip_profile
:
269 #parts = ip_profile['dhcp_start_address'].split('.')
270 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
271 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
272 ip_int
+= ip_profile
['dhcp_count']
273 ip_str
= str(netaddr
.IPAddress(ip_int
))
274 subnet
['allocation_pools'][0]['end'] = ip_str
275 self
.neutron
.create_subnet({"subnet": subnet
} )
276 return new_net
["network"]["id"]
277 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
278 self
._format
_exception
(e
)
280 def get_network_list(self
, filter_dict
={}):
281 '''Obtain tenant networks of VIM
287 admin_state_up: boolean
289 Returns the network list of dictionaries
291 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
293 self
._reload
_connection
()
294 net_dict
=self
.neutron
.list_networks(**filter_dict
)
295 net_list
=net_dict
["networks"]
296 self
.__net
_os
2mano
(net_list
)
298 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
299 self
._format
_exception
(e
)
301 def get_network(self
, net_id
):
302 '''Obtain details of network from VIM
303 Returns the network information from a network id'''
304 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
305 filter_dict
={"id": net_id
}
306 net_list
= self
.get_network_list(filter_dict
)
308 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
309 elif len(net_list
)>1:
310 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
313 for subnet_id
in net
.get("subnets", () ):
315 subnet
= self
.neutron
.show_subnet(subnet_id
)
316 except Exception as e
:
317 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
318 subnet
= {"id": subnet_id
, "fault": str(e
)}
319 subnets
.append(subnet
)
320 net
["subnets"] = subnets
323 def delete_network(self
, net_id
):
324 '''Deletes a tenant network from VIM. Returns the old network identifier'''
325 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
327 self
._reload
_connection
()
328 #delete VM ports attached to this networks before the network
329 ports
= self
.neutron
.list_ports(network_id
=net_id
)
330 for p
in ports
['ports']:
332 self
.neutron
.delete_port(p
["id"])
333 except Exception as e
:
334 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
335 self
.neutron
.delete_network(net_id
)
337 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
338 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
339 self
._format
_exception
(e
)
341 def refresh_nets_status(self
, net_list
):
342 '''Get the status of the networks
343 Params: the list of network identifiers
344 Returns a dictionary with:
345 net_id: #VIM id of this network
346 status: #Mandatory. Text with one of:
347 # DELETED (not found at vim)
348 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
349 # OTHER (Vim reported other status not understood)
350 # ERROR (VIM indicates an ERROR status)
351 # ACTIVE, INACTIVE, DOWN (admin down),
352 # BUILD (on building process)
354 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
355 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
359 for net_id
in net_list
:
362 net_vim
= self
.get_network(net_id
)
363 if net_vim
['status'] in netStatus2manoFormat
:
364 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
366 net
["status"] = "OTHER"
367 net
["error_msg"] = "VIM status reported " + net_vim
['status']
369 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
370 net
['status'] = 'DOWN'
372 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
373 except yaml
.representer
.RepresenterError
:
374 net
['vim_info'] = str(net_vim
)
375 if net_vim
.get('fault'): #TODO
376 net
['error_msg'] = str(net_vim
['fault'])
377 except vimconn
.vimconnNotFoundException
as e
:
378 self
.logger
.error("Exception getting net status: %s", str(e
))
379 net
['status'] = "DELETED"
380 net
['error_msg'] = str(e
)
381 except vimconn
.vimconnException
as e
:
382 self
.logger
.error("Exception getting net status: %s", str(e
))
383 net
['status'] = "VIM_ERROR"
384 net
['error_msg'] = str(e
)
385 net_dict
[net_id
] = net
388 def get_flavor(self
, flavor_id
):
389 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
390 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
392 self
._reload
_connection
()
393 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
394 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
395 return flavor
.to_dict()
396 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
397 self
._format
_exception
(e
)
399 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
400 '''Adds a tenant flavor to openstack VIM
401 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
402 Returns the flavor identifier
404 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
408 name
=flavor_data
['name']
409 while retry
<max_retries
:
412 self
._reload
_connection
()
413 if change_name_if_used
:
416 fl
=self
.nova
.flavors
.list()
418 fl_names
.append(f
.name
)
419 while name
in fl_names
:
421 name
= flavor_data
['name']+"-" + str(name_suffix
)
423 ram
= flavor_data
.get('ram',64)
424 vcpus
= flavor_data
.get('vcpus',1)
427 extended
= flavor_data
.get("extended")
429 numas
=extended
.get("numas")
431 numa_nodes
= len(numas
)
433 return -1, "Can not add flavor with more than one numa"
434 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
435 numa_properties
["hw:mem_page_size"] = "large"
436 numa_properties
["hw:cpu_policy"] = "dedicated"
437 numa_properties
["hw:numa_mempolicy"] = "strict"
439 #overwrite ram and vcpus
440 ram
= numa
['memory']*1024
441 if 'paired-threads' in numa
:
442 vcpus
= numa
['paired-threads']*2
443 numa_properties
["hw:cpu_threads_policy"] = "prefer"
444 elif 'cores' in numa
:
445 vcpus
= numa
['cores']
446 #numa_properties["hw:cpu_threads_policy"] = "prefer"
447 elif 'threads' in numa
:
448 vcpus
= numa
['threads']
449 numa_properties
["hw:cpu_policy"] = "isolated"
450 for interface
in numa
.get("interfaces",() ):
451 if interface
["dedicated"]=="yes":
452 raise vimconn
.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code
=vimconn
.HTTP_Service_Unavailable
)
453 #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
456 new_flavor
=self
.nova
.flavors
.create(name
,
459 flavor_data
.get('disk',1),
460 is_public
=flavor_data
.get('is_public', True)
464 new_flavor
.set_keys(numa_properties
)
466 except nvExceptions
.Conflict
as e
:
467 if change_name_if_used
and retry
< max_retries
:
469 self
._format
_exception
(e
)
470 #except nvExceptions.BadRequest as e:
471 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
472 self
._format
_exception
(e
)
474 def delete_flavor(self
,flavor_id
):
475 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
478 self
._reload
_connection
()
479 self
.nova
.flavors
.delete(flavor_id
)
481 #except nvExceptions.BadRequest as e:
482 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
483 self
._format
_exception
(e
)
485 def new_image(self
,image_dict
):
487 Adds a tenant image to VIM. imge_dict is a dictionary with:
489 disk_format: qcow2, vhd, vmdk, raw (by default), ...
490 location: path or URI
491 public: "yes" or "no"
492 metadata: metadata of the image
495 #using version 1 of glance client
496 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
499 while retry
<max_retries
:
502 self
._reload
_connection
()
503 #determine format http://docs.openstack.org/developer/glance/formats.html
504 if "disk_format" in image_dict
:
505 disk_format
=image_dict
["disk_format"]
506 else: #autodiscover base on extention
507 if image_dict
['location'][-6:]==".qcow2":
509 elif image_dict
['location'][-4:]==".vhd":
511 elif image_dict
['location'][-5:]==".vmdk":
513 elif image_dict
['location'][-4:]==".vdi":
515 elif image_dict
['location'][-4:]==".iso":
517 elif image_dict
['location'][-4:]==".aki":
519 elif image_dict
['location'][-4:]==".ari":
521 elif image_dict
['location'][-4:]==".ami":
525 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
526 if image_dict
['location'][0:4]=="http":
527 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
528 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
530 with
open(image_dict
['location']) as fimage
:
531 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
532 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
533 #insert metadata. We cannot use 'new_image.properties.setdefault'
534 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
535 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
536 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
537 metadata_to_load
= image_dict
.get('metadata')
539 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
540 new_image_nova
.metadata
.setdefault(k
,v
)
542 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
543 self
._format
_exception
(e
)
544 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
545 if retry
==max_retries
:
547 self
._format
_exception
(e
)
548 except IOError as e
: #can not open the file
549 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
550 http_code
=vimconn
.HTTP_Bad_Request
)
552 def delete_image(self
, image_id
):
553 '''Deletes a tenant image from openstack VIM. Returns the old id
556 self
._reload
_connection
()
557 self
.nova
.images
.delete(image_id
)
559 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
560 self
._format
_exception
(e
)
562 def get_image_id_from_path(self
, path
):
563 '''Get the image id from image path in the VIM database. Returns the image_id
566 self
._reload
_connection
()
567 images
= self
.nova
.images
.list()
569 if image
.metadata
.get("location")==path
:
571 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
572 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
573 self
._format
_exception
(e
)
575 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None):
576 '''Adds a VM instance to VIM
578 start: indicates if VM must start or boot in pause mode. Ignored
579 image_id,flavor_id: iamge and flavor uuid
580 net_list: list of interfaces, each one is a dictionary with:
582 net_id: network uuid to connect
583 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
584 model: interface model, ignored #TODO
585 mac_address: used for SR-IOV ifaces #TODO for other types
586 use: 'data', 'bridge', 'mgmt'
587 type: 'virtual', 'PF', 'VF', 'VFnotShared'
588 vim_id: filled/added by this function
589 #TODO ip, security groups
590 Returns the instance identifier
592 self
.logger
.debug("Creating VM image '%s' flavor '%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
596 self
._reload
_connection
()
597 metadata_vpci
={} #For a specific neutron plugin
599 if not net
.get("net_id"): #skip non connected iface
601 if net
["type"]=="virtual":
602 net_list_vim
.append({'net-id': net
["net_id"]})
604 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
605 elif net
["type"]=="PF":
606 self
.logger
.warn("new_vminstance: Warning, can not connect a passthrough interface ")
607 #TODO insert this when openstack consider passthrough ports as openstack neutron ports
610 if "VF" not in metadata_vpci
:
611 metadata_vpci
["VF"]=[]
612 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
614 "network_id": net
["net_id"],
615 "name": net
.get("name"),
616 "binding:vnic_type": "direct",
617 "admin_state_up": True
619 if not port_dict
["name"]:
620 port_dict
["name"] = name
621 if net
.get("mac_address"):
622 port_dict
["mac_address"]=net
["mac_address"]
623 #TODO: manage having SRIOV without vlan tag
624 #if net["type"] == "VFnotShared"
625 # port_dict["vlan"]=0
626 new_port
= self
.neutron
.create_port({"port": port_dict
})
627 net
["mac_adress"] = new_port
["port"]["mac_address"]
628 net
["vim_id"] = new_port
["port"]["id"]
629 net
["ip"] = new_port
["port"].get("fixed_ips",[{}])[0].get("ip_address")
630 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
632 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
633 if len(metadata
["pci_assignement"]) >255:
634 #limit the metadata size
635 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
636 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
639 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
640 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
642 security_groups
= self
.config
.get('security_groups')
643 if type(security_groups
) is str:
644 security_groups
= ( security_groups
, )
645 if isinstance(cloud_config
, dict):
646 userdata
="#cloud-config\nusers:\n"
648 if "key-pairs" in cloud_config
:
649 userdata
+= " - default:\n ssh-authorized-keys:\n"
650 for key
in cloud_config
["key-pairs"]:
651 userdata
+= " - '{key}'\n".format(key
=key
)
652 for user
in cloud_config
.get("users",[]):
653 userdata
+= " - name: {name}\n sudo: ALL=(ALL) NOPASSWD:ALL\n".format(name
=user
["name"])
654 if "user-info" in user
:
655 userdata
+= " gecos: {}'\n".format(user
["user-info"])
656 if user
.get("key-pairs"):
657 userdata
+= " ssh-authorized-keys:\n"
658 for key
in user
["key-pairs"]:
659 userdata
+= " - '{key}'\n".format(key
=key
)
660 self
.logger
.debug("userdata: %s", userdata
)
661 elif isinstance(cloud_config
, str):
662 userdata
= cloud_config
666 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
667 security_groups
= security_groups
,
668 availability_zone
= self
.config
.get('availability_zone'),
669 key_name
= self
.config
.get('keypair'),
671 ) #, description=description)
674 #print "DONE :-)", server
676 # #TODO server.add_floating_ip("10.95.87.209")
677 # #To look for a free floating_ip
678 # free_floating_ip = None
679 # for floating_ip in self.neutron.list_floatingips().get("floatingips", () ):
680 # if not floating_ip["port_id"]:
681 # free_floating_ip = floating_ip["floating_ip_address"]
683 # if free_floating_ip:
684 # server.add_floating_ip(free_floating_ip)
688 # except nvExceptions.NotFound as e:
689 # error_value=-vimconn.HTTP_Not_Found
690 # error_text= "vm instance %s not found" % vm_id
691 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
693 self
._format
_exception
(e
)
694 except TypeError as e
:
695 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
697 def get_vminstance(self
,vm_id
):
698 '''Returns the VM instance information from VIM'''
699 #self.logger.debug("Getting VM from VIM")
701 self
._reload
_connection
()
702 server
= self
.nova
.servers
.find(id=vm_id
)
703 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
704 return server
.to_dict()
705 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
706 self
._format
_exception
(e
)
708 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
710 Get a console for the virtual machine
712 vm_id: uuid of the VM
713 console_type, can be:
714 "novnc" (by default), "xvpvnc" for VNC types,
715 "rdp-html5" for RDP types, "spice-html5" for SPICE types
716 Returns dict with the console parameters:
717 protocol: ssh, ftp, http, https, ...
718 server: usually ip address
719 port: the http, ssh, ... port
720 suffix: extra text, e.g. the http path and query string
722 self
.logger
.debug("Getting VM CONSOLE from VIM")
724 self
._reload
_connection
()
725 server
= self
.nova
.servers
.find(id=vm_id
)
726 if console_type
== None or console_type
== "novnc":
727 console_dict
= server
.get_vnc_console("novnc")
728 elif console_type
== "xvpvnc":
729 console_dict
= server
.get_vnc_console(console_type
)
730 elif console_type
== "rdp-html5":
731 console_dict
= server
.get_rdp_console(console_type
)
732 elif console_type
== "spice-html5":
733 console_dict
= server
.get_spice_console(console_type
)
735 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
737 console_dict1
= console_dict
.get("console")
739 console_url
= console_dict1
.get("url")
742 protocol_index
= console_url
.find("//")
743 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
744 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
745 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
746 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
747 console_dict
={"protocol": console_url
[0:protocol_index
],
748 "server": console_url
[protocol_index
+2:port_index
],
749 "port": console_url
[port_index
:suffix_index
],
750 "suffix": console_url
[suffix_index
+1:]
754 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
756 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
757 self
._format
_exception
(e
)
759 def delete_vminstance(self
, vm_id
):
760 '''Removes a VM instance from VIM. Returns the old identifier
762 #print "osconnector: Getting VM from VIM"
764 self
._reload
_connection
()
765 #delete VM ports attached to this networks before the virtual machine
766 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
767 for p
in ports
['ports']:
769 self
.neutron
.delete_port(p
["id"])
770 except Exception as e
:
771 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
772 self
.nova
.servers
.delete(vm_id
)
774 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
775 self
._format
_exception
(e
)
776 #TODO insert exception vimconn.HTTP_Unauthorized
777 #if reaching here is because an exception
779 def refresh_vms_status(self
, vm_list
):
780 '''Get the status of the virtual machines and their interfaces/ports
781 Params: the list of VM identifiers
782 Returns a dictionary with:
783 vm_id: #VIM id of this Virtual Machine
784 status: #Mandatory. Text with one of:
785 # DELETED (not found at vim)
786 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
787 # OTHER (Vim reported other status not understood)
788 # ERROR (VIM indicates an ERROR status)
789 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
790 # CREATING (on building process), ERROR
791 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
793 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
794 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
796 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
797 mac_address: #Text format XX:XX:XX:XX:XX:XX
798 vim_net_id: #network id where this interface is connected
799 vim_interface_id: #interface/port VIM id
800 ip_address: #null, or text with IPv4, IPv6 address
803 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
804 for vm_id
in vm_list
:
807 vm_vim
= self
.get_vminstance(vm_id
)
808 if vm_vim
['status'] in vmStatus2manoFormat
:
809 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
811 vm
['status'] = "OTHER"
812 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
814 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
815 except yaml
.representer
.RepresenterError
:
816 vm
['vim_info'] = str(vm_vim
)
817 vm
["interfaces"] = []
818 if vm_vim
.get('fault'):
819 vm
['error_msg'] = str(vm_vim
['fault'])
822 self
._reload
_connection
()
823 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
824 for port
in port_dict
["ports"]:
827 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
828 except yaml
.representer
.RepresenterError
:
829 interface
['vim_info'] = str(port
)
830 interface
["mac_address"] = port
.get("mac_address")
831 interface
["vim_net_id"] = port
["network_id"]
832 interface
["vim_interface_id"] = port
["id"]
834 #look for floating ip address
835 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
836 if floating_ip_dict
.get("floatingips"):
837 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
839 for subnet
in port
["fixed_ips"]:
840 ips
.append(subnet
["ip_address"])
841 interface
["ip_address"] = ";".join(ips
)
842 vm
["interfaces"].append(interface
)
843 except Exception as e
:
844 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
845 except vimconn
.vimconnNotFoundException
as e
:
846 self
.logger
.error("Exception getting vm status: %s", str(e
))
847 vm
['status'] = "DELETED"
848 vm
['error_msg'] = str(e
)
849 except vimconn
.vimconnException
as e
:
850 self
.logger
.error("Exception getting vm status: %s", str(e
))
851 vm
['status'] = "VIM_ERROR"
852 vm
['error_msg'] = str(e
)
856 def action_vminstance(self
, vm_id
, action_dict
):
857 '''Send and action over a VM instance from VIM
858 Returns the vm_id if the action was successfully sent to the VIM'''
859 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
861 self
._reload
_connection
()
862 server
= self
.nova
.servers
.find(id=vm_id
)
863 if "start" in action_dict
:
864 if action_dict
["start"]=="rebuild":
867 if server
.status
=="PAUSED":
869 elif server
.status
=="SUSPENDED":
871 elif server
.status
=="SHUTOFF":
873 elif "pause" in action_dict
:
875 elif "resume" in action_dict
:
877 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
879 elif "forceOff" in action_dict
:
881 elif "terminate" in action_dict
:
883 elif "createImage" in action_dict
:
884 server
.create_image()
886 #"description":description_schema,
888 #"metadata":metadata_schema,
889 #"imageRef": id_schema,
890 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
891 elif "rebuild" in action_dict
:
892 server
.rebuild(server
.image
['id'])
893 elif "reboot" in action_dict
:
894 server
.reboot() #reboot_type='SOFT'
895 elif "console" in action_dict
:
896 console_type
= action_dict
["console"]
897 if console_type
== None or console_type
== "novnc":
898 console_dict
= server
.get_vnc_console("novnc")
899 elif console_type
== "xvpvnc":
900 console_dict
= server
.get_vnc_console(console_type
)
901 elif console_type
== "rdp-html5":
902 console_dict
= server
.get_rdp_console(console_type
)
903 elif console_type
== "spice-html5":
904 console_dict
= server
.get_spice_console(console_type
)
906 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
907 http_code
=vimconn
.HTTP_Bad_Request
)
909 console_url
= console_dict
["console"]["url"]
911 protocol_index
= console_url
.find("//")
912 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
913 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
914 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
915 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
916 console_dict2
={"protocol": console_url
[0:protocol_index
],
917 "server": console_url
[protocol_index
+2 : port_index
],
918 "port": int(console_url
[port_index
+1 : suffix_index
]),
919 "suffix": console_url
[suffix_index
+1:]
922 except Exception as e
:
923 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
926 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
927 self
._format
_exception
(e
)
928 #TODO insert exception vimconn.HTTP_Unauthorized
932 def new_external_port(self
, port_data
):
933 #TODO openstack if needed
934 '''Adds a external port to VIM'''
935 '''Returns the port identifier'''
936 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
938 def connect_port_network(self
, port_id
, network_id
, admin
=False):
939 #TODO openstack if needed
940 '''Connects a external port to a network'''
941 '''Returns status code of the VIM response'''
942 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
944 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
945 '''Adds a new user to openstack VIM'''
946 '''Returns the user identifier'''
947 self
.logger
.debug("osconnector: Adding a new user to VIM")
949 self
._reload
_connection
()
950 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
951 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
953 except ksExceptions
.ConnectionError
as e
:
954 error_value
=-vimconn
.HTTP_Bad_Request
955 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
956 except ksExceptions
.ClientException
as e
: #TODO remove
957 error_value
=-vimconn
.HTTP_Bad_Request
958 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
959 #TODO insert exception vimconn.HTTP_Unauthorized
960 #if reaching here is because an exception
962 self
.logger
.debug("new_user " + error_text
)
963 return error_value
, error_text
965 def delete_user(self
, user_id
):
966 '''Delete a user from openstack VIM'''
967 '''Returns the user identifier'''
969 print "osconnector: Deleting a user from VIM"
971 self
._reload
_connection
()
972 self
.keystone
.users
.delete(user_id
)
974 except ksExceptions
.ConnectionError
as e
:
975 error_value
=-vimconn
.HTTP_Bad_Request
976 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
977 except ksExceptions
.NotFound
as e
:
978 error_value
=-vimconn
.HTTP_Not_Found
979 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
980 except ksExceptions
.ClientException
as e
: #TODO remove
981 error_value
=-vimconn
.HTTP_Bad_Request
982 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
983 #TODO insert exception vimconn.HTTP_Unauthorized
984 #if reaching here is because an exception
986 print "delete_tenant " + error_text
987 return error_value
, error_text
989 def get_hosts_info(self
):
990 '''Get the information of deployed hosts
991 Returns the hosts content'''
993 print "osconnector: Getting Host info from VIM"
996 self
._reload
_connection
()
997 hypervisors
= self
.nova
.hypervisors
.list()
998 for hype
in hypervisors
:
999 h_list
.append( hype
.to_dict() )
1000 return 1, {"hosts":h_list
}
1001 except nvExceptions
.NotFound
as e
:
1002 error_value
=-vimconn
.HTTP_Not_Found
1003 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1004 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1005 error_value
=-vimconn
.HTTP_Bad_Request
1006 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1007 #TODO insert exception vimconn.HTTP_Unauthorized
1008 #if reaching here is because an exception
1010 print "get_hosts_info " + error_text
1011 return error_value
, error_text
1013 def get_hosts(self
, vim_tenant
):
1014 '''Get the hosts and deployed instances
1015 Returns the hosts content'''
1016 r
, hype_dict
= self
.get_hosts_info()
1019 hypervisors
= hype_dict
["hosts"]
1021 servers
= self
.nova
.servers
.list()
1022 for hype
in hypervisors
:
1023 for server
in servers
:
1024 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1026 hype
['vm'].append(server
.id)
1028 hype
['vm'] = [server
.id]
1030 except nvExceptions
.NotFound
as e
:
1031 error_value
=-vimconn
.HTTP_Not_Found
1032 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1033 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1034 error_value
=-vimconn
.HTTP_Bad_Request
1035 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1036 #TODO insert exception vimconn.HTTP_Unauthorized
1037 #if reaching here is because an exception
1039 print "get_hosts " + error_text
1040 return error_value
, error_text