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$"
38 from novaclient
import client
as nClient_v2
, exceptions
as nvExceptions
, api_versions
as APIVersion
39 import keystoneclient
.v2_0
.client
as ksClient_v2
40 from novaclient
.v2
.client
import Client
as nClient
41 import keystoneclient
.v3
.client
as ksClient
42 import keystoneclient
.exceptions
as ksExceptions
43 import glanceclient
.v2
.client
as glClient
44 import glanceclient
.client
as gl1Client
45 import glanceclient
.exc
as gl1Exceptions
46 import cinderclient
.v2
.client
as cClient_v2
47 from httplib
import HTTPException
48 from neutronclient
.neutron
import client
as neClient_v2
49 from neutronclient
.v2_0
import client
as neClient
50 from neutronclient
.common
import exceptions
as neExceptions
51 from requests
.exceptions
import ConnectionError
53 '''contain the openstack virtual machine status to openmano status'''
54 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
56 'SUSPENDED': 'SUSPENDED',
59 'ERROR':'ERROR','DELETED':'DELETED'
61 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
64 #global var to have a timeout creating and deleting volumes
68 class vimconnector(vimconn
.vimconnector
):
69 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None, log_level
=None, config
={}):
70 '''using common constructor parameters. In this case
71 'url' is the keystone authorization url,
72 'url_admin' is not use
74 self
.osc_api_version
= 'v2.0'
75 if config
.get('APIversion') == 'v3.3':
76 self
.osc_api_version
= 'v3.3'
77 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
81 if self
.config
.get("insecure"):
82 self
.k_creds
["insecure"] = True
83 self
.n_creds
["insecure"] = True
85 raise TypeError, 'url param can not be NoneType'
86 self
.k_creds
['auth_url'] = url
87 self
.n_creds
['auth_url'] = url
89 self
.k_creds
['tenant_name'] = tenant_name
90 self
.n_creds
['project_id'] = tenant_name
92 self
.k_creds
['tenant_id'] = tenant_id
93 self
.n_creds
['tenant_id'] = tenant_id
95 self
.k_creds
['username'] = user
96 self
.n_creds
['username'] = user
98 self
.k_creds
['password'] = passwd
99 self
.n_creds
['api_key'] = passwd
100 if self
.osc_api_version
== 'v3.3':
101 self
.k_creds
['project_name'] = tenant_name
102 self
.k_creds
['project_id'] = tenant_id
103 if config
.get('region_name'):
104 self
.k_creds
['region_name'] = config
.get('region_name')
105 self
.n_creds
['region_name'] = config
.get('region_name')
107 self
.reload_client
= True
108 self
.logger
= logging
.getLogger('openmano.vim.openstack')
110 self
.logger
.setLevel( getattr(logging
, log_level
) )
112 def __setitem__(self
,index
, value
):
113 '''Set individuals parameters
114 Throw TypeError, KeyError
116 if index
=='tenant_id':
117 self
.reload_client
=True
118 self
.tenant_id
= value
119 if self
.osc_api_version
== 'v3.3':
121 self
.k_creds
['project_id'] = value
122 self
.n_creds
['project_id'] = value
124 del self
.k_creds
['project_id']
125 del self
.n_creds
['project_id']
128 self
.k_creds
['tenant_id'] = value
129 self
.n_creds
['tenant_id'] = value
131 del self
.k_creds
['tenant_id']
132 del self
.n_creds
['tenant_id']
133 elif index
=='tenant_name':
134 self
.reload_client
=True
135 self
.tenant_name
= value
136 if self
.osc_api_version
== 'v3.3':
138 self
.k_creds
['project_name'] = value
139 self
.n_creds
['project_name'] = value
141 del self
.k_creds
['project_name']
142 del self
.n_creds
['project_name']
145 self
.k_creds
['tenant_name'] = value
146 self
.n_creds
['project_id'] = value
148 del self
.k_creds
['tenant_name']
149 del self
.n_creds
['project_id']
151 self
.reload_client
=True
154 self
.k_creds
['username'] = value
155 self
.n_creds
['username'] = value
157 del self
.k_creds
['username']
158 del self
.n_creds
['username']
159 elif index
=='passwd':
160 self
.reload_client
=True
163 self
.k_creds
['password'] = value
164 self
.n_creds
['api_key'] = value
166 del self
.k_creds
['password']
167 del self
.n_creds
['api_key']
169 self
.reload_client
=True
172 self
.k_creds
['auth_url'] = value
173 self
.n_creds
['auth_url'] = value
175 raise TypeError, 'url param can not be NoneType'
177 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
179 def _reload_connection(self
):
180 '''Called before any operation, it check if credentials has changed
181 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
183 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
184 if self
.reload_client
:
186 if len(self
.n_creds
) <4:
187 raise ksExceptions
.ClientException("Not enough parameters to connect to openstack")
188 if self
.osc_api_version
== 'v3.3':
189 self
.nova
= nClient(APIVersion(version_str
='2'), **self
.n_creds
)
190 #TODO To be updated for v3
191 #self.cinder = cClient.Client(**self.n_creds)
192 self
.keystone
= ksClient
.Client(**self
.k_creds
)
193 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
194 self
.neutron
= neClient
.Client(APIVersion(version_str
='2'), endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
196 self
.nova
= nClient_v2
.Client('2', **self
.n_creds
)
197 self
.cinder
= cClient_v2
.Client(**self
.n_creds
)
198 self
.keystone
= ksClient_v2
.Client(**self
.k_creds
)
199 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
200 self
.neutron
= neClient_v2
.Client('2.0', endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
201 self
.glance_endpoint
= self
.keystone
.service_catalog
.url_for(service_type
='image', endpoint_type
='publicURL')
202 self
.glance
= glClient
.Client(self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
203 self
.reload_client
= False
205 def __net_os2mano(self
, net_list_dict
):
206 '''Transform the net openstack format to mano format
207 net_list_dict can be a list of dict or a single dict'''
208 if type(net_list_dict
) is dict:
209 net_list_
=(net_list_dict
,)
210 elif type(net_list_dict
) is list:
211 net_list_
=net_list_dict
213 raise TypeError("param net_list_dict must be a list or a dictionary")
214 for net
in net_list_
:
215 if net
.get('provider:network_type') == "vlan":
222 def _format_exception(self
, exception
):
223 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
224 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
225 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
227 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
228 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
229 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
230 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
231 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
232 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
233 elif isinstance(exception
, nvExceptions
.Conflict
):
234 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
236 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
238 def get_tenant_list(self
, filter_dict
={}):
239 '''Obtain tenants of VIM
240 filter_dict can contain the following keys:
241 name: filter by tenant name
242 id: filter by tenant uuid/id
244 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
246 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
248 self
._reload
_connection
()
249 if self
.osc_api_version
== 'v3.3':
250 project_class_list
=self
.keystone
.projects
.findall(**filter_dict
)
252 project_class_list
=self
.keystone
.tenants
.findall(**filter_dict
)
254 for project
in project_class_list
:
255 project_list
.append(project
.to_dict())
257 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
258 self
._format
_exception
(e
)
260 def new_tenant(self
, tenant_name
, tenant_description
):
261 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
262 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
264 self
._reload
_connection
()
265 if self
.osc_api_version
== 'v3.3':
266 project
=self
.keystone
.projects
.create(tenant_name
, tenant_description
)
268 project
=self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
270 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
271 self
._format
_exception
(e
)
273 def delete_tenant(self
, tenant_id
):
274 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
275 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
277 self
._reload
_connection
()
278 if self
.osc_api_version
== 'v3.3':
279 self
.keystone
.projects
.delete(tenant_id
)
281 self
.keystone
.tenants
.delete(tenant_id
)
283 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
284 self
._format
_exception
(e
)
286 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
287 '''Adds a tenant network to VIM. Returns the network identifier'''
288 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
289 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
292 self
._reload
_connection
()
293 network_dict
= {'name': net_name
, 'admin_state_up': True}
294 if net_type
=="data" or net_type
=="ptp":
295 if self
.config
.get('dataplane_physical_net') == None:
296 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
297 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
298 network_dict
["provider:network_type"] = "vlan"
300 network_dict
["provider:network_type"] = vlan
301 network_dict
["shared"]=shared
302 new_net
=self
.neutron
.create_network({'network':network_dict
})
304 #create subnetwork, even if there is no profile
307 if 'subnet_address' not in ip_profile
:
308 #Fake subnet is required
309 ip_profile
['subnet_address'] = "192.168.111.0/24"
310 if 'ip_version' not in ip_profile
:
311 ip_profile
['ip_version'] = "IPv4"
312 subnet
={"name":net_name
+"-subnet",
313 "network_id": new_net
["network"]["id"],
314 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
315 "cidr": ip_profile
['subnet_address']
317 if 'gateway_address' in ip_profile
:
318 subnet
['gateway_ip'] = ip_profile
['gateway_address']
319 if ip_profile
.get('dns_address'):
320 #TODO: manage dns_address as a list of addresses separated by commas
321 subnet
['dns_nameservers'] = []
322 subnet
['dns_nameservers'].append(ip_profile
['dns_address'])
323 if 'dhcp_enabled' in ip_profile
:
324 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
325 if 'dhcp_start_address' in ip_profile
:
326 subnet
['allocation_pools']=[]
327 subnet
['allocation_pools'].append(dict())
328 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
329 if 'dhcp_count' in ip_profile
:
330 #parts = ip_profile['dhcp_start_address'].split('.')
331 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
332 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
333 ip_int
+= ip_profile
['dhcp_count'] - 1
334 ip_str
= str(netaddr
.IPAddress(ip_int
))
335 subnet
['allocation_pools'][0]['end'] = ip_str
336 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
337 self
.neutron
.create_subnet({"subnet": subnet
} )
338 return new_net
["network"]["id"]
339 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
341 self
.neutron
.delete_network(new_net
['network']['id'])
342 self
._format
_exception
(e
)
344 def get_network_list(self
, filter_dict
={}):
345 '''Obtain tenant networks of VIM
351 admin_state_up: boolean
353 Returns the network list of dictionaries
355 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
357 self
._reload
_connection
()
358 if self
.osc_api_version
== 'v3.3' and "tenant_id" in filter_dict
:
359 filter_dict
['project_id'] = filter_dict
.pop('tenant_id')
360 net_dict
=self
.neutron
.list_networks(**filter_dict
)
361 net_list
=net_dict
["networks"]
362 self
.__net
_os
2mano
(net_list
)
364 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
365 self
._format
_exception
(e
)
367 def get_network(self
, net_id
):
368 '''Obtain details of network from VIM
369 Returns the network information from a network id'''
370 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
371 filter_dict
={"id": net_id
}
372 net_list
= self
.get_network_list(filter_dict
)
374 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
375 elif len(net_list
)>1:
376 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
379 for subnet_id
in net
.get("subnets", () ):
381 subnet
= self
.neutron
.show_subnet(subnet_id
)
382 except Exception as e
:
383 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
384 subnet
= {"id": subnet_id
, "fault": str(e
)}
385 subnets
.append(subnet
)
386 net
["subnets"] = subnets
389 def delete_network(self
, net_id
):
390 '''Deletes a tenant network from VIM. Returns the old network identifier'''
391 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
393 self
._reload
_connection
()
394 #delete VM ports attached to this networks before the network
395 ports
= self
.neutron
.list_ports(network_id
=net_id
)
396 for p
in ports
['ports']:
398 self
.neutron
.delete_port(p
["id"])
399 except Exception as e
:
400 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
401 self
.neutron
.delete_network(net_id
)
403 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
404 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
405 self
._format
_exception
(e
)
407 def refresh_nets_status(self
, net_list
):
408 '''Get the status of the networks
409 Params: the list of network identifiers
410 Returns a dictionary with:
411 net_id: #VIM id of this network
412 status: #Mandatory. Text with one of:
413 # DELETED (not found at vim)
414 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
415 # OTHER (Vim reported other status not understood)
416 # ERROR (VIM indicates an ERROR status)
417 # ACTIVE, INACTIVE, DOWN (admin down),
418 # BUILD (on building process)
420 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
421 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
425 for net_id
in net_list
:
428 net_vim
= self
.get_network(net_id
)
429 if net_vim
['status'] in netStatus2manoFormat
:
430 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
432 net
["status"] = "OTHER"
433 net
["error_msg"] = "VIM status reported " + net_vim
['status']
435 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
436 net
['status'] = 'DOWN'
438 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
439 except yaml
.representer
.RepresenterError
:
440 net
['vim_info'] = str(net_vim
)
441 if net_vim
.get('fault'): #TODO
442 net
['error_msg'] = str(net_vim
['fault'])
443 except vimconn
.vimconnNotFoundException
as e
:
444 self
.logger
.error("Exception getting net status: %s", str(e
))
445 net
['status'] = "DELETED"
446 net
['error_msg'] = str(e
)
447 except vimconn
.vimconnException
as e
:
448 self
.logger
.error("Exception getting net status: %s", str(e
))
449 net
['status'] = "VIM_ERROR"
450 net
['error_msg'] = str(e
)
451 net_dict
[net_id
] = net
454 def get_flavor(self
, flavor_id
):
455 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
456 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
458 self
._reload
_connection
()
459 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
460 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
461 return flavor
.to_dict()
462 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
463 self
._format
_exception
(e
)
465 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
466 '''Adds a tenant flavor to openstack VIM
467 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
468 Returns the flavor identifier
470 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
474 name
=flavor_data
['name']
475 while retry
<max_retries
:
478 self
._reload
_connection
()
479 if change_name_if_used
:
482 fl
=self
.nova
.flavors
.list()
484 fl_names
.append(f
.name
)
485 while name
in fl_names
:
487 name
= flavor_data
['name']+"-" + str(name_suffix
)
489 ram
= flavor_data
.get('ram',64)
490 vcpus
= flavor_data
.get('vcpus',1)
493 extended
= flavor_data
.get("extended")
495 numas
=extended
.get("numas")
497 numa_nodes
= len(numas
)
499 return -1, "Can not add flavor with more than one numa"
500 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
501 numa_properties
["hw:mem_page_size"] = "large"
502 numa_properties
["hw:cpu_policy"] = "dedicated"
503 numa_properties
["hw:numa_mempolicy"] = "strict"
505 #overwrite ram and vcpus
506 ram
= numa
['memory']*1024
507 if 'paired-threads' in numa
:
508 vcpus
= numa
['paired-threads']*2
509 numa_properties
["hw:cpu_threads_policy"] = "prefer"
510 elif 'cores' in numa
:
511 vcpus
= numa
['cores']
512 #numa_properties["hw:cpu_threads_policy"] = "prefer"
513 elif 'threads' in numa
:
514 vcpus
= numa
['threads']
515 numa_properties
["hw:cpu_policy"] = "isolated"
516 for interface
in numa
.get("interfaces",() ):
517 if interface
["dedicated"]=="yes":
518 raise vimconn
.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code
=vimconn
.HTTP_Service_Unavailable
)
519 #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
522 new_flavor
=self
.nova
.flavors
.create(name
,
525 flavor_data
.get('disk',1),
526 is_public
=flavor_data
.get('is_public', True)
530 new_flavor
.set_keys(numa_properties
)
532 except nvExceptions
.Conflict
as e
:
533 if change_name_if_used
and retry
< max_retries
:
535 self
._format
_exception
(e
)
536 #except nvExceptions.BadRequest as e:
537 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
538 self
._format
_exception
(e
)
540 def delete_flavor(self
,flavor_id
):
541 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
544 self
._reload
_connection
()
545 self
.nova
.flavors
.delete(flavor_id
)
547 #except nvExceptions.BadRequest as e:
548 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
549 self
._format
_exception
(e
)
551 def new_image(self
,image_dict
):
553 Adds a tenant image to VIM. imge_dict is a dictionary with:
555 disk_format: qcow2, vhd, vmdk, raw (by default), ...
556 location: path or URI
557 public: "yes" or "no"
558 metadata: metadata of the image
561 #using version 1 of glance client
562 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
565 while retry
<max_retries
:
568 self
._reload
_connection
()
569 #determine format http://docs.openstack.org/developer/glance/formats.html
570 if "disk_format" in image_dict
:
571 disk_format
=image_dict
["disk_format"]
572 else: #autodiscover based on extension
573 if image_dict
['location'][-6:]==".qcow2":
575 elif image_dict
['location'][-4:]==".vhd":
577 elif image_dict
['location'][-5:]==".vmdk":
579 elif image_dict
['location'][-4:]==".vdi":
581 elif image_dict
['location'][-4:]==".iso":
583 elif image_dict
['location'][-4:]==".aki":
585 elif image_dict
['location'][-4:]==".ari":
587 elif image_dict
['location'][-4:]==".ami":
591 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
592 if image_dict
['location'][0:4]=="http":
593 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
594 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
596 with
open(image_dict
['location']) as fimage
:
597 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
598 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
599 #insert metadata. We cannot use 'new_image.properties.setdefault'
600 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
601 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
602 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
603 metadata_to_load
= image_dict
.get('metadata')
605 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
606 new_image_nova
.metadata
.setdefault(k
,v
)
608 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
609 self
._format
_exception
(e
)
610 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
611 if retry
==max_retries
:
613 self
._format
_exception
(e
)
614 except IOError as e
: #can not open the file
615 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
616 http_code
=vimconn
.HTTP_Bad_Request
)
618 def delete_image(self
, image_id
):
619 '''Deletes a tenant image from openstack VIM. Returns the old id
622 self
._reload
_connection
()
623 self
.nova
.images
.delete(image_id
)
625 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
626 self
._format
_exception
(e
)
628 def get_image_id_from_path(self
, path
):
629 '''Get the image id from image path in the VIM database. Returns the image_id'''
631 self
._reload
_connection
()
632 images
= self
.nova
.images
.list()
634 if image
.metadata
.get("location")==path
:
636 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
637 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
638 self
._format
_exception
(e
)
640 def get_image_list(self
, filter_dict
={}):
641 '''Obtain tenant images from VIM
645 checksum: image checksum
646 Returns the image list of dictionaries:
647 [{<the fields at Filter_dict plus some VIM specific>}, ...]
650 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
652 self
._reload
_connection
()
653 filter_dict_os
=filter_dict
.copy()
654 #First we filter by the available filter fields: name, id. The others are removed.
655 filter_dict_os
.pop('checksum',None)
656 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
657 if len(image_list
)==0:
659 #Then we filter by the rest of filter fields: checksum
661 for image
in image_list
:
662 image_class
=self
.glance
.images
.get(image
.id)
663 if 'checksum' not in filter_dict
or image_class
['checksum']==filter_dict
.get('checksum'):
664 filtered_list
.append(image_class
.copy())
666 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
667 self
._format
_exception
(e
)
669 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
670 '''Adds a VM instance to VIM
672 start: indicates if VM must start or boot in pause mode. Ignored
673 image_id,flavor_id: iamge and flavor uuid
674 net_list: list of interfaces, each one is a dictionary with:
676 net_id: network uuid to connect
677 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
678 model: interface model, ignored #TODO
679 mac_address: used for SR-IOV ifaces #TODO for other types
680 use: 'data', 'bridge', 'mgmt'
681 type: 'virtual', 'PF', 'VF', 'VFnotShared'
682 vim_id: filled/added by this function
683 floating_ip: True/False (or it can be None)
684 #TODO ip, security groups
685 Returns the instance identifier
687 self
.logger
.debug("Creating VM image '%s' flavor '%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
691 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
692 self
._reload
_connection
()
693 metadata_vpci
={} #For a specific neutron plugin
695 if not net
.get("net_id"): #skip non connected iface
697 if net
["type"]=="virtual" or net
["type"]=="VF":
699 "network_id": net
["net_id"],
700 "name": net
.get("name"),
701 "admin_state_up": True
703 if net
["type"]=="virtual":
705 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
708 if "VF" not in metadata_vpci
:
709 metadata_vpci
["VF"]=[]
710 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
711 port_dict
["binding:vnic_type"]="direct"
712 if not port_dict
["name"]:
713 port_dict
["name"]=name
714 if net
.get("mac_address"):
715 port_dict
["mac_address"]=net
["mac_address"]
716 if net
.get("port_security") == False:
717 port_dict
["port_security_enabled"]=net
["port_security"]
718 new_port
= self
.neutron
.create_port({"port": port_dict
})
719 net
["mac_adress"] = new_port
["port"]["mac_address"]
720 net
["vim_id"] = new_port
["port"]["id"]
721 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
722 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
724 self
.logger
.warn("new_vminstance: Warning, can not connect a passthrough interface ")
725 #TODO insert this when openstack consider passthrough ports as openstack neutron ports
726 if net
.get('floating_ip', False):
727 net
['exit_on_floating_ip_error'] = True
728 external_network
.append(net
)
729 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
730 net
['exit_on_floating_ip_error'] = False
731 external_network
.append(net
)
734 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
735 if len(metadata
["pci_assignement"]) >255:
736 #limit the metadata size
737 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
738 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
741 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
742 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
744 security_groups
= self
.config
.get('security_groups')
745 if type(security_groups
) is str:
746 security_groups
= ( security_groups
, )
750 if isinstance(cloud_config
, dict):
751 if cloud_config
.get("user-data"):
752 userdata
=cloud_config
["user-data"]
753 if cloud_config
.get("boot-data-drive") != None:
754 config_drive
= cloud_config
["boot-data-drive"]
755 if cloud_config
.get("config-files") or cloud_config
.get("users") or cloud_config
.get("key-pairs"):
757 raise vimconn
.vimconnConflictException("Cloud-config cannot contain both 'userdata' and 'config-files'/'users'/'key-pairs'")
760 if cloud_config
.get("key-pairs"):
761 userdata_dict
["ssh-authorized-keys"] = cloud_config
["key-pairs"]
762 userdata_dict
["users"] = [{"default": None, "ssh-authorized-keys": cloud_config
["key-pairs"] }]
763 if cloud_config
.get("users"):
764 if "users" not in cloud_config
:
765 userdata_dict
["users"] = [ "default" ]
766 for user
in cloud_config
["users"]:
768 "name" : user
["name"],
769 "sudo": "ALL = (ALL)NOPASSWD:ALL"
771 if "user-info" in user
:
772 user_info
["gecos"] = user
["user-info"]
773 if user
.get("key-pairs"):
774 user_info
["ssh-authorized-keys"] = user
["key-pairs"]
775 userdata_dict
["users"].append(user_info
)
777 if cloud_config
.get("config-files"):
778 userdata_dict
["write_files"] = []
779 for file in cloud_config
["config-files"]:
781 "path" : file["dest"],
782 "content": file["content"]
784 if file.get("encoding"):
785 file_info
["encoding"] = file["encoding"]
786 if file.get("permissions"):
787 file_info
["permissions"] = file["permissions"]
788 if file.get("owner"):
789 file_info
["owner"] = file["owner"]
790 userdata_dict
["write_files"].append(file_info
)
791 userdata
= "#cloud-config\n"
792 userdata
+= yaml
.safe_dump(userdata_dict
, indent
=4, default_flow_style
=False)
793 self
.logger
.debug("userdata: %s", userdata
)
794 elif isinstance(cloud_config
, str):
795 userdata
= cloud_config
797 #Create additional volumes in case these are present in disk_list
798 block_device_mapping
= None
799 base_disk_index
= ord('b')
800 if disk_list
!= None:
801 block_device_mapping
= dict()
802 for disk
in disk_list
:
803 if 'image_id' in disk
:
804 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
805 chr(base_disk_index
), imageRef
= disk
['image_id'])
807 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
808 chr(base_disk_index
))
809 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
812 #wait until volumes are with status available
815 while keep_waiting
and elapsed_time
< volume_timeout
:
817 for volume_id
in block_device_mapping
.itervalues():
818 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
824 #if we exceeded the timeout rollback
825 if elapsed_time
>= volume_timeout
:
826 #delete the volumes we just created
827 for volume_id
in block_device_mapping
.itervalues():
828 self
.cinder
.volumes
.delete(volume_id
)
830 #delete ports we just created
831 for net_item
in net_list_vim
:
832 if 'port-id' in net_item
:
833 self
.neutron
.delete_port(net_item
['port-id'])
835 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
836 http_code
=vimconn
.HTTP_Request_Timeout
)
838 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
839 security_groups
=security_groups
,
840 availability_zone
=self
.config
.get('availability_zone'),
841 key_name
=self
.config
.get('keypair'),
843 config_drive
= config_drive
,
844 block_device_mapping
= block_device_mapping
845 ) # , description=description)
846 #print "DONE :-)", server
848 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
849 for floating_network
in external_network
:
851 # wait until vm is active
853 while elapsed_time
< server_timeout
:
854 status
= self
.nova
.servers
.get(server
.id).status
855 if status
== 'ACTIVE':
860 #if we exceeded the timeout rollback
861 if elapsed_time
>= server_timeout
:
862 raise vimconn
.vimconnException('Timeout creating instance ' + name
,
863 http_code
=vimconn
.HTTP_Request_Timeout
)
866 while(assigned
== False):
868 ip
= floating_ips
.pop(0)
869 if not ip
.get("port_id", False) and ip
.get('tenant_id') == server
.tenant_id
:
870 free_floating_ip
= ip
.get("floating_ip_address")
872 fix_ip
= floating_network
.get('ip')
873 server
.add_floating_ip(free_floating_ip
, fix_ip
)
875 except Exception as e
:
876 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
878 #Find the external network
879 external_nets
= list()
880 for net
in self
.neutron
.list_networks()['networks']:
881 if net
['router:external']:
882 external_nets
.append(net
)
884 if len(external_nets
) == 0:
885 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
886 "network is present",
887 http_code
=vimconn
.HTTP_Conflict
)
888 if len(external_nets
) > 1:
889 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
890 "external networks are present",
891 http_code
=vimconn
.HTTP_Conflict
)
893 pool_id
= external_nets
[0].get('id')
894 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
896 #self.logger.debug("Creating floating IP")
897 new_floating_ip
= self
.neutron
.create_floatingip(param
)
898 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
899 fix_ip
= floating_network
.get('ip')
900 server
.add_floating_ip(free_floating_ip
, fix_ip
)
902 except Exception as e
:
903 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot assign floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
904 except Exception as e
:
905 if not floating_network
['exit_on_floating_ip_error']:
906 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
908 self
.delete_vminstance(server
.id)
912 # except nvExceptions.NotFound as e:
913 # error_value=-vimconn.HTTP_Not_Found
914 # error_text= "vm instance %s not found" % vm_id
915 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
916 # delete the volumes we just created
917 if block_device_mapping
!= None:
918 for volume_id
in block_device_mapping
.itervalues():
919 self
.cinder
.volumes
.delete(volume_id
)
921 # delete ports we just created
922 for net_item
in net_list_vim
:
923 if 'port-id' in net_item
:
924 self
.neutron
.delete_port(net_item
['port-id'])
925 self
._format
_exception
(e
)
926 except TypeError as e
:
927 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
929 def get_vminstance(self
,vm_id
):
930 '''Returns the VM instance information from VIM'''
931 #self.logger.debug("Getting VM from VIM")
933 self
._reload
_connection
()
934 server
= self
.nova
.servers
.find(id=vm_id
)
935 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
936 return server
.to_dict()
937 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
938 self
._format
_exception
(e
)
940 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
942 Get a console for the virtual machine
944 vm_id: uuid of the VM
945 console_type, can be:
946 "novnc" (by default), "xvpvnc" for VNC types,
947 "rdp-html5" for RDP types, "spice-html5" for SPICE types
948 Returns dict with the console parameters:
949 protocol: ssh, ftp, http, https, ...
950 server: usually ip address
951 port: the http, ssh, ... port
952 suffix: extra text, e.g. the http path and query string
954 self
.logger
.debug("Getting VM CONSOLE from VIM")
956 self
._reload
_connection
()
957 server
= self
.nova
.servers
.find(id=vm_id
)
958 if console_type
== None or console_type
== "novnc":
959 console_dict
= server
.get_vnc_console("novnc")
960 elif console_type
== "xvpvnc":
961 console_dict
= server
.get_vnc_console(console_type
)
962 elif console_type
== "rdp-html5":
963 console_dict
= server
.get_rdp_console(console_type
)
964 elif console_type
== "spice-html5":
965 console_dict
= server
.get_spice_console(console_type
)
967 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
969 console_dict1
= console_dict
.get("console")
971 console_url
= console_dict1
.get("url")
974 protocol_index
= console_url
.find("//")
975 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
976 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
977 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
978 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
979 console_dict
={"protocol": console_url
[0:protocol_index
],
980 "server": console_url
[protocol_index
+2:port_index
],
981 "port": console_url
[port_index
:suffix_index
],
982 "suffix": console_url
[suffix_index
+1:]
986 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
988 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
989 self
._format
_exception
(e
)
991 def delete_vminstance(self
, vm_id
):
992 '''Removes a VM instance from VIM. Returns the old identifier
994 #print "osconnector: Getting VM from VIM"
996 self
._reload
_connection
()
997 #delete VM ports attached to this networks before the virtual machine
998 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
999 for p
in ports
['ports']:
1001 self
.neutron
.delete_port(p
["id"])
1002 except Exception as e
:
1003 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
1005 #commented because detaching the volumes makes the servers.delete not work properly ?!?
1006 #dettach volumes attached
1007 server
= self
.nova
.servers
.get(vm_id
)
1008 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
1009 #for volume in volumes_attached_dict:
1010 # self.cinder.volumes.detach(volume['id'])
1012 self
.nova
.servers
.delete(vm_id
)
1015 #Although having detached them should have them in active status
1016 #we ensure in this loop
1019 while keep_waiting
and elapsed_time
< volume_timeout
:
1020 keep_waiting
= False
1021 for volume
in volumes_attached_dict
:
1022 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
1025 self
.cinder
.volumes
.delete(volume
['id'])
1031 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1032 self
._format
_exception
(e
)
1033 #TODO insert exception vimconn.HTTP_Unauthorized
1034 #if reaching here is because an exception
1036 def refresh_vms_status(self
, vm_list
):
1037 '''Get the status of the virtual machines and their interfaces/ports
1038 Params: the list of VM identifiers
1039 Returns a dictionary with:
1040 vm_id: #VIM id of this Virtual Machine
1041 status: #Mandatory. Text with one of:
1042 # DELETED (not found at vim)
1043 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1044 # OTHER (Vim reported other status not understood)
1045 # ERROR (VIM indicates an ERROR status)
1046 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1047 # CREATING (on building process), ERROR
1048 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1050 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1051 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1053 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1054 mac_address: #Text format XX:XX:XX:XX:XX:XX
1055 vim_net_id: #network id where this interface is connected
1056 vim_interface_id: #interface/port VIM id
1057 ip_address: #null, or text with IPv4, IPv6 address
1060 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1061 for vm_id
in vm_list
:
1064 vm_vim
= self
.get_vminstance(vm_id
)
1065 if vm_vim
['status'] in vmStatus2manoFormat
:
1066 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1068 vm
['status'] = "OTHER"
1069 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1071 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1072 except yaml
.representer
.RepresenterError
:
1073 vm
['vim_info'] = str(vm_vim
)
1074 vm
["interfaces"] = []
1075 if vm_vim
.get('fault'):
1076 vm
['error_msg'] = str(vm_vim
['fault'])
1079 self
._reload
_connection
()
1080 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1081 for port
in port_dict
["ports"]:
1084 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1085 except yaml
.representer
.RepresenterError
:
1086 interface
['vim_info'] = str(port
)
1087 interface
["mac_address"] = port
.get("mac_address")
1088 interface
["vim_net_id"] = port
["network_id"]
1089 interface
["vim_interface_id"] = port
["id"]
1091 #look for floating ip address
1092 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1093 if floating_ip_dict
.get("floatingips"):
1094 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1096 for subnet
in port
["fixed_ips"]:
1097 ips
.append(subnet
["ip_address"])
1098 interface
["ip_address"] = ";".join(ips
)
1099 vm
["interfaces"].append(interface
)
1100 except Exception as e
:
1101 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1102 except vimconn
.vimconnNotFoundException
as e
:
1103 self
.logger
.error("Exception getting vm status: %s", str(e
))
1104 vm
['status'] = "DELETED"
1105 vm
['error_msg'] = str(e
)
1106 except vimconn
.vimconnException
as e
:
1107 self
.logger
.error("Exception getting vm status: %s", str(e
))
1108 vm
['status'] = "VIM_ERROR"
1109 vm
['error_msg'] = str(e
)
1113 def action_vminstance(self
, vm_id
, action_dict
):
1114 '''Send and action over a VM instance from VIM
1115 Returns the vm_id if the action was successfully sent to the VIM'''
1116 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1118 self
._reload
_connection
()
1119 server
= self
.nova
.servers
.find(id=vm_id
)
1120 if "start" in action_dict
:
1121 if action_dict
["start"]=="rebuild":
1124 if server
.status
=="PAUSED":
1126 elif server
.status
=="SUSPENDED":
1128 elif server
.status
=="SHUTOFF":
1130 elif "pause" in action_dict
:
1132 elif "resume" in action_dict
:
1134 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1136 elif "forceOff" in action_dict
:
1138 elif "terminate" in action_dict
:
1140 elif "createImage" in action_dict
:
1141 server
.create_image()
1142 #"path":path_schema,
1143 #"description":description_schema,
1144 #"name":name_schema,
1145 #"metadata":metadata_schema,
1146 #"imageRef": id_schema,
1147 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1148 elif "rebuild" in action_dict
:
1149 server
.rebuild(server
.image
['id'])
1150 elif "reboot" in action_dict
:
1151 server
.reboot() #reboot_type='SOFT'
1152 elif "console" in action_dict
:
1153 console_type
= action_dict
["console"]
1154 if console_type
== None or console_type
== "novnc":
1155 console_dict
= server
.get_vnc_console("novnc")
1156 elif console_type
== "xvpvnc":
1157 console_dict
= server
.get_vnc_console(console_type
)
1158 elif console_type
== "rdp-html5":
1159 console_dict
= server
.get_rdp_console(console_type
)
1160 elif console_type
== "spice-html5":
1161 console_dict
= server
.get_spice_console(console_type
)
1163 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1164 http_code
=vimconn
.HTTP_Bad_Request
)
1166 console_url
= console_dict
["console"]["url"]
1168 protocol_index
= console_url
.find("//")
1169 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1170 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1171 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1172 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1173 console_dict2
={"protocol": console_url
[0:protocol_index
],
1174 "server": console_url
[protocol_index
+2 : port_index
],
1175 "port": int(console_url
[port_index
+1 : suffix_index
]),
1176 "suffix": console_url
[suffix_index
+1:]
1178 return console_dict2
1179 except Exception as e
:
1180 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1183 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1184 self
._format
_exception
(e
)
1185 #TODO insert exception vimconn.HTTP_Unauthorized
1189 def new_external_port(self
, port_data
):
1190 #TODO openstack if needed
1191 '''Adds a external port to VIM'''
1192 '''Returns the port identifier'''
1193 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1195 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1196 #TODO openstack if needed
1197 '''Connects a external port to a network'''
1198 '''Returns status code of the VIM response'''
1199 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1201 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1202 '''Adds a new user to openstack VIM'''
1203 '''Returns the user identifier'''
1204 self
.logger
.debug("osconnector: Adding a new user to VIM")
1206 self
._reload
_connection
()
1207 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1208 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1210 except ksExceptions
.ConnectionError
as e
:
1211 error_value
=-vimconn
.HTTP_Bad_Request
1212 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1213 except ksExceptions
.ClientException
as e
: #TODO remove
1214 error_value
=-vimconn
.HTTP_Bad_Request
1215 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1216 #TODO insert exception vimconn.HTTP_Unauthorized
1217 #if reaching here is because an exception
1219 self
.logger
.debug("new_user " + error_text
)
1220 return error_value
, error_text
1222 def delete_user(self
, user_id
):
1223 '''Delete a user from openstack VIM'''
1224 '''Returns the user identifier'''
1226 print "osconnector: Deleting a user from VIM"
1228 self
._reload
_connection
()
1229 self
.keystone
.users
.delete(user_id
)
1231 except ksExceptions
.ConnectionError
as e
:
1232 error_value
=-vimconn
.HTTP_Bad_Request
1233 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1234 except ksExceptions
.NotFound
as e
:
1235 error_value
=-vimconn
.HTTP_Not_Found
1236 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1237 except ksExceptions
.ClientException
as e
: #TODO remove
1238 error_value
=-vimconn
.HTTP_Bad_Request
1239 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1240 #TODO insert exception vimconn.HTTP_Unauthorized
1241 #if reaching here is because an exception
1243 print "delete_tenant " + error_text
1244 return error_value
, error_text
1246 def get_hosts_info(self
):
1247 '''Get the information of deployed hosts
1248 Returns the hosts content'''
1250 print "osconnector: Getting Host info from VIM"
1253 self
._reload
_connection
()
1254 hypervisors
= self
.nova
.hypervisors
.list()
1255 for hype
in hypervisors
:
1256 h_list
.append( hype
.to_dict() )
1257 return 1, {"hosts":h_list
}
1258 except nvExceptions
.NotFound
as e
:
1259 error_value
=-vimconn
.HTTP_Not_Found
1260 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1261 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1262 error_value
=-vimconn
.HTTP_Bad_Request
1263 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1264 #TODO insert exception vimconn.HTTP_Unauthorized
1265 #if reaching here is because an exception
1267 print "get_hosts_info " + error_text
1268 return error_value
, error_text
1270 def get_hosts(self
, vim_tenant
):
1271 '''Get the hosts and deployed instances
1272 Returns the hosts content'''
1273 r
, hype_dict
= self
.get_hosts_info()
1276 hypervisors
= hype_dict
["hosts"]
1278 servers
= self
.nova
.servers
.list()
1279 for hype
in hypervisors
:
1280 for server
in servers
:
1281 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1283 hype
['vm'].append(server
.id)
1285 hype
['vm'] = [server
.id]
1287 except nvExceptions
.NotFound
as e
:
1288 error_value
=-vimconn
.HTTP_Not_Found
1289 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1290 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1291 error_value
=-vimconn
.HTTP_Bad_Request
1292 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1293 #TODO insert exception vimconn.HTTP_Unauthorized
1294 #if reaching here is because an exception
1296 print "get_hosts " + error_text
1297 return error_value
, error_text