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
)
82 raise TypeError, 'url param can not be NoneType'
83 self
.k_creds
['auth_url'] = url
84 self
.n_creds
['auth_url'] = url
86 self
.k_creds
['tenant_name'] = tenant_name
87 self
.n_creds
['project_id'] = tenant_name
89 self
.k_creds
['tenant_id'] = tenant_id
90 self
.n_creds
['tenant_id'] = tenant_id
92 self
.k_creds
['username'] = user
93 self
.n_creds
['username'] = user
95 self
.k_creds
['password'] = passwd
96 self
.n_creds
['api_key'] = passwd
97 if self
.osc_api_version
== 'v3.3':
98 self
.k_creds
['project_name'] = tenant_name
99 self
.k_creds
['project_id'] = tenant_id
100 if config
.get('region_name'):
101 self
.k_creds
['region_name'] = config
.get('region_name')
102 self
.n_creds
['region_name'] = config
.get('region_name')
104 self
.reload_client
= True
105 self
.logger
= logging
.getLogger('openmano.vim.openstack')
107 self
.logger
.setLevel( getattr(logging
, log_level
) )
109 def __setitem__(self
,index
, value
):
110 '''Set individuals parameters
111 Throw TypeError, KeyError
113 if index
=='tenant_id':
114 self
.reload_client
=True
115 self
.tenant_id
= value
116 if self
.osc_api_version
== 'v3.3':
118 self
.k_creds
['project_id'] = value
119 self
.n_creds
['project_id'] = value
121 del self
.k_creds
['project_id']
122 del self
.n_creds
['project_id']
125 self
.k_creds
['tenant_id'] = value
126 self
.n_creds
['tenant_id'] = value
128 del self
.k_creds
['tenant_id']
129 del self
.n_creds
['tenant_id']
130 elif index
=='tenant_name':
131 self
.reload_client
=True
132 self
.tenant_name
= value
133 if self
.osc_api_version
== 'v3.3':
135 self
.k_creds
['project_name'] = value
136 self
.n_creds
['project_name'] = value
138 del self
.k_creds
['project_name']
139 del self
.n_creds
['project_name']
142 self
.k_creds
['tenant_name'] = value
143 self
.n_creds
['project_id'] = value
145 del self
.k_creds
['tenant_name']
146 del self
.n_creds
['project_id']
148 self
.reload_client
=True
151 self
.k_creds
['username'] = value
152 self
.n_creds
['username'] = value
154 del self
.k_creds
['username']
155 del self
.n_creds
['username']
156 elif index
=='passwd':
157 self
.reload_client
=True
160 self
.k_creds
['password'] = value
161 self
.n_creds
['api_key'] = value
163 del self
.k_creds
['password']
164 del self
.n_creds
['api_key']
166 self
.reload_client
=True
169 self
.k_creds
['auth_url'] = value
170 self
.n_creds
['auth_url'] = value
172 raise TypeError, 'url param can not be NoneType'
174 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
176 def _reload_connection(self
):
177 '''Called before any operation, it check if credentials has changed
178 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
180 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
181 if self
.reload_client
:
183 if len(self
.n_creds
) <4:
184 raise ksExceptions
.ClientException("Not enough parameters to connect to openstack")
185 if self
.osc_api_version
== 'v3.3':
186 self
.nova
= nClient(APIVersion(version_str
='2'), **self
.n_creds
)
187 #TODO To be updated for v3
188 #self.cinder = cClient.Client(**self.n_creds)
189 self
.keystone
= ksClient
.Client(**self
.k_creds
)
190 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
191 self
.neutron
= neClient
.Client(APIVersion(version_str
='2'), endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
193 self
.nova
= nClient_v2
.Client('2', **self
.n_creds
)
194 self
.cinder
= cClient_v2
.Client(**self
.n_creds
)
195 self
.keystone
= ksClient_v2
.Client(**self
.k_creds
)
196 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
197 self
.neutron
= neClient_v2
.Client('2.0', endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
198 self
.glance_endpoint
= self
.keystone
.service_catalog
.url_for(service_type
='image', endpoint_type
='publicURL')
199 self
.glance
= glClient
.Client(self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
200 self
.reload_client
= False
202 def __net_os2mano(self
, net_list_dict
):
203 '''Transform the net openstack format to mano format
204 net_list_dict can be a list of dict or a single dict'''
205 if type(net_list_dict
) is dict:
206 net_list_
=(net_list_dict
,)
207 elif type(net_list_dict
) is list:
208 net_list_
=net_list_dict
210 raise TypeError("param net_list_dict must be a list or a dictionary")
211 for net
in net_list_
:
212 if net
.get('provider:network_type') == "vlan":
219 def _format_exception(self
, exception
):
220 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
221 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
222 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
224 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
225 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
226 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
227 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
228 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
229 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
230 elif isinstance(exception
, nvExceptions
.Conflict
):
231 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
233 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
235 def get_tenant_list(self
, filter_dict
={}):
236 '''Obtain tenants of VIM
237 filter_dict can contain the following keys:
238 name: filter by tenant name
239 id: filter by tenant uuid/id
241 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
243 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
245 self
._reload
_connection
()
246 if self
.osc_api_version
== 'v3.3':
247 project_class_list
=self
.keystone
.projects
.findall(**filter_dict
)
249 project_class_list
=self
.keystone
.tenants
.findall(**filter_dict
)
251 for project
in project_class_list
:
252 project_list
.append(project
.to_dict())
254 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
255 self
._format
_exception
(e
)
257 def new_tenant(self
, tenant_name
, tenant_description
):
258 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
259 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
261 self
._reload
_connection
()
262 if self
.osc_api_version
== 'v3.3':
263 project
=self
.keystone
.projects
.create(tenant_name
, tenant_description
)
265 project
=self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
267 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
268 self
._format
_exception
(e
)
270 def delete_tenant(self
, tenant_id
):
271 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
272 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
274 self
._reload
_connection
()
275 if self
.osc_api_version
== 'v3.3':
276 self
.keystone
.projects
.delete(tenant_id
)
278 self
.keystone
.tenants
.delete(tenant_id
)
280 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
281 self
._format
_exception
(e
)
283 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
284 '''Adds a tenant network to VIM. Returns the network identifier'''
285 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
286 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
289 self
._reload
_connection
()
290 network_dict
= {'name': net_name
, 'admin_state_up': True}
291 if net_type
=="data" or net_type
=="ptp":
292 if self
.config
.get('dataplane_physical_net') == None:
293 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
294 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
295 network_dict
["provider:network_type"] = "vlan"
297 network_dict
["provider:network_type"] = vlan
298 network_dict
["shared"]=shared
299 new_net
=self
.neutron
.create_network({'network':network_dict
})
301 #create subnetwork, even if there is no profile
304 if 'subnet_address' not in ip_profile
:
305 #Fake subnet is required
306 ip_profile
['subnet_address'] = "192.168.111.0/24"
307 if 'ip_version' not in ip_profile
:
308 ip_profile
['ip_version'] = "IPv4"
309 subnet
={"name":net_name
+"-subnet",
310 "network_id": new_net
["network"]["id"],
311 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
312 "cidr": ip_profile
['subnet_address']
314 if 'gateway_address' in ip_profile
:
315 subnet
['gateway_ip'] = ip_profile
['gateway_address']
316 if ip_profile
.get('dns_address'):
317 #TODO: manage dns_address as a list of addresses separated by commas
318 subnet
['dns_nameservers'] = []
319 subnet
['dns_nameservers'].append(ip_profile
['dns_address'])
320 if 'dhcp_enabled' in ip_profile
:
321 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
322 if 'dhcp_start_address' in ip_profile
:
323 subnet
['allocation_pools']=[]
324 subnet
['allocation_pools'].append(dict())
325 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
326 if 'dhcp_count' in ip_profile
:
327 #parts = ip_profile['dhcp_start_address'].split('.')
328 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
329 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
330 ip_int
+= ip_profile
['dhcp_count'] - 1
331 ip_str
= str(netaddr
.IPAddress(ip_int
))
332 subnet
['allocation_pools'][0]['end'] = ip_str
333 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
334 self
.neutron
.create_subnet({"subnet": subnet
} )
335 return new_net
["network"]["id"]
336 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
338 self
.neutron
.delete_network(new_net
['network']['id'])
339 self
._format
_exception
(e
)
341 def get_network_list(self
, filter_dict
={}):
342 '''Obtain tenant networks of VIM
348 admin_state_up: boolean
350 Returns the network list of dictionaries
352 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
354 self
._reload
_connection
()
355 if self
.osc_api_version
== 'v3.3' and "tenant_id" in filter_dict
:
356 filter_dict
['project_id'] = filter_dict
.pop('tenant_id')
357 net_dict
=self
.neutron
.list_networks(**filter_dict
)
358 net_list
=net_dict
["networks"]
359 self
.__net
_os
2mano
(net_list
)
361 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
362 self
._format
_exception
(e
)
364 def get_network(self
, net_id
):
365 '''Obtain details of network from VIM
366 Returns the network information from a network id'''
367 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
368 filter_dict
={"id": net_id
}
369 net_list
= self
.get_network_list(filter_dict
)
371 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
372 elif len(net_list
)>1:
373 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
376 for subnet_id
in net
.get("subnets", () ):
378 subnet
= self
.neutron
.show_subnet(subnet_id
)
379 except Exception as e
:
380 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
381 subnet
= {"id": subnet_id
, "fault": str(e
)}
382 subnets
.append(subnet
)
383 net
["subnets"] = subnets
386 def delete_network(self
, net_id
):
387 '''Deletes a tenant network from VIM. Returns the old network identifier'''
388 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
390 self
._reload
_connection
()
391 #delete VM ports attached to this networks before the network
392 ports
= self
.neutron
.list_ports(network_id
=net_id
)
393 for p
in ports
['ports']:
395 self
.neutron
.delete_port(p
["id"])
396 except Exception as e
:
397 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
398 self
.neutron
.delete_network(net_id
)
400 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
401 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
402 self
._format
_exception
(e
)
404 def refresh_nets_status(self
, net_list
):
405 '''Get the status of the networks
406 Params: the list of network identifiers
407 Returns a dictionary with:
408 net_id: #VIM id of this network
409 status: #Mandatory. Text with one of:
410 # DELETED (not found at vim)
411 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
412 # OTHER (Vim reported other status not understood)
413 # ERROR (VIM indicates an ERROR status)
414 # ACTIVE, INACTIVE, DOWN (admin down),
415 # BUILD (on building process)
417 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
418 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
422 for net_id
in net_list
:
425 net_vim
= self
.get_network(net_id
)
426 if net_vim
['status'] in netStatus2manoFormat
:
427 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
429 net
["status"] = "OTHER"
430 net
["error_msg"] = "VIM status reported " + net_vim
['status']
432 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
433 net
['status'] = 'DOWN'
435 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
436 except yaml
.representer
.RepresenterError
:
437 net
['vim_info'] = str(net_vim
)
438 if net_vim
.get('fault'): #TODO
439 net
['error_msg'] = str(net_vim
['fault'])
440 except vimconn
.vimconnNotFoundException
as e
:
441 self
.logger
.error("Exception getting net status: %s", str(e
))
442 net
['status'] = "DELETED"
443 net
['error_msg'] = str(e
)
444 except vimconn
.vimconnException
as e
:
445 self
.logger
.error("Exception getting net status: %s", str(e
))
446 net
['status'] = "VIM_ERROR"
447 net
['error_msg'] = str(e
)
448 net_dict
[net_id
] = net
451 def get_flavor(self
, flavor_id
):
452 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
453 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
455 self
._reload
_connection
()
456 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
457 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
458 return flavor
.to_dict()
459 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
460 self
._format
_exception
(e
)
462 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
463 '''Adds a tenant flavor to openstack VIM
464 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
465 Returns the flavor identifier
467 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
471 name
=flavor_data
['name']
472 while retry
<max_retries
:
475 self
._reload
_connection
()
476 if change_name_if_used
:
479 fl
=self
.nova
.flavors
.list()
481 fl_names
.append(f
.name
)
482 while name
in fl_names
:
484 name
= flavor_data
['name']+"-" + str(name_suffix
)
486 ram
= flavor_data
.get('ram',64)
487 vcpus
= flavor_data
.get('vcpus',1)
490 extended
= flavor_data
.get("extended")
492 numas
=extended
.get("numas")
494 numa_nodes
= len(numas
)
496 return -1, "Can not add flavor with more than one numa"
497 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
498 numa_properties
["hw:mem_page_size"] = "large"
499 numa_properties
["hw:cpu_policy"] = "dedicated"
500 numa_properties
["hw:numa_mempolicy"] = "strict"
502 #overwrite ram and vcpus
503 ram
= numa
['memory']*1024
504 if 'paired-threads' in numa
:
505 vcpus
= numa
['paired-threads']*2
506 numa_properties
["hw:cpu_threads_policy"] = "prefer"
507 elif 'cores' in numa
:
508 vcpus
= numa
['cores']
509 #numa_properties["hw:cpu_threads_policy"] = "prefer"
510 elif 'threads' in numa
:
511 vcpus
= numa
['threads']
512 numa_properties
["hw:cpu_policy"] = "isolated"
513 for interface
in numa
.get("interfaces",() ):
514 if interface
["dedicated"]=="yes":
515 raise vimconn
.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code
=vimconn
.HTTP_Service_Unavailable
)
516 #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
519 new_flavor
=self
.nova
.flavors
.create(name
,
522 flavor_data
.get('disk',1),
523 is_public
=flavor_data
.get('is_public', True)
527 new_flavor
.set_keys(numa_properties
)
529 except nvExceptions
.Conflict
as e
:
530 if change_name_if_used
and retry
< max_retries
:
532 self
._format
_exception
(e
)
533 #except nvExceptions.BadRequest as e:
534 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
535 self
._format
_exception
(e
)
537 def delete_flavor(self
,flavor_id
):
538 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
541 self
._reload
_connection
()
542 self
.nova
.flavors
.delete(flavor_id
)
544 #except nvExceptions.BadRequest as e:
545 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
546 self
._format
_exception
(e
)
548 def new_image(self
,image_dict
):
550 Adds a tenant image to VIM. imge_dict is a dictionary with:
552 disk_format: qcow2, vhd, vmdk, raw (by default), ...
553 location: path or URI
554 public: "yes" or "no"
555 metadata: metadata of the image
558 #using version 1 of glance client
559 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
562 while retry
<max_retries
:
565 self
._reload
_connection
()
566 #determine format http://docs.openstack.org/developer/glance/formats.html
567 if "disk_format" in image_dict
:
568 disk_format
=image_dict
["disk_format"]
569 else: #autodiscover based on extension
570 if image_dict
['location'][-6:]==".qcow2":
572 elif image_dict
['location'][-4:]==".vhd":
574 elif image_dict
['location'][-5:]==".vmdk":
576 elif image_dict
['location'][-4:]==".vdi":
578 elif image_dict
['location'][-4:]==".iso":
580 elif image_dict
['location'][-4:]==".aki":
582 elif image_dict
['location'][-4:]==".ari":
584 elif image_dict
['location'][-4:]==".ami":
588 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
589 if image_dict
['location'][0:4]=="http":
590 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
591 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
593 with
open(image_dict
['location']) as fimage
:
594 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
595 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
596 #insert metadata. We cannot use 'new_image.properties.setdefault'
597 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
598 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
599 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
600 metadata_to_load
= image_dict
.get('metadata')
602 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
603 new_image_nova
.metadata
.setdefault(k
,v
)
605 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
606 self
._format
_exception
(e
)
607 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
608 if retry
==max_retries
:
610 self
._format
_exception
(e
)
611 except IOError as e
: #can not open the file
612 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
613 http_code
=vimconn
.HTTP_Bad_Request
)
615 def delete_image(self
, image_id
):
616 '''Deletes a tenant image from openstack VIM. Returns the old id
619 self
._reload
_connection
()
620 self
.nova
.images
.delete(image_id
)
622 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
623 self
._format
_exception
(e
)
625 def get_image_id_from_path(self
, path
):
626 '''Get the image id from image path in the VIM database. Returns the image_id'''
628 self
._reload
_connection
()
629 images
= self
.nova
.images
.list()
631 if image
.metadata
.get("location")==path
:
633 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
634 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
635 self
._format
_exception
(e
)
637 def get_image_list(self
, filter_dict
={}):
638 '''Obtain tenant images from VIM
642 checksum: image checksum
643 Returns the image list of dictionaries:
644 [{<the fields at Filter_dict plus some VIM specific>}, ...]
647 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
649 self
._reload
_connection
()
650 filter_dict_os
=filter_dict
.copy()
651 #First we filter by the available filter fields: name, id. The others are removed.
652 filter_dict_os
.pop('checksum',None)
653 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
654 if len(image_list
)==0:
656 #Then we filter by the rest of filter fields: checksum
658 for image
in image_list
:
659 image_dict
=self
.glance
.images
.get(image
.id)
660 if 'checksum' not in filter_dict
or image_dict
['checksum']==filter_dict
.get('checksum'):
661 filtered_list
.append(image_dict
)
663 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
664 self
._format
_exception
(e
)
666 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
667 '''Adds a VM instance to VIM
669 start: indicates if VM must start or boot in pause mode. Ignored
670 image_id,flavor_id: iamge and flavor uuid
671 net_list: list of interfaces, each one is a dictionary with:
673 net_id: network uuid to connect
674 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
675 model: interface model, ignored #TODO
676 mac_address: used for SR-IOV ifaces #TODO for other types
677 use: 'data', 'bridge', 'mgmt'
678 type: 'virtual', 'PF', 'VF', 'VFnotShared'
679 vim_id: filled/added by this function
680 floating_ip: True/False (or it can be None)
681 #TODO ip, security groups
682 Returns the instance identifier
684 self
.logger
.debug("Creating VM image '%s' flavor '%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
688 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
689 self
._reload
_connection
()
690 metadata_vpci
={} #For a specific neutron plugin
692 if not net
.get("net_id"): #skip non connected iface
694 if net
["type"]=="virtual" or net
["type"]=="VF":
696 "network_id": net
["net_id"],
697 "name": net
.get("name"),
698 "admin_state_up": True
700 if net
["type"]=="virtual":
702 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
705 if "VF" not in metadata_vpci
:
706 metadata_vpci
["VF"]=[]
707 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
708 port_dict
["binding:vnic_type"]="direct"
709 if not port_dict
["name"]:
710 port_dict
["name"]=name
711 if net
.get("mac_address"):
712 port_dict
["mac_address"]=net
["mac_address"]
713 if net
.get("port_security") == False:
714 port_dict
["port_security_enabled"]=net
["port_security"]
715 new_port
= self
.neutron
.create_port({"port": port_dict
})
716 net
["mac_adress"] = new_port
["port"]["mac_address"]
717 net
["vim_id"] = new_port
["port"]["id"]
718 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
719 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
721 self
.logger
.warn("new_vminstance: Warning, can not connect a passthrough interface ")
722 #TODO insert this when openstack consider passthrough ports as openstack neutron ports
723 if net
.get('floating_ip', False):
724 external_network
.append(net
)
727 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
728 if len(metadata
["pci_assignement"]) >255:
729 #limit the metadata size
730 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
731 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
734 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
735 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
737 security_groups
= self
.config
.get('security_groups')
738 if type(security_groups
) is str:
739 security_groups
= ( security_groups
, )
743 if isinstance(cloud_config
, dict):
744 if cloud_config
.get("user-data"):
745 userdata
=cloud_config
["user-data"]
746 if cloud_config
.get("boot-data-drive") != None:
747 config_drive
= cloud_config
["boot-data-drive"]
748 if cloud_config
.get("config-files") or cloud_config
.get("users") or cloud_config
.get("key-pairs"):
750 raise vimconn
.vimconnConflictException("Cloud-config cannot contain both 'userdata' and 'config-files'/'users'/'key-pairs'")
753 if cloud_config
.get("key-pairs"):
754 userdata_dict
["ssh-authorized-keys"] = cloud_config
["key-pairs"]
755 userdata_dict
["users"] = [{"default": None, "ssh-authorized-keys": cloud_config
["key-pairs"] }]
756 if cloud_config
.get("users"):
757 if "users" not in cloud_config
:
758 userdata_dict
["users"] = [ "default" ]
759 for user
in cloud_config
["users"]:
761 "name" : user
["name"],
762 "sudo": "ALL = (ALL)NOPASSWD:ALL"
764 if "user-info" in user
:
765 user_info
["gecos"] = user
["user-info"]
766 if user
.get("key-pairs"):
767 user_info
["ssh-authorized-keys"] = user
["key-pairs"]
768 userdata_dict
["users"].append(user_info
)
770 if cloud_config
.get("config-files"):
771 userdata_dict
["write_files"] = []
772 for file in cloud_config
["config-files"]:
774 "path" : file["dest"],
775 "content": file["content"]
777 if file.get("encoding"):
778 file_info
["encoding"] = file["encoding"]
779 if file.get("permissions"):
780 file_info
["permissions"] = file["permissions"]
781 if file.get("owner"):
782 file_info
["owner"] = file["owner"]
783 userdata_dict
["write_files"].append(file_info
)
784 userdata
= "#cloud-config\n"
785 userdata
+= yaml
.safe_dump(userdata_dict
, indent
=4, default_flow_style
=False)
786 self
.logger
.debug("userdata: %s", userdata
)
787 elif isinstance(cloud_config
, str):
788 userdata
= cloud_config
790 #Create additional volumes in case these are present in disk_list
791 block_device_mapping
= None
792 base_disk_index
= ord('b')
793 if disk_list
!= None:
794 block_device_mapping
= dict()
795 for disk
in disk_list
:
796 if 'image_id' in disk
:
797 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
798 chr(base_disk_index
), imageRef
= disk
['image_id'])
800 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
801 chr(base_disk_index
))
802 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
805 #wait until volumes are with status available
808 while keep_waiting
and elapsed_time
< volume_timeout
:
810 for volume_id
in block_device_mapping
.itervalues():
811 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
817 #if we exceeded the timeout rollback
818 if elapsed_time
>= volume_timeout
:
819 #delete the volumes we just created
820 for volume_id
in block_device_mapping
.itervalues():
821 self
.cinder
.volumes
.delete(volume_id
)
823 #delete ports we just created
824 for net_item
in net_list_vim
:
825 if 'port-id' in net_item
:
826 self
.neutron
.delete_port(net_item
['port-id'])
828 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
829 http_code
=vimconn
.HTTP_Request_Timeout
)
831 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
832 security_groups
=security_groups
,
833 availability_zone
=self
.config
.get('availability_zone'),
834 key_name
=self
.config
.get('keypair'),
836 config_drive
= config_drive
,
837 block_device_mapping
= block_device_mapping
838 ) # , description=description)
839 #print "DONE :-)", server
841 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
842 for floating_network
in external_network
:
843 # wait until vm is active
845 while elapsed_time
< server_timeout
:
846 status
= self
.nova
.servers
.get(server
.id).status
847 if status
== 'ACTIVE':
852 #if we exceeded the timeout rollback
853 if elapsed_time
>= server_timeout
:
854 self
.delete_vminstance(server
.id)
855 raise vimconn
.vimconnException('Timeout creating instance ' + name
,
856 http_code
=vimconn
.HTTP_Request_Timeout
)
859 while(assigned
== False):
861 ip
= floating_ips
.pop(0)
862 if not ip
.get("port_id", False) and ip
.get('tenant_id') == server
.tenant_id
:
863 free_floating_ip
= ip
.get("floating_ip_address")
865 fix_ip
= floating_network
.get('ip')
866 server
.add_floating_ip(free_floating_ip
, fix_ip
)
868 except Exception as e
:
869 self
.delete_vminstance(server
.id)
870 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
872 #Find the external network
873 external_nets
= list()
874 for net
in self
.neutron
.list_networks()['networks']:
875 if net
['router:external']:
876 external_nets
.append(net
)
878 if len(external_nets
) == 0:
879 self
.delete_vminstance(server
.id)
880 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
881 "network is present",
882 http_code
=vimconn
.HTTP_Conflict
)
883 if len(external_nets
) > 1:
884 self
.delete_vminstance(server
.id)
885 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
886 "external networks are present",
887 http_code
=vimconn
.HTTP_Conflict
)
889 pool_id
= external_nets
[0].get('id')
890 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
892 #self.logger.debug("Creating floating IP")
893 new_floating_ip
= self
.neutron
.create_floatingip(param
)
894 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
895 fix_ip
= floating_network
.get('ip')
896 server
.add_floating_ip(free_floating_ip
, fix_ip
)
898 except Exception as e
:
899 self
.delete_vminstance(server
.id)
900 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
903 # except nvExceptions.NotFound as e:
904 # error_value=-vimconn.HTTP_Not_Found
905 # error_text= "vm instance %s not found" % vm_id
906 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
908 # delete the volumes we just created
909 if block_device_mapping
!= None:
910 for volume_id
in block_device_mapping
.itervalues():
911 self
.cinder
.volumes
.delete(volume_id
)
913 # delete ports we just created
914 for net_item
in net_list_vim
:
915 if 'port-id' in net_item
:
916 self
.neutron
.delete_port(net_item
['port-id'])
917 self
._format
_exception
(e
)
918 except TypeError as e
:
919 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
921 def get_vminstance(self
,vm_id
):
922 '''Returns the VM instance information from VIM'''
923 #self.logger.debug("Getting VM from VIM")
925 self
._reload
_connection
()
926 server
= self
.nova
.servers
.find(id=vm_id
)
927 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
928 return server
.to_dict()
929 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
930 self
._format
_exception
(e
)
932 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
934 Get a console for the virtual machine
936 vm_id: uuid of the VM
937 console_type, can be:
938 "novnc" (by default), "xvpvnc" for VNC types,
939 "rdp-html5" for RDP types, "spice-html5" for SPICE types
940 Returns dict with the console parameters:
941 protocol: ssh, ftp, http, https, ...
942 server: usually ip address
943 port: the http, ssh, ... port
944 suffix: extra text, e.g. the http path and query string
946 self
.logger
.debug("Getting VM CONSOLE from VIM")
948 self
._reload
_connection
()
949 server
= self
.nova
.servers
.find(id=vm_id
)
950 if console_type
== None or console_type
== "novnc":
951 console_dict
= server
.get_vnc_console("novnc")
952 elif console_type
== "xvpvnc":
953 console_dict
= server
.get_vnc_console(console_type
)
954 elif console_type
== "rdp-html5":
955 console_dict
= server
.get_rdp_console(console_type
)
956 elif console_type
== "spice-html5":
957 console_dict
= server
.get_spice_console(console_type
)
959 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
961 console_dict1
= console_dict
.get("console")
963 console_url
= console_dict1
.get("url")
966 protocol_index
= console_url
.find("//")
967 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
968 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
969 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
970 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
971 console_dict
={"protocol": console_url
[0:protocol_index
],
972 "server": console_url
[protocol_index
+2:port_index
],
973 "port": console_url
[port_index
:suffix_index
],
974 "suffix": console_url
[suffix_index
+1:]
978 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
980 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
981 self
._format
_exception
(e
)
983 def delete_vminstance(self
, vm_id
):
984 '''Removes a VM instance from VIM. Returns the old identifier
986 #print "osconnector: Getting VM from VIM"
988 self
._reload
_connection
()
989 #delete VM ports attached to this networks before the virtual machine
990 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
991 for p
in ports
['ports']:
993 self
.neutron
.delete_port(p
["id"])
994 except Exception as e
:
995 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
997 #commented because detaching the volumes makes the servers.delete not work properly ?!?
998 #dettach volumes attached
999 server
= self
.nova
.servers
.get(vm_id
)
1000 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
1001 #for volume in volumes_attached_dict:
1002 # self.cinder.volumes.detach(volume['id'])
1004 self
.nova
.servers
.delete(vm_id
)
1007 #Although having detached them should have them in active status
1008 #we ensure in this loop
1011 while keep_waiting
and elapsed_time
< volume_timeout
:
1012 keep_waiting
= False
1013 for volume
in volumes_attached_dict
:
1014 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
1017 self
.cinder
.volumes
.delete(volume
['id'])
1023 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1024 self
._format
_exception
(e
)
1025 #TODO insert exception vimconn.HTTP_Unauthorized
1026 #if reaching here is because an exception
1028 def refresh_vms_status(self
, vm_list
):
1029 '''Get the status of the virtual machines and their interfaces/ports
1030 Params: the list of VM identifiers
1031 Returns a dictionary with:
1032 vm_id: #VIM id of this Virtual Machine
1033 status: #Mandatory. Text with one of:
1034 # DELETED (not found at vim)
1035 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1036 # OTHER (Vim reported other status not understood)
1037 # ERROR (VIM indicates an ERROR status)
1038 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1039 # CREATING (on building process), ERROR
1040 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1042 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1043 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1045 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1046 mac_address: #Text format XX:XX:XX:XX:XX:XX
1047 vim_net_id: #network id where this interface is connected
1048 vim_interface_id: #interface/port VIM id
1049 ip_address: #null, or text with IPv4, IPv6 address
1052 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1053 for vm_id
in vm_list
:
1056 vm_vim
= self
.get_vminstance(vm_id
)
1057 if vm_vim
['status'] in vmStatus2manoFormat
:
1058 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1060 vm
['status'] = "OTHER"
1061 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1063 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1064 except yaml
.representer
.RepresenterError
:
1065 vm
['vim_info'] = str(vm_vim
)
1066 vm
["interfaces"] = []
1067 if vm_vim
.get('fault'):
1068 vm
['error_msg'] = str(vm_vim
['fault'])
1071 self
._reload
_connection
()
1072 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1073 for port
in port_dict
["ports"]:
1076 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1077 except yaml
.representer
.RepresenterError
:
1078 interface
['vim_info'] = str(port
)
1079 interface
["mac_address"] = port
.get("mac_address")
1080 interface
["vim_net_id"] = port
["network_id"]
1081 interface
["vim_interface_id"] = port
["id"]
1083 #look for floating ip address
1084 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1085 if floating_ip_dict
.get("floatingips"):
1086 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1088 for subnet
in port
["fixed_ips"]:
1089 ips
.append(subnet
["ip_address"])
1090 interface
["ip_address"] = ";".join(ips
)
1091 vm
["interfaces"].append(interface
)
1092 except Exception as e
:
1093 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1094 except vimconn
.vimconnNotFoundException
as e
:
1095 self
.logger
.error("Exception getting vm status: %s", str(e
))
1096 vm
['status'] = "DELETED"
1097 vm
['error_msg'] = str(e
)
1098 except vimconn
.vimconnException
as e
:
1099 self
.logger
.error("Exception getting vm status: %s", str(e
))
1100 vm
['status'] = "VIM_ERROR"
1101 vm
['error_msg'] = str(e
)
1105 def action_vminstance(self
, vm_id
, action_dict
):
1106 '''Send and action over a VM instance from VIM
1107 Returns the vm_id if the action was successfully sent to the VIM'''
1108 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1110 self
._reload
_connection
()
1111 server
= self
.nova
.servers
.find(id=vm_id
)
1112 if "start" in action_dict
:
1113 if action_dict
["start"]=="rebuild":
1116 if server
.status
=="PAUSED":
1118 elif server
.status
=="SUSPENDED":
1120 elif server
.status
=="SHUTOFF":
1122 elif "pause" in action_dict
:
1124 elif "resume" in action_dict
:
1126 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1128 elif "forceOff" in action_dict
:
1130 elif "terminate" in action_dict
:
1132 elif "createImage" in action_dict
:
1133 server
.create_image()
1134 #"path":path_schema,
1135 #"description":description_schema,
1136 #"name":name_schema,
1137 #"metadata":metadata_schema,
1138 #"imageRef": id_schema,
1139 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1140 elif "rebuild" in action_dict
:
1141 server
.rebuild(server
.image
['id'])
1142 elif "reboot" in action_dict
:
1143 server
.reboot() #reboot_type='SOFT'
1144 elif "console" in action_dict
:
1145 console_type
= action_dict
["console"]
1146 if console_type
== None or console_type
== "novnc":
1147 console_dict
= server
.get_vnc_console("novnc")
1148 elif console_type
== "xvpvnc":
1149 console_dict
= server
.get_vnc_console(console_type
)
1150 elif console_type
== "rdp-html5":
1151 console_dict
= server
.get_rdp_console(console_type
)
1152 elif console_type
== "spice-html5":
1153 console_dict
= server
.get_spice_console(console_type
)
1155 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1156 http_code
=vimconn
.HTTP_Bad_Request
)
1158 console_url
= console_dict
["console"]["url"]
1160 protocol_index
= console_url
.find("//")
1161 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1162 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1163 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1164 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1165 console_dict2
={"protocol": console_url
[0:protocol_index
],
1166 "server": console_url
[protocol_index
+2 : port_index
],
1167 "port": int(console_url
[port_index
+1 : suffix_index
]),
1168 "suffix": console_url
[suffix_index
+1:]
1170 return console_dict2
1171 except Exception as e
:
1172 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1175 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1176 self
._format
_exception
(e
)
1177 #TODO insert exception vimconn.HTTP_Unauthorized
1181 def new_external_port(self
, port_data
):
1182 #TODO openstack if needed
1183 '''Adds a external port to VIM'''
1184 '''Returns the port identifier'''
1185 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1187 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1188 #TODO openstack if needed
1189 '''Connects a external port to a network'''
1190 '''Returns status code of the VIM response'''
1191 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1193 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1194 '''Adds a new user to openstack VIM'''
1195 '''Returns the user identifier'''
1196 self
.logger
.debug("osconnector: Adding a new user to VIM")
1198 self
._reload
_connection
()
1199 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1200 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1202 except ksExceptions
.ConnectionError
as e
:
1203 error_value
=-vimconn
.HTTP_Bad_Request
1204 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1205 except ksExceptions
.ClientException
as e
: #TODO remove
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 self
.logger
.debug("new_user " + error_text
)
1212 return error_value
, error_text
1214 def delete_user(self
, user_id
):
1215 '''Delete a user from openstack VIM'''
1216 '''Returns the user identifier'''
1218 print "osconnector: Deleting a user from VIM"
1220 self
._reload
_connection
()
1221 self
.keystone
.users
.delete(user_id
)
1223 except ksExceptions
.ConnectionError
as e
:
1224 error_value
=-vimconn
.HTTP_Bad_Request
1225 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1226 except ksExceptions
.NotFound
as e
:
1227 error_value
=-vimconn
.HTTP_Not_Found
1228 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1229 except ksExceptions
.ClientException
as e
: #TODO remove
1230 error_value
=-vimconn
.HTTP_Bad_Request
1231 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1232 #TODO insert exception vimconn.HTTP_Unauthorized
1233 #if reaching here is because an exception
1235 print "delete_tenant " + error_text
1236 return error_value
, error_text
1238 def get_hosts_info(self
):
1239 '''Get the information of deployed hosts
1240 Returns the hosts content'''
1242 print "osconnector: Getting Host info from VIM"
1245 self
._reload
_connection
()
1246 hypervisors
= self
.nova
.hypervisors
.list()
1247 for hype
in hypervisors
:
1248 h_list
.append( hype
.to_dict() )
1249 return 1, {"hosts":h_list
}
1250 except nvExceptions
.NotFound
as e
:
1251 error_value
=-vimconn
.HTTP_Not_Found
1252 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1253 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1254 error_value
=-vimconn
.HTTP_Bad_Request
1255 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1256 #TODO insert exception vimconn.HTTP_Unauthorized
1257 #if reaching here is because an exception
1259 print "get_hosts_info " + error_text
1260 return error_value
, error_text
1262 def get_hosts(self
, vim_tenant
):
1263 '''Get the hosts and deployed instances
1264 Returns the hosts content'''
1265 r
, hype_dict
= self
.get_hosts_info()
1268 hypervisors
= hype_dict
["hosts"]
1270 servers
= self
.nova
.servers
.list()
1271 for hype
in hypervisors
:
1272 for server
in servers
:
1273 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1275 hype
['vm'].append(server
.id)
1277 hype
['vm'] = [server
.id]
1279 except nvExceptions
.NotFound
as e
:
1280 error_value
=-vimconn
.HTTP_Not_Found
1281 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1282 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1283 error_value
=-vimconn
.HTTP_Bad_Request
1284 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1285 #TODO insert exception vimconn.HTTP_Unauthorized
1286 #if reaching here is because an exception
1288 print "get_hosts " + error_text
1289 return error_value
, error_text