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, Pablo Montes, xFlow Research"
28 __date__
="$22-jun-2014 11:19:29$"
37 from novaclient
import client
as nClient_v2
, exceptions
as nvExceptions
, api_versions
as APIVersion
38 import keystoneclient
.v2_0
.client
as ksClient_v2
39 from novaclient
.v2
.client
import Client
as nClient
40 import keystoneclient
.v3
.client
as ksClient
41 import keystoneclient
.exceptions
as ksExceptions
42 import glanceclient
.v2
.client
as glClient
43 import glanceclient
.client
as gl1Client
44 import glanceclient
.exc
as gl1Exceptions
45 import cinderclient
.v2
.client
as cClient_v2
46 from httplib
import HTTPException
47 from neutronclient
.neutron
import client
as neClient_v2
48 from neutronclient
.v2_0
import client
as neClient
49 from neutronclient
.common
import exceptions
as neExceptions
50 from requests
.exceptions
import ConnectionError
52 '''contain the openstack virtual machine status to openmano status'''
53 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
55 'SUSPENDED': 'SUSPENDED',
58 'ERROR':'ERROR','DELETED':'DELETED'
60 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
63 #global var to have a timeout creating and deleting volumes
66 class vimconnector(vimconn
.vimconnector
):
67 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None, log_level
=None, config
={}):
68 '''using common constructor parameters. In this case
69 'url' is the keystone authorization url,
70 'url_admin' is not use
72 self
.osc_api_version
= 'v2.0'
73 if config
.get('APIversion') == 'v3.3':
74 self
.osc_api_version
= 'v3.3'
75 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
80 raise TypeError, 'url param can not be NoneType'
81 self
.k_creds
['auth_url'] = url
82 self
.n_creds
['auth_url'] = url
84 self
.k_creds
['tenant_name'] = tenant_name
85 self
.n_creds
['project_id'] = tenant_name
87 self
.k_creds
['tenant_id'] = tenant_id
88 self
.n_creds
['tenant_id'] = tenant_id
90 self
.k_creds
['username'] = user
91 self
.n_creds
['username'] = user
93 self
.k_creds
['password'] = passwd
94 self
.n_creds
['api_key'] = passwd
95 if self
.osc_api_version
== 'v3.3':
96 self
.k_creds
['project_name'] = tenant_name
97 self
.k_creds
['project_id'] = tenant_id
99 self
.reload_client
= True
100 self
.logger
= logging
.getLogger('openmano.vim.openstack')
102 self
.logger
.setLevel( getattr(logging
, log_level
) )
104 def __setitem__(self
,index
, value
):
105 '''Set individuals parameters
106 Throw TypeError, KeyError
108 if index
=='tenant_id':
109 self
.reload_client
=True
110 self
.tenant_id
= value
111 if self
.osc_api_version
== 'v3.3':
113 self
.k_creds
['project_id'] = value
114 self
.n_creds
['project_id'] = value
116 del self
.k_creds
['project_id']
117 del self
.n_creds
['project_id']
120 self
.k_creds
['tenant_id'] = value
121 self
.n_creds
['tenant_id'] = value
123 del self
.k_creds
['tenant_id']
124 del self
.n_creds
['tenant_id']
125 elif index
=='tenant_name':
126 self
.reload_client
=True
127 self
.tenant_name
= value
128 if self
.osc_api_version
== 'v3.3':
130 self
.k_creds
['project_name'] = value
131 self
.n_creds
['project_name'] = value
133 del self
.k_creds
['project_name']
134 del self
.n_creds
['project_name']
137 self
.k_creds
['tenant_name'] = value
138 self
.n_creds
['project_id'] = value
140 del self
.k_creds
['tenant_name']
141 del self
.n_creds
['project_id']
143 self
.reload_client
=True
146 self
.k_creds
['username'] = value
147 self
.n_creds
['username'] = value
149 del self
.k_creds
['username']
150 del self
.n_creds
['username']
151 elif index
=='passwd':
152 self
.reload_client
=True
155 self
.k_creds
['password'] = value
156 self
.n_creds
['api_key'] = value
158 del self
.k_creds
['password']
159 del self
.n_creds
['api_key']
161 self
.reload_client
=True
164 self
.k_creds
['auth_url'] = value
165 self
.n_creds
['auth_url'] = value
167 raise TypeError, 'url param can not be NoneType'
169 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
171 def _reload_connection(self
):
172 '''Called before any operation, it check if credentials has changed
173 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
175 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
176 if self
.reload_client
:
178 if len(self
.n_creds
) <4:
179 raise ksExceptions
.ClientException("Not enough parameters to connect to openstack")
180 if self
.osc_api_version
== 'v3.3':
181 self
.nova
= nClient(APIVersion(version_str
='2'), **self
.n_creds
)
182 #TODO To be updated for v3
183 #self.cinder = cClient.Client(**self.n_creds)
184 self
.keystone
= ksClient
.Client(**self
.k_creds
)
185 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
186 self
.neutron
= neClient
.Client(APIVersion(version_str
='2'), endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
188 self
.nova
= nClient_v2
.Client('2', **self
.n_creds
)
189 self
.cinder
= cClient_v2
.Client(**self
.n_creds
)
190 self
.keystone
= ksClient_v2
.Client(**self
.k_creds
)
191 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
192 self
.neutron
= neClient_v2
.Client('2.0', endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
193 self
.glance_endpoint
= self
.keystone
.service_catalog
.url_for(service_type
='image', endpoint_type
='publicURL')
194 self
.glance
= glClient
.Client(self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
195 self
.reload_client
= False
197 def __net_os2mano(self
, net_list_dict
):
198 '''Transform the net openstack format to mano format
199 net_list_dict can be a list of dict or a single dict'''
200 if type(net_list_dict
) is dict:
201 net_list_
=(net_list_dict
,)
202 elif type(net_list_dict
) is list:
203 net_list_
=net_list_dict
205 raise TypeError("param net_list_dict must be a list or a dictionary")
206 for net
in net_list_
:
207 if net
.get('provider:network_type') == "vlan":
214 def _format_exception(self
, exception
):
215 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
216 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
217 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
219 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
220 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
221 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
222 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
223 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
224 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
225 elif isinstance(exception
, nvExceptions
.Conflict
):
226 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
228 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
230 def get_tenant_list(self
, filter_dict
={}):
231 '''Obtain tenants of VIM
232 filter_dict can contain the following keys:
233 name: filter by tenant name
234 id: filter by tenant uuid/id
236 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
238 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
240 self
._reload
_connection
()
241 if self
.osc_api_version
== 'v3.3':
242 project_class_list
=self
.keystone
.projects
.findall(**filter_dict
)
244 project_class_list
=self
.keystone
.tenants
.findall(**filter_dict
)
246 for project
in project_class_list
:
247 project_list
.append(project
.to_dict())
249 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
250 self
._format
_exception
(e
)
252 def new_tenant(self
, tenant_name
, tenant_description
):
253 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
254 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
256 self
._reload
_connection
()
257 if self
.osc_api_version
== 'v3.3':
258 project
=self
.keystone
.projects
.create(tenant_name
, tenant_description
)
260 project
=self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
262 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
263 self
._format
_exception
(e
)
265 def delete_tenant(self
, tenant_id
):
266 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
267 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
269 self
._reload
_connection
()
270 if self
.osc_api_version
== 'v3.3':
271 self
.keystone
.projects
.delete(tenant_id
)
273 self
.keystone
.tenants
.delete(tenant_id
)
275 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
276 self
._format
_exception
(e
)
278 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
279 '''Adds a tenant network to VIM. Returns the network identifier'''
280 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
281 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
284 self
._reload
_connection
()
285 network_dict
= {'name': net_name
, 'admin_state_up': True}
286 if net_type
=="data" or net_type
=="ptp":
287 if self
.config
.get('dataplane_physical_net') == None:
288 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
289 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
290 network_dict
["provider:network_type"] = "vlan"
292 network_dict
["provider:network_type"] = vlan
293 network_dict
["shared"]=shared
294 new_net
=self
.neutron
.create_network({'network':network_dict
})
296 #create subnetwork, even if there is no profile
299 if 'subnet_address' not in ip_profile
:
300 #Fake subnet is required
301 ip_profile
['subnet_address'] = "192.168.111.0/24"
302 if 'ip_version' not in ip_profile
:
303 ip_profile
['ip_version'] = "IPv4"
304 subnet
={"name":net_name
+"-subnet",
305 "network_id": new_net
["network"]["id"],
306 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
307 "cidr": ip_profile
['subnet_address']
309 if 'gateway_address' in ip_profile
:
310 subnet
['gateway_ip'] = ip_profile
['gateway_address']
311 if ip_profile
.get('dns_address'):
312 #TODO: manage dns_address as a list of addresses separated by commas
313 subnet
['dns_nameservers'] = []
314 subnet
['dns_nameservers'].append(ip_profile
['dns_address'])
315 if 'dhcp_enabled' in ip_profile
:
316 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
317 if 'dhcp_start_address' in ip_profile
:
318 subnet
['allocation_pools']=[]
319 subnet
['allocation_pools'].append(dict())
320 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
321 if 'dhcp_count' in ip_profile
:
322 #parts = ip_profile['dhcp_start_address'].split('.')
323 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
324 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
325 ip_int
+= ip_profile
['dhcp_count'] - 1
326 ip_str
= str(netaddr
.IPAddress(ip_int
))
327 subnet
['allocation_pools'][0]['end'] = ip_str
328 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
329 self
.neutron
.create_subnet({"subnet": subnet
} )
330 return new_net
["network"]["id"]
331 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
333 self
.neutron
.delete_network(new_net
['network']['id'])
334 self
._format
_exception
(e
)
336 def get_network_list(self
, filter_dict
={}):
337 '''Obtain tenant networks of VIM
343 admin_state_up: boolean
345 Returns the network list of dictionaries
347 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
349 self
._reload
_connection
()
350 if self
.osc_api_version
== 'v3.3' and "tenant_id" in filter_dict
:
351 filter_dict
['project_id'] = filter_dict
.pop('tenant_id')
352 net_dict
=self
.neutron
.list_networks(**filter_dict
)
353 net_list
=net_dict
["networks"]
354 self
.__net
_os
2mano
(net_list
)
356 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
357 self
._format
_exception
(e
)
359 def get_network(self
, net_id
):
360 '''Obtain details of network from VIM
361 Returns the network information from a network id'''
362 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
363 filter_dict
={"id": net_id
}
364 net_list
= self
.get_network_list(filter_dict
)
366 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
367 elif len(net_list
)>1:
368 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
371 for subnet_id
in net
.get("subnets", () ):
373 subnet
= self
.neutron
.show_subnet(subnet_id
)
374 except Exception as e
:
375 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
376 subnet
= {"id": subnet_id
, "fault": str(e
)}
377 subnets
.append(subnet
)
378 net
["subnets"] = subnets
381 def delete_network(self
, net_id
):
382 '''Deletes a tenant network from VIM. Returns the old network identifier'''
383 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
385 self
._reload
_connection
()
386 #delete VM ports attached to this networks before the network
387 ports
= self
.neutron
.list_ports(network_id
=net_id
)
388 for p
in ports
['ports']:
390 self
.neutron
.delete_port(p
["id"])
391 except Exception as e
:
392 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
393 self
.neutron
.delete_network(net_id
)
395 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
396 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
397 self
._format
_exception
(e
)
399 def refresh_nets_status(self
, net_list
):
400 '''Get the status of the networks
401 Params: the list of network identifiers
402 Returns a dictionary with:
403 net_id: #VIM id of this network
404 status: #Mandatory. Text with one of:
405 # DELETED (not found at vim)
406 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
407 # OTHER (Vim reported other status not understood)
408 # ERROR (VIM indicates an ERROR status)
409 # ACTIVE, INACTIVE, DOWN (admin down),
410 # BUILD (on building process)
412 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
413 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
417 for net_id
in net_list
:
420 net_vim
= self
.get_network(net_id
)
421 if net_vim
['status'] in netStatus2manoFormat
:
422 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
424 net
["status"] = "OTHER"
425 net
["error_msg"] = "VIM status reported " + net_vim
['status']
427 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
428 net
['status'] = 'DOWN'
430 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
431 except yaml
.representer
.RepresenterError
:
432 net
['vim_info'] = str(net_vim
)
433 if net_vim
.get('fault'): #TODO
434 net
['error_msg'] = str(net_vim
['fault'])
435 except vimconn
.vimconnNotFoundException
as e
:
436 self
.logger
.error("Exception getting net status: %s", str(e
))
437 net
['status'] = "DELETED"
438 net
['error_msg'] = str(e
)
439 except vimconn
.vimconnException
as e
:
440 self
.logger
.error("Exception getting net status: %s", str(e
))
441 net
['status'] = "VIM_ERROR"
442 net
['error_msg'] = str(e
)
443 net_dict
[net_id
] = net
446 def get_flavor(self
, flavor_id
):
447 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
448 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
450 self
._reload
_connection
()
451 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
452 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
453 return flavor
.to_dict()
454 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
455 self
._format
_exception
(e
)
457 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
458 '''Adds a tenant flavor to openstack VIM
459 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
460 Returns the flavor identifier
462 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
466 name
=flavor_data
['name']
467 while retry
<max_retries
:
470 self
._reload
_connection
()
471 if change_name_if_used
:
474 fl
=self
.nova
.flavors
.list()
476 fl_names
.append(f
.name
)
477 while name
in fl_names
:
479 name
= flavor_data
['name']+"-" + str(name_suffix
)
481 ram
= flavor_data
.get('ram',64)
482 vcpus
= flavor_data
.get('vcpus',1)
485 extended
= flavor_data
.get("extended")
487 numas
=extended
.get("numas")
489 numa_nodes
= len(numas
)
491 return -1, "Can not add flavor with more than one numa"
492 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
493 numa_properties
["hw:mem_page_size"] = "large"
494 numa_properties
["hw:cpu_policy"] = "dedicated"
495 numa_properties
["hw:numa_mempolicy"] = "strict"
497 #overwrite ram and vcpus
498 ram
= numa
['memory']*1024
499 if 'paired-threads' in numa
:
500 vcpus
= numa
['paired-threads']*2
501 numa_properties
["hw:cpu_threads_policy"] = "prefer"
502 elif 'cores' in numa
:
503 vcpus
= numa
['cores']
504 #numa_properties["hw:cpu_threads_policy"] = "prefer"
505 elif 'threads' in numa
:
506 vcpus
= numa
['threads']
507 numa_properties
["hw:cpu_policy"] = "isolated"
508 for interface
in numa
.get("interfaces",() ):
509 if interface
["dedicated"]=="yes":
510 raise vimconn
.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code
=vimconn
.HTTP_Service_Unavailable
)
511 #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
514 new_flavor
=self
.nova
.flavors
.create(name
,
517 flavor_data
.get('disk',1),
518 is_public
=flavor_data
.get('is_public', True)
522 new_flavor
.set_keys(numa_properties
)
524 except nvExceptions
.Conflict
as e
:
525 if change_name_if_used
and retry
< max_retries
:
527 self
._format
_exception
(e
)
528 #except nvExceptions.BadRequest as e:
529 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
530 self
._format
_exception
(e
)
532 def delete_flavor(self
,flavor_id
):
533 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
536 self
._reload
_connection
()
537 self
.nova
.flavors
.delete(flavor_id
)
539 #except nvExceptions.BadRequest as e:
540 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
541 self
._format
_exception
(e
)
543 def new_image(self
,image_dict
):
545 Adds a tenant image to VIM. imge_dict is a dictionary with:
547 disk_format: qcow2, vhd, vmdk, raw (by default), ...
548 location: path or URI
549 public: "yes" or "no"
550 metadata: metadata of the image
553 #using version 1 of glance client
554 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
557 while retry
<max_retries
:
560 self
._reload
_connection
()
561 #determine format http://docs.openstack.org/developer/glance/formats.html
562 if "disk_format" in image_dict
:
563 disk_format
=image_dict
["disk_format"]
564 else: #autodiscover base on extention
565 if image_dict
['location'][-6:]==".qcow2":
567 elif image_dict
['location'][-4:]==".vhd":
569 elif image_dict
['location'][-5:]==".vmdk":
571 elif image_dict
['location'][-4:]==".vdi":
573 elif image_dict
['location'][-4:]==".iso":
575 elif image_dict
['location'][-4:]==".aki":
577 elif image_dict
['location'][-4:]==".ari":
579 elif image_dict
['location'][-4:]==".ami":
583 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
584 if image_dict
['location'][0:4]=="http":
585 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
586 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
588 with
open(image_dict
['location']) as fimage
:
589 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
590 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
591 #insert metadata. We cannot use 'new_image.properties.setdefault'
592 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
593 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
594 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
595 metadata_to_load
= image_dict
.get('metadata')
597 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
598 new_image_nova
.metadata
.setdefault(k
,v
)
600 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
601 self
._format
_exception
(e
)
602 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
603 if retry
==max_retries
:
605 self
._format
_exception
(e
)
606 except IOError as e
: #can not open the file
607 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
608 http_code
=vimconn
.HTTP_Bad_Request
)
610 def delete_image(self
, image_id
):
611 '''Deletes a tenant image from openstack VIM. Returns the old id
614 self
._reload
_connection
()
615 self
.nova
.images
.delete(image_id
)
617 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
618 self
._format
_exception
(e
)
620 def get_image_id_from_path(self
, path
):
621 '''Get the image id from image path in the VIM database. Returns the image_id'''
623 self
._reload
_connection
()
624 images
= self
.nova
.images
.list()
626 if image
.metadata
.get("location")==path
:
628 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
629 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
630 self
._format
_exception
(e
)
632 def get_image_list(self
, filter_dict
={}):
633 '''Obtain tenant images from VIM
637 checksum: image checksum
638 Returns the image list of dictionaries:
639 [{<the fields at Filter_dict plus some VIM specific>}, ...]
642 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
644 self
._reload
_connection
()
645 filter_dict_os
=filter_dict
.copy()
646 #First we filter by the available filter fields: name, id. The others are removed.
647 filter_dict_os
.pop('checksum',None)
648 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
649 if len(image_list
)==0:
651 #Then we filter by the rest of filter fields: checksum
653 for image
in image_list
:
654 image_dict
=self
.glance
.images
.get(image
.id)
655 if 'checksum' in filter_dict
and image_dict
['checksum']==filter_dict
.get('checksum'):
656 filtered_list
.append(image
)
658 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
659 self
._format
_exception
(e
)
661 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
662 '''Adds a VM instance to VIM
664 start: indicates if VM must start or boot in pause mode. Ignored
665 image_id,flavor_id: iamge and flavor uuid
666 net_list: list of interfaces, each one is a dictionary with:
668 net_id: network uuid to connect
669 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
670 model: interface model, ignored #TODO
671 mac_address: used for SR-IOV ifaces #TODO for other types
672 use: 'data', 'bridge', 'mgmt'
673 type: 'virtual', 'PF', 'VF', 'VFnotShared'
674 vim_id: filled/added by this function
675 floating_ip: True/False (or it can be None)
676 #TODO ip, security groups
677 Returns the instance identifier
679 self
.logger
.debug("Creating VM image '%s' flavor '%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
683 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
684 self
._reload
_connection
()
685 metadata_vpci
={} #For a specific neutron plugin
687 if not net
.get("net_id"): #skip non connected iface
689 if net
["type"]=="virtual" or net
["type"]=="VF":
691 "network_id": net
["net_id"],
692 "name": net
.get("name"),
693 "admin_state_up": True
695 if net
["type"]=="virtual":
697 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
700 if "VF" not in metadata_vpci
:
701 metadata_vpci
["VF"]=[]
702 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
703 port_dict
["binding:vnic_type"]="direct"
704 if not port_dict
["name"]:
705 port_dict
["name"]=name
706 if net
.get("mac_address"):
707 port_dict
["mac_address"]=net
["mac_address"]
708 new_port
= self
.neutron
.create_port({"port": port_dict
})
709 net
["mac_adress"] = new_port
["port"]["mac_address"]
710 net
["vim_id"] = new_port
["port"]["id"]
711 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
712 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
714 self
.logger
.warn("new_vminstance: Warning, can not connect a passthrough interface ")
715 #TODO insert this when openstack consider passthrough ports as openstack neutron ports
716 if net
.get('floating_ip', False):
717 external_network
.append(net
)
720 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
721 if len(metadata
["pci_assignement"]) >255:
722 #limit the metadata size
723 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
724 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
727 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
728 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
730 security_groups
= self
.config
.get('security_groups')
731 if type(security_groups
) is str:
732 security_groups
= ( security_groups
, )
733 if isinstance(cloud_config
, dict):
734 userdata
="#cloud-config\nusers:\n"
736 if "key-pairs" in cloud_config
:
737 userdata
+= " - default:\n ssh-authorized-keys:\n"
738 for key
in cloud_config
["key-pairs"]:
739 userdata
+= " - '{key}'\n".format(key
=key
)
740 for user
in cloud_config
.get("users",[]):
741 userdata
+= " - name: {name}\n sudo: ALL=(ALL) NOPASSWD:ALL\n".format(name
=user
["name"])
742 if "user-info" in user
:
743 userdata
+= " gecos: {}'\n".format(user
["user-info"])
744 if user
.get("key-pairs"):
745 userdata
+= " ssh-authorized-keys:\n"
746 for key
in user
["key-pairs"]:
747 userdata
+= " - '{key}'\n".format(key
=key
)
748 self
.logger
.debug("userdata: %s", userdata
)
749 elif isinstance(cloud_config
, str):
750 userdata
= cloud_config
754 #Create additional volumes in case these are present in disk_list
755 block_device_mapping
= None
756 base_disk_index
= ord('b')
757 if disk_list
!= None:
758 block_device_mapping
= dict()
759 for disk
in disk_list
:
760 if 'image_id' in disk
:
761 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
762 chr(base_disk_index
), imageRef
= disk
['image_id'])
764 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
765 chr(base_disk_index
))
766 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
769 #wait until volumes are with status available
772 while keep_waiting
and elapsed_time
< volume_timeout
:
774 for volume_id
in block_device_mapping
.itervalues():
775 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
781 #if we exceeded the timeout rollback
782 if elapsed_time
>= volume_timeout
:
783 #delete the volumes we just created
784 for volume_id
in block_device_mapping
.itervalues():
785 self
.cinder
.volumes
.delete(volume_id
)
787 #delete ports we just created
788 for net_item
in net_list_vim
:
789 if 'port-id' in net_item
:
790 self
.neutron
.delete_port(net_item
['port_id'])
792 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
793 http_code
=vimconn
.HTTP_Request_Timeout
)
795 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
796 security_groups
=security_groups
,
797 availability_zone
=self
.config
.get('availability_zone'),
798 key_name
=self
.config
.get('keypair'),
800 block_device_mapping
= block_device_mapping
801 ) # , description=description)
802 #print "DONE :-)", server
805 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
806 for floating_network
in external_network
:
808 while(assigned
== False):
810 ip
= floating_ips
.pop(0)
811 if not ip
.get("port_id", False):
812 free_floating_ip
= ip
.get("floating_ip_address")
814 fix_ip
= floating_network
.get('ip')
815 server
.add_floating_ip(free_floating_ip
, fix_ip
)
817 except Exception as e
:
818 self
.delete_vminstance(server
.id)
819 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
821 pool_id
= floating_network
.get('net_id')
822 param
= {'floatingip': {'floating_network_id': pool_id
}}
824 #self.logger.debug("Creating floating IP")
825 new_floating_ip
= self
.neutron
.create_floatingip(param
)
826 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
827 fix_ip
= floating_network
.get('ip')
828 server
.add_floating_ip(free_floating_ip
, fix_ip
)
830 except Exception as e
:
831 self
.delete_vminstance(server
.id)
832 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
835 # except nvExceptions.NotFound as e:
836 # error_value=-vimconn.HTTP_Not_Found
837 # error_text= "vm instance %s not found" % vm_id
838 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
840 self
._format
_exception
(e
)
841 except TypeError as e
:
842 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
844 def get_vminstance(self
,vm_id
):
845 '''Returns the VM instance information from VIM'''
846 #self.logger.debug("Getting VM from VIM")
848 self
._reload
_connection
()
849 server
= self
.nova
.servers
.find(id=vm_id
)
850 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
851 return server
.to_dict()
852 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
853 self
._format
_exception
(e
)
855 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
857 Get a console for the virtual machine
859 vm_id: uuid of the VM
860 console_type, can be:
861 "novnc" (by default), "xvpvnc" for VNC types,
862 "rdp-html5" for RDP types, "spice-html5" for SPICE types
863 Returns dict with the console parameters:
864 protocol: ssh, ftp, http, https, ...
865 server: usually ip address
866 port: the http, ssh, ... port
867 suffix: extra text, e.g. the http path and query string
869 self
.logger
.debug("Getting VM CONSOLE from VIM")
871 self
._reload
_connection
()
872 server
= self
.nova
.servers
.find(id=vm_id
)
873 if console_type
== None or console_type
== "novnc":
874 console_dict
= server
.get_vnc_console("novnc")
875 elif console_type
== "xvpvnc":
876 console_dict
= server
.get_vnc_console(console_type
)
877 elif console_type
== "rdp-html5":
878 console_dict
= server
.get_rdp_console(console_type
)
879 elif console_type
== "spice-html5":
880 console_dict
= server
.get_spice_console(console_type
)
882 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
884 console_dict1
= console_dict
.get("console")
886 console_url
= console_dict1
.get("url")
889 protocol_index
= console_url
.find("//")
890 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
891 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
892 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
893 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
894 console_dict
={"protocol": console_url
[0:protocol_index
],
895 "server": console_url
[protocol_index
+2:port_index
],
896 "port": console_url
[port_index
:suffix_index
],
897 "suffix": console_url
[suffix_index
+1:]
901 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
903 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
904 self
._format
_exception
(e
)
906 def delete_vminstance(self
, vm_id
):
907 '''Removes a VM instance from VIM. Returns the old identifier
909 #print "osconnector: Getting VM from VIM"
911 self
._reload
_connection
()
912 #delete VM ports attached to this networks before the virtual machine
913 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
914 for p
in ports
['ports']:
916 self
.neutron
.delete_port(p
["id"])
917 except Exception as e
:
918 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
920 #commented because detaching the volumes makes the servers.delete not work properly ?!?
921 #dettach volumes attached
922 server
= self
.nova
.servers
.get(vm_id
)
923 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
924 #for volume in volumes_attached_dict:
925 # self.cinder.volumes.detach(volume['id'])
927 self
.nova
.servers
.delete(vm_id
)
930 #Although having detached them should have them in active status
931 #we ensure in this loop
934 while keep_waiting
and elapsed_time
< volume_timeout
:
936 for volume
in volumes_attached_dict
:
937 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
940 self
.cinder
.volumes
.delete(volume
['id'])
946 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
947 self
._format
_exception
(e
)
948 #TODO insert exception vimconn.HTTP_Unauthorized
949 #if reaching here is because an exception
951 def refresh_vms_status(self
, vm_list
):
952 '''Get the status of the virtual machines and their interfaces/ports
953 Params: the list of VM identifiers
954 Returns a dictionary with:
955 vm_id: #VIM id of this Virtual Machine
956 status: #Mandatory. Text with one of:
957 # DELETED (not found at vim)
958 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
959 # OTHER (Vim reported other status not understood)
960 # ERROR (VIM indicates an ERROR status)
961 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
962 # CREATING (on building process), ERROR
963 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
965 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
966 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
968 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
969 mac_address: #Text format XX:XX:XX:XX:XX:XX
970 vim_net_id: #network id where this interface is connected
971 vim_interface_id: #interface/port VIM id
972 ip_address: #null, or text with IPv4, IPv6 address
975 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
976 for vm_id
in vm_list
:
979 vm_vim
= self
.get_vminstance(vm_id
)
980 if vm_vim
['status'] in vmStatus2manoFormat
:
981 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
983 vm
['status'] = "OTHER"
984 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
986 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
987 except yaml
.representer
.RepresenterError
:
988 vm
['vim_info'] = str(vm_vim
)
989 vm
["interfaces"] = []
990 if vm_vim
.get('fault'):
991 vm
['error_msg'] = str(vm_vim
['fault'])
994 self
._reload
_connection
()
995 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
996 for port
in port_dict
["ports"]:
999 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1000 except yaml
.representer
.RepresenterError
:
1001 interface
['vim_info'] = str(port
)
1002 interface
["mac_address"] = port
.get("mac_address")
1003 interface
["vim_net_id"] = port
["network_id"]
1004 interface
["vim_interface_id"] = port
["id"]
1006 #look for floating ip address
1007 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1008 if floating_ip_dict
.get("floatingips"):
1009 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1011 for subnet
in port
["fixed_ips"]:
1012 ips
.append(subnet
["ip_address"])
1013 interface
["ip_address"] = ";".join(ips
)
1014 vm
["interfaces"].append(interface
)
1015 except Exception as e
:
1016 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1017 except vimconn
.vimconnNotFoundException
as e
:
1018 self
.logger
.error("Exception getting vm status: %s", str(e
))
1019 vm
['status'] = "DELETED"
1020 vm
['error_msg'] = str(e
)
1021 except vimconn
.vimconnException
as e
:
1022 self
.logger
.error("Exception getting vm status: %s", str(e
))
1023 vm
['status'] = "VIM_ERROR"
1024 vm
['error_msg'] = str(e
)
1028 def action_vminstance(self
, vm_id
, action_dict
):
1029 '''Send and action over a VM instance from VIM
1030 Returns the vm_id if the action was successfully sent to the VIM'''
1031 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1033 self
._reload
_connection
()
1034 server
= self
.nova
.servers
.find(id=vm_id
)
1035 if "start" in action_dict
:
1036 if action_dict
["start"]=="rebuild":
1039 if server
.status
=="PAUSED":
1041 elif server
.status
=="SUSPENDED":
1043 elif server
.status
=="SHUTOFF":
1045 elif "pause" in action_dict
:
1047 elif "resume" in action_dict
:
1049 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1051 elif "forceOff" in action_dict
:
1053 elif "terminate" in action_dict
:
1055 elif "createImage" in action_dict
:
1056 server
.create_image()
1057 #"path":path_schema,
1058 #"description":description_schema,
1059 #"name":name_schema,
1060 #"metadata":metadata_schema,
1061 #"imageRef": id_schema,
1062 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1063 elif "rebuild" in action_dict
:
1064 server
.rebuild(server
.image
['id'])
1065 elif "reboot" in action_dict
:
1066 server
.reboot() #reboot_type='SOFT'
1067 elif "console" in action_dict
:
1068 console_type
= action_dict
["console"]
1069 if console_type
== None or console_type
== "novnc":
1070 console_dict
= server
.get_vnc_console("novnc")
1071 elif console_type
== "xvpvnc":
1072 console_dict
= server
.get_vnc_console(console_type
)
1073 elif console_type
== "rdp-html5":
1074 console_dict
= server
.get_rdp_console(console_type
)
1075 elif console_type
== "spice-html5":
1076 console_dict
= server
.get_spice_console(console_type
)
1078 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1079 http_code
=vimconn
.HTTP_Bad_Request
)
1081 console_url
= console_dict
["console"]["url"]
1083 protocol_index
= console_url
.find("//")
1084 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1085 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1086 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1087 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1088 console_dict2
={"protocol": console_url
[0:protocol_index
],
1089 "server": console_url
[protocol_index
+2 : port_index
],
1090 "port": int(console_url
[port_index
+1 : suffix_index
]),
1091 "suffix": console_url
[suffix_index
+1:]
1093 return console_dict2
1094 except Exception as e
:
1095 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1098 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1099 self
._format
_exception
(e
)
1100 #TODO insert exception vimconn.HTTP_Unauthorized
1104 def new_external_port(self
, port_data
):
1105 #TODO openstack if needed
1106 '''Adds a external port to VIM'''
1107 '''Returns the port identifier'''
1108 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1110 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1111 #TODO openstack if needed
1112 '''Connects a external port to a network'''
1113 '''Returns status code of the VIM response'''
1114 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1116 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1117 '''Adds a new user to openstack VIM'''
1118 '''Returns the user identifier'''
1119 self
.logger
.debug("osconnector: Adding a new user to VIM")
1121 self
._reload
_connection
()
1122 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1123 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1125 except ksExceptions
.ConnectionError
as e
:
1126 error_value
=-vimconn
.HTTP_Bad_Request
1127 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1128 except ksExceptions
.ClientException
as e
: #TODO remove
1129 error_value
=-vimconn
.HTTP_Bad_Request
1130 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1131 #TODO insert exception vimconn.HTTP_Unauthorized
1132 #if reaching here is because an exception
1134 self
.logger
.debug("new_user " + error_text
)
1135 return error_value
, error_text
1137 def delete_user(self
, user_id
):
1138 '''Delete a user from openstack VIM'''
1139 '''Returns the user identifier'''
1141 print "osconnector: Deleting a user from VIM"
1143 self
._reload
_connection
()
1144 self
.keystone
.users
.delete(user_id
)
1146 except ksExceptions
.ConnectionError
as e
:
1147 error_value
=-vimconn
.HTTP_Bad_Request
1148 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1149 except ksExceptions
.NotFound
as e
:
1150 error_value
=-vimconn
.HTTP_Not_Found
1151 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1152 except ksExceptions
.ClientException
as e
: #TODO remove
1153 error_value
=-vimconn
.HTTP_Bad_Request
1154 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1155 #TODO insert exception vimconn.HTTP_Unauthorized
1156 #if reaching here is because an exception
1158 print "delete_tenant " + error_text
1159 return error_value
, error_text
1161 def get_hosts_info(self
):
1162 '''Get the information of deployed hosts
1163 Returns the hosts content'''
1165 print "osconnector: Getting Host info from VIM"
1168 self
._reload
_connection
()
1169 hypervisors
= self
.nova
.hypervisors
.list()
1170 for hype
in hypervisors
:
1171 h_list
.append( hype
.to_dict() )
1172 return 1, {"hosts":h_list
}
1173 except nvExceptions
.NotFound
as e
:
1174 error_value
=-vimconn
.HTTP_Not_Found
1175 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1176 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1177 error_value
=-vimconn
.HTTP_Bad_Request
1178 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1179 #TODO insert exception vimconn.HTTP_Unauthorized
1180 #if reaching here is because an exception
1182 print "get_hosts_info " + error_text
1183 return error_value
, error_text
1185 def get_hosts(self
, vim_tenant
):
1186 '''Get the hosts and deployed instances
1187 Returns the hosts content'''
1188 r
, hype_dict
= self
.get_hosts_info()
1191 hypervisors
= hype_dict
["hosts"]
1193 servers
= self
.nova
.servers
.list()
1194 for hype
in hypervisors
:
1195 for server
in servers
:
1196 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1198 hype
['vm'].append(server
.id)
1200 hype
['vm'] = [server
.id]
1202 except nvExceptions
.NotFound
as e
:
1203 error_value
=-vimconn
.HTTP_Not_Found
1204 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1205 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1206 error_value
=-vimconn
.HTTP_Bad_Request
1207 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1208 #TODO insert exception vimconn.HTTP_Unauthorized
1209 #if reaching here is because an exception
1211 print "get_hosts " + error_text
1212 return error_value
, error_text