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$"
39 from novaclient
import client
as nClient_v2
, exceptions
as nvExceptions
40 from novaclient
import api_versions
41 import keystoneclient
.v2_0
.client
as ksClient_v2
42 from novaclient
.v2
.client
import Client
as nClient
43 import keystoneclient
.v3
.client
as ksClient
44 import keystoneclient
.exceptions
as ksExceptions
45 import glanceclient
.v2
.client
as glClient
46 import glanceclient
.client
as gl1Client
47 import glanceclient
.exc
as gl1Exceptions
48 import cinderclient
.v2
.client
as cClient_v2
49 from httplib
import HTTPException
50 from neutronclient
.neutron
import client
as neClient_v2
51 from neutronclient
.v2_0
import client
as neClient
52 from neutronclient
.common
import exceptions
as neExceptions
53 from requests
.exceptions
import ConnectionError
55 '''contain the openstack virtual machine status to openmano status'''
56 vmStatus2manoFormat
={'ACTIVE':'ACTIVE',
58 'SUSPENDED': 'SUSPENDED',
61 'ERROR':'ERROR','DELETED':'DELETED'
63 netStatus2manoFormat
={'ACTIVE':'ACTIVE','PAUSED':'PAUSED','INACTIVE':'INACTIVE','BUILD':'BUILD','ERROR':'ERROR','DELETED':'DELETED'
66 #global var to have a timeout creating and deleting volumes
70 class vimconnector(vimconn
.vimconnector
):
71 def __init__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
=None, user
=None, passwd
=None,
72 log_level
=None, config
={}, persistent_info
={}):
73 '''using common constructor parameters. In this case
74 'url' is the keystone authorization url,
75 'url_admin' is not use
77 self
.osc_api_version
= 'v2.0'
78 if config
.get('APIversion') == 'v3.3':
79 self
.osc_api_version
= 'v3.3'
80 vimconn
.vimconnector
.__init
__(self
, uuid
, name
, tenant_id
, tenant_name
, url
, url_admin
, user
, passwd
, log_level
, config
)
82 self
.persistent_info
= persistent_info
85 if self
.config
.get("insecure"):
86 self
.k_creds
["insecure"] = True
87 self
.n_creds
["insecure"] = True
89 raise TypeError, 'url param can not be NoneType'
90 self
.k_creds
['auth_url'] = url
91 self
.n_creds
['auth_url'] = url
93 self
.k_creds
['tenant_name'] = tenant_name
94 self
.n_creds
['project_id'] = tenant_name
96 self
.k_creds
['tenant_id'] = tenant_id
97 self
.n_creds
['tenant_id'] = tenant_id
99 self
.k_creds
['username'] = user
100 self
.n_creds
['username'] = user
102 self
.k_creds
['password'] = passwd
103 self
.n_creds
['api_key'] = passwd
104 if self
.osc_api_version
== 'v3.3':
105 self
.k_creds
['project_name'] = tenant_name
106 self
.k_creds
['project_id'] = tenant_id
107 if config
.get('region_name'):
108 self
.k_creds
['region_name'] = config
.get('region_name')
109 self
.n_creds
['region_name'] = config
.get('region_name')
111 self
.reload_client
= True
112 self
.logger
= logging
.getLogger('openmano.vim.openstack')
114 self
.logger
.setLevel( getattr(logging
, log_level
) )
116 def __setitem__(self
,index
, value
):
117 '''Set individuals parameters
118 Throw TypeError, KeyError
120 if index
=='tenant_id':
121 self
.reload_client
=True
122 self
.tenant_id
= value
123 if self
.osc_api_version
== 'v3.3':
125 self
.k_creds
['project_id'] = value
126 self
.n_creds
['project_id'] = value
128 del self
.k_creds
['project_id']
129 del self
.n_creds
['project_id']
132 self
.k_creds
['tenant_id'] = value
133 self
.n_creds
['tenant_id'] = value
135 del self
.k_creds
['tenant_id']
136 del self
.n_creds
['tenant_id']
137 elif index
=='tenant_name':
138 self
.reload_client
=True
139 self
.tenant_name
= value
140 if self
.osc_api_version
== 'v3.3':
142 self
.k_creds
['project_name'] = value
143 self
.n_creds
['project_name'] = value
145 del self
.k_creds
['project_name']
146 del self
.n_creds
['project_name']
149 self
.k_creds
['tenant_name'] = value
150 self
.n_creds
['project_id'] = value
152 del self
.k_creds
['tenant_name']
153 del self
.n_creds
['project_id']
155 self
.reload_client
=True
158 self
.k_creds
['username'] = value
159 self
.n_creds
['username'] = value
161 del self
.k_creds
['username']
162 del self
.n_creds
['username']
163 elif index
=='passwd':
164 self
.reload_client
=True
167 self
.k_creds
['password'] = value
168 self
.n_creds
['api_key'] = value
170 del self
.k_creds
['password']
171 del self
.n_creds
['api_key']
173 self
.reload_client
=True
176 self
.k_creds
['auth_url'] = value
177 self
.n_creds
['auth_url'] = value
179 raise TypeError, 'url param can not be NoneType'
181 vimconn
.vimconnector
.__setitem
__(self
,index
, value
)
183 def _reload_connection(self
):
184 '''Called before any operation, it check if credentials has changed
185 Throw keystoneclient.apiclient.exceptions.AuthorizationFailure
187 #TODO control the timing and possible token timeout, but it seams that python client does this task for us :-)
188 if self
.reload_client
:
190 if len(self
.n_creds
) <4:
191 raise ksExceptions
.ClientException("Not enough parameters to connect to openstack")
192 if self
.osc_api_version
== 'v3.3':
193 self
.nova
= nClient(api_version
=api_versions
.APIVersion(version_str
='2.0'), **self
.n_creds
)
194 #TODO To be updated for v3
195 #self.cinder = cClient.Client(**self.n_creds)
196 self
.keystone
= ksClient
.Client(**self
.k_creds
)
197 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
198 self
.neutron
= neClient
.Client(api_version
=api_versions
.APIVersion(version_str
='2.0'), endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
200 self
.nova
= nClient_v2
.Client(version
='2', **self
.n_creds
)
201 self
.cinder
= cClient_v2
.Client(**self
.n_creds
)
202 self
.keystone
= ksClient_v2
.Client(**self
.k_creds
)
203 self
.ne_endpoint
=self
.keystone
.service_catalog
.url_for(service_type
='network', endpoint_type
='publicURL')
204 self
.neutron
= neClient_v2
.Client('2.0', endpoint_url
=self
.ne_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
)
205 self
.glance_endpoint
= self
.keystone
.service_catalog
.url_for(service_type
='image', endpoint_type
='publicURL')
206 self
.glance
= glClient
.Client(self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
207 self
.reload_client
= False
209 def __net_os2mano(self
, net_list_dict
):
210 '''Transform the net openstack format to mano format
211 net_list_dict can be a list of dict or a single dict'''
212 if type(net_list_dict
) is dict:
213 net_list_
=(net_list_dict
,)
214 elif type(net_list_dict
) is list:
215 net_list_
=net_list_dict
217 raise TypeError("param net_list_dict must be a list or a dictionary")
218 for net
in net_list_
:
219 if net
.get('provider:network_type') == "vlan":
226 def _format_exception(self
, exception
):
227 '''Transform a keystone, nova, neutron exception into a vimconn exception'''
228 if isinstance(exception
, (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
,
229 ConnectionError
, ksExceptions
.ConnectionError
, neExceptions
.ConnectionFailed
231 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
232 elif isinstance(exception
, (nvExceptions
.ClientException
, ksExceptions
.ClientException
,
233 neExceptions
.NeutronException
, nvExceptions
.BadRequest
)):
234 raise vimconn
.vimconnUnexpectedResponse(type(exception
).__name
__ + ": " + str(exception
))
235 elif isinstance(exception
, (neExceptions
.NetworkNotFoundClient
, nvExceptions
.NotFound
)):
236 raise vimconn
.vimconnNotFoundException(type(exception
).__name
__ + ": " + str(exception
))
237 elif isinstance(exception
, nvExceptions
.Conflict
):
238 raise vimconn
.vimconnConflictException(type(exception
).__name
__ + ": " + str(exception
))
240 raise vimconn
.vimconnConnectionException(type(exception
).__name
__ + ": " + str(exception
))
242 def get_tenant_list(self
, filter_dict
={}):
243 '''Obtain tenants of VIM
244 filter_dict can contain the following keys:
245 name: filter by tenant name
246 id: filter by tenant uuid/id
248 Returns the tenant list of dictionaries: [{'name':'<name>, 'id':'<id>, ...}, ...]
250 self
.logger
.debug("Getting tenants from VIM filter: '%s'", str(filter_dict
))
252 self
._reload
_connection
()
253 if self
.osc_api_version
== 'v3.3':
254 project_class_list
=self
.keystone
.projects
.findall(**filter_dict
)
256 project_class_list
=self
.keystone
.tenants
.findall(**filter_dict
)
258 for project
in project_class_list
:
259 project_list
.append(project
.to_dict())
261 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
262 self
._format
_exception
(e
)
264 def new_tenant(self
, tenant_name
, tenant_description
):
265 '''Adds a new tenant to openstack VIM. Returns the tenant identifier'''
266 self
.logger
.debug("Adding a new tenant name: %s", tenant_name
)
268 self
._reload
_connection
()
269 if self
.osc_api_version
== 'v3.3':
270 project
=self
.keystone
.projects
.create(tenant_name
, tenant_description
)
272 project
=self
.keystone
.tenants
.create(tenant_name
, tenant_description
)
274 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
275 self
._format
_exception
(e
)
277 def delete_tenant(self
, tenant_id
):
278 '''Delete a tenant from openstack VIM. Returns the old tenant identifier'''
279 self
.logger
.debug("Deleting tenant %s from VIM", tenant_id
)
281 self
._reload
_connection
()
282 if self
.osc_api_version
== 'v3.3':
283 self
.keystone
.projects
.delete(tenant_id
)
285 self
.keystone
.tenants
.delete(tenant_id
)
287 except (ksExceptions
.ConnectionError
, ksExceptions
.ClientException
, ConnectionError
) as e
:
288 self
._format
_exception
(e
)
290 def new_network(self
,net_name
, net_type
, ip_profile
=None, shared
=False, vlan
=None):
291 '''Adds a tenant network to VIM. Returns the network identifier'''
292 self
.logger
.debug("Adding a new network to VIM name '%s', type '%s'", net_name
, net_type
)
293 #self.logger.debug(">>>>>>>>>>>>>>>>>> IP profile %s", str(ip_profile))
296 self
._reload
_connection
()
297 network_dict
= {'name': net_name
, 'admin_state_up': True}
298 if net_type
=="data" or net_type
=="ptp":
299 if self
.config
.get('dataplane_physical_net') == None:
300 raise vimconn
.vimconnConflictException("You must provide a 'dataplane_physical_net' at config value before creating sriov network")
301 network_dict
["provider:physical_network"] = self
.config
['dataplane_physical_net'] #"physnet_sriov" #TODO physical
302 network_dict
["provider:network_type"] = "vlan"
304 network_dict
["provider:network_type"] = vlan
305 network_dict
["shared"]=shared
306 new_net
=self
.neutron
.create_network({'network':network_dict
})
308 #create subnetwork, even if there is no profile
311 if 'subnet_address' not in ip_profile
:
312 #Fake subnet is required
313 subnet_rand
= random
.randint(0, 255)
314 ip_profile
['subnet_address'] = "192.168.{}.0/24".format(subnet_rand
)
315 if 'ip_version' not in ip_profile
:
316 ip_profile
['ip_version'] = "IPv4"
317 subnet
={"name":net_name
+"-subnet",
318 "network_id": new_net
["network"]["id"],
319 "ip_version": 4 if ip_profile
['ip_version']=="IPv4" else 6,
320 "cidr": ip_profile
['subnet_address']
322 if 'gateway_address' in ip_profile
:
323 subnet
['gateway_ip'] = ip_profile
['gateway_address']
324 if ip_profile
.get('dns_address'):
325 #TODO: manage dns_address as a list of addresses separated by commas
326 subnet
['dns_nameservers'] = []
327 subnet
['dns_nameservers'].append(ip_profile
['dns_address'])
328 if 'dhcp_enabled' in ip_profile
:
329 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
330 if 'dhcp_start_address' in ip_profile
:
331 subnet
['allocation_pools']=[]
332 subnet
['allocation_pools'].append(dict())
333 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
334 if 'dhcp_count' in ip_profile
:
335 #parts = ip_profile['dhcp_start_address'].split('.')
336 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
337 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
338 ip_int
+= ip_profile
['dhcp_count'] - 1
339 ip_str
= str(netaddr
.IPAddress(ip_int
))
340 subnet
['allocation_pools'][0]['end'] = ip_str
341 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
342 self
.neutron
.create_subnet({"subnet": subnet
} )
343 return new_net
["network"]["id"]
344 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
346 self
.neutron
.delete_network(new_net
['network']['id'])
347 self
._format
_exception
(e
)
349 def get_network_list(self
, filter_dict
={}):
350 '''Obtain tenant networks of VIM
356 admin_state_up: boolean
358 Returns the network list of dictionaries
360 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
362 self
._reload
_connection
()
363 if self
.osc_api_version
== 'v3.3' and "tenant_id" in filter_dict
:
364 filter_dict
['project_id'] = filter_dict
.pop('tenant_id')
365 net_dict
=self
.neutron
.list_networks(**filter_dict
)
366 net_list
=net_dict
["networks"]
367 self
.__net
_os
2mano
(net_list
)
369 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
370 self
._format
_exception
(e
)
372 def get_network(self
, net_id
):
373 '''Obtain details of network from VIM
374 Returns the network information from a network id'''
375 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
376 filter_dict
={"id": net_id
}
377 net_list
= self
.get_network_list(filter_dict
)
379 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
380 elif len(net_list
)>1:
381 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
384 for subnet_id
in net
.get("subnets", () ):
386 subnet
= self
.neutron
.show_subnet(subnet_id
)
387 except Exception as e
:
388 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
389 subnet
= {"id": subnet_id
, "fault": str(e
)}
390 subnets
.append(subnet
)
391 net
["subnets"] = subnets
392 net
["encapsulation"] = net
.get('provider:network_type')
393 net
["segmentation_id"] = net
.get('provider:segmentation_id')
396 def delete_network(self
, net_id
):
397 '''Deletes a tenant network from VIM. Returns the old network identifier'''
398 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
400 self
._reload
_connection
()
401 #delete VM ports attached to this networks before the network
402 ports
= self
.neutron
.list_ports(network_id
=net_id
)
403 for p
in ports
['ports']:
405 self
.neutron
.delete_port(p
["id"])
406 except Exception as e
:
407 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
408 self
.neutron
.delete_network(net_id
)
410 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
411 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
412 self
._format
_exception
(e
)
414 def refresh_nets_status(self
, net_list
):
415 '''Get the status of the networks
416 Params: the list of network identifiers
417 Returns a dictionary with:
418 net_id: #VIM id of this network
419 status: #Mandatory. Text with one of:
420 # DELETED (not found at vim)
421 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
422 # OTHER (Vim reported other status not understood)
423 # ERROR (VIM indicates an ERROR status)
424 # ACTIVE, INACTIVE, DOWN (admin down),
425 # BUILD (on building process)
427 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
428 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
432 for net_id
in net_list
:
435 net_vim
= self
.get_network(net_id
)
436 if net_vim
['status'] in netStatus2manoFormat
:
437 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
439 net
["status"] = "OTHER"
440 net
["error_msg"] = "VIM status reported " + net_vim
['status']
442 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
443 net
['status'] = 'DOWN'
445 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
446 except yaml
.representer
.RepresenterError
:
447 net
['vim_info'] = str(net_vim
)
448 if net_vim
.get('fault'): #TODO
449 net
['error_msg'] = str(net_vim
['fault'])
450 except vimconn
.vimconnNotFoundException
as e
:
451 self
.logger
.error("Exception getting net status: %s", str(e
))
452 net
['status'] = "DELETED"
453 net
['error_msg'] = str(e
)
454 except vimconn
.vimconnException
as e
:
455 self
.logger
.error("Exception getting net status: %s", str(e
))
456 net
['status'] = "VIM_ERROR"
457 net
['error_msg'] = str(e
)
458 net_dict
[net_id
] = net
461 def get_flavor(self
, flavor_id
):
462 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
463 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
465 self
._reload
_connection
()
466 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
467 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
468 return flavor
.to_dict()
469 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
470 self
._format
_exception
(e
)
472 def get_flavor_id_from_data(self
, flavor_dict
):
473 """Obtain flavor id that match the flavor description
474 Returns the flavor_id or raises a vimconnNotFoundException
477 self
._reload
_connection
()
479 numas
= flavor_dict
.get("extended",{}).get("numas")
482 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemted")
484 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
486 # numas = extended.get("numas")
487 for flavor
in self
.nova
.flavors
.list():
488 epa
= flavor
.get_keys()
492 if flavor
.ram
!= flavor_dict
["ram"]:
494 if flavor
.vcpus
!= flavor_dict
["vcpus"]:
496 if flavor
.disk
!= flavor_dict
["disk"]:
499 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
500 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
501 self
._format
_exception
(e
)
504 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
505 '''Adds a tenant flavor to openstack VIM
506 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
507 Returns the flavor identifier
509 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
513 name
=flavor_data
['name']
514 while retry
<max_retries
:
517 self
._reload
_connection
()
518 if change_name_if_used
:
521 fl
=self
.nova
.flavors
.list()
523 fl_names
.append(f
.name
)
524 while name
in fl_names
:
526 name
= flavor_data
['name']+"-" + str(name_suffix
)
528 ram
= flavor_data
.get('ram',64)
529 vcpus
= flavor_data
.get('vcpus',1)
532 extended
= flavor_data
.get("extended")
534 numas
=extended
.get("numas")
536 numa_nodes
= len(numas
)
538 return -1, "Can not add flavor with more than one numa"
539 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
540 numa_properties
["hw:mem_page_size"] = "large"
541 numa_properties
["hw:cpu_policy"] = "dedicated"
542 numa_properties
["hw:numa_mempolicy"] = "strict"
544 #overwrite ram and vcpus
545 ram
= numa
['memory']*1024
546 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
547 if 'paired-threads' in numa
:
548 vcpus
= numa
['paired-threads']*2
549 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
550 numa_properties
["hw:cpu_thread_policy"] = "require"
551 numa_properties
["hw:cpu_policy"] = "dedicated"
552 elif 'cores' in numa
:
553 vcpus
= numa
['cores']
554 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
555 numa_properties
["hw:cpu_thread_policy"] = "isolate"
556 numa_properties
["hw:cpu_policy"] = "dedicated"
557 elif 'threads' in numa
:
558 vcpus
= numa
['threads']
559 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
560 numa_properties
["hw:cpu_thread_policy"] = "prefer"
561 numa_properties
["hw:cpu_policy"] = "dedicated"
562 # for interface in numa.get("interfaces",() ):
563 # if interface["dedicated"]=="yes":
564 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
565 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
568 new_flavor
=self
.nova
.flavors
.create(name
,
571 flavor_data
.get('disk',1),
572 is_public
=flavor_data
.get('is_public', True)
576 new_flavor
.set_keys(numa_properties
)
578 except nvExceptions
.Conflict
as e
:
579 if change_name_if_used
and retry
< max_retries
:
581 self
._format
_exception
(e
)
582 #except nvExceptions.BadRequest as e:
583 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
584 self
._format
_exception
(e
)
586 def delete_flavor(self
,flavor_id
):
587 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
590 self
._reload
_connection
()
591 self
.nova
.flavors
.delete(flavor_id
)
593 #except nvExceptions.BadRequest as e:
594 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
595 self
._format
_exception
(e
)
597 def new_image(self
,image_dict
):
599 Adds a tenant image to VIM. imge_dict is a dictionary with:
601 disk_format: qcow2, vhd, vmdk, raw (by default), ...
602 location: path or URI
603 public: "yes" or "no"
604 metadata: metadata of the image
607 #using version 1 of glance client
608 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
611 while retry
<max_retries
:
614 self
._reload
_connection
()
615 #determine format http://docs.openstack.org/developer/glance/formats.html
616 if "disk_format" in image_dict
:
617 disk_format
=image_dict
["disk_format"]
618 else: #autodiscover based on extension
619 if image_dict
['location'][-6:]==".qcow2":
621 elif image_dict
['location'][-4:]==".vhd":
623 elif image_dict
['location'][-5:]==".vmdk":
625 elif image_dict
['location'][-4:]==".vdi":
627 elif image_dict
['location'][-4:]==".iso":
629 elif image_dict
['location'][-4:]==".aki":
631 elif image_dict
['location'][-4:]==".ari":
633 elif image_dict
['location'][-4:]==".ami":
637 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
638 if image_dict
['location'][0:4]=="http":
639 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
640 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
642 with
open(image_dict
['location']) as fimage
:
643 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
644 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
645 #insert metadata. We cannot use 'new_image.properties.setdefault'
646 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
647 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
648 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
649 metadata_to_load
= image_dict
.get('metadata')
651 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
652 new_image_nova
.metadata
.setdefault(k
,v
)
654 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
655 self
._format
_exception
(e
)
656 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
657 if retry
==max_retries
:
659 self
._format
_exception
(e
)
660 except IOError as e
: #can not open the file
661 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
662 http_code
=vimconn
.HTTP_Bad_Request
)
664 def delete_image(self
, image_id
):
665 '''Deletes a tenant image from openstack VIM. Returns the old id
668 self
._reload
_connection
()
669 self
.nova
.images
.delete(image_id
)
671 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
672 self
._format
_exception
(e
)
674 def get_image_id_from_path(self
, path
):
675 '''Get the image id from image path in the VIM database. Returns the image_id'''
677 self
._reload
_connection
()
678 images
= self
.nova
.images
.list()
680 if image
.metadata
.get("location")==path
:
682 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
683 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
684 self
._format
_exception
(e
)
686 def get_image_list(self
, filter_dict
={}):
687 '''Obtain tenant images from VIM
691 checksum: image checksum
692 Returns the image list of dictionaries:
693 [{<the fields at Filter_dict plus some VIM specific>}, ...]
696 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
698 self
._reload
_connection
()
699 filter_dict_os
=filter_dict
.copy()
700 #First we filter by the available filter fields: name, id. The others are removed.
701 filter_dict_os
.pop('checksum',None)
702 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
703 if len(image_list
)==0:
705 #Then we filter by the rest of filter fields: checksum
707 for image
in image_list
:
708 image_class
=self
.glance
.images
.get(image
.id)
709 if 'checksum' not in filter_dict
or image_class
['checksum']==filter_dict
.get('checksum'):
710 filtered_list
.append(image_class
.copy())
712 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
713 self
._format
_exception
(e
)
715 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
716 '''Adds a VM instance to VIM
718 start: indicates if VM must start or boot in pause mode. Ignored
719 image_id,flavor_id: iamge and flavor uuid
720 net_list: list of interfaces, each one is a dictionary with:
722 net_id: network uuid to connect
723 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
724 model: interface model, ignored #TODO
725 mac_address: used for SR-IOV ifaces #TODO for other types
726 use: 'data', 'bridge', 'mgmt'
727 type: 'virtual', 'PF', 'VF', 'VFnotShared'
728 vim_id: filled/added by this function
729 floating_ip: True/False (or it can be None)
730 #TODO ip, security groups
731 Returns the instance identifier
733 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
737 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
738 self
._reload
_connection
()
739 metadata_vpci
={} #For a specific neutron plugin
741 if not net
.get("net_id"): #skip non connected iface
745 "network_id": net
["net_id"],
746 "name": net
.get("name"),
747 "admin_state_up": True
749 if net
["type"]=="virtual":
751 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
752 elif net
["type"]=="VF": # for VF
754 if "VF" not in metadata_vpci
:
755 metadata_vpci
["VF"]=[]
756 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
757 port_dict
["binding:vnic_type"]="direct"
760 if "PF" not in metadata_vpci
:
761 metadata_vpci
["PF"]=[]
762 metadata_vpci
["PF"].append([ net
["vpci"], "" ])
763 port_dict
["binding:vnic_type"]="direct-physical"
764 if not port_dict
["name"]:
765 port_dict
["name"]=name
766 if net
.get("mac_address"):
767 port_dict
["mac_address"]=net
["mac_address"]
768 if net
.get("port_security") == False:
769 port_dict
["port_security_enabled"]=net
["port_security"]
770 new_port
= self
.neutron
.create_port({"port": port_dict
})
771 net
["mac_adress"] = new_port
["port"]["mac_address"]
772 net
["vim_id"] = new_port
["port"]["id"]
773 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
774 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
776 if net
.get('floating_ip', False):
777 net
['exit_on_floating_ip_error'] = True
778 external_network
.append(net
)
779 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
780 net
['exit_on_floating_ip_error'] = False
781 external_network
.append(net
)
784 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
785 if len(metadata
["pci_assignement"]) >255:
786 #limit the metadata size
787 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
788 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
791 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
792 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
794 security_groups
= self
.config
.get('security_groups')
795 if type(security_groups
) is str:
796 security_groups
= ( security_groups
, )
800 if isinstance(cloud_config
, dict):
801 if cloud_config
.get("user-data"):
802 userdata
=cloud_config
["user-data"]
803 if cloud_config
.get("boot-data-drive") != None:
804 config_drive
= cloud_config
["boot-data-drive"]
805 if cloud_config
.get("config-files") or cloud_config
.get("users") or cloud_config
.get("key-pairs"):
807 raise vimconn
.vimconnConflictException("Cloud-config cannot contain both 'userdata' and 'config-files'/'users'/'key-pairs'")
810 if cloud_config
.get("key-pairs"):
811 userdata_dict
["ssh-authorized-keys"] = cloud_config
["key-pairs"]
812 userdata_dict
["users"] = [{"default": None, "ssh-authorized-keys": cloud_config
["key-pairs"] }]
813 if cloud_config
.get("users"):
814 if "users" not in userdata_dict
:
815 userdata_dict
["users"] = [ "default" ]
816 for user
in cloud_config
["users"]:
818 "name" : user
["name"],
819 "sudo": "ALL = (ALL)NOPASSWD:ALL"
821 if "user-info" in user
:
822 user_info
["gecos"] = user
["user-info"]
823 if user
.get("key-pairs"):
824 user_info
["ssh-authorized-keys"] = user
["key-pairs"]
825 userdata_dict
["users"].append(user_info
)
827 if cloud_config
.get("config-files"):
828 userdata_dict
["write_files"] = []
829 for file in cloud_config
["config-files"]:
831 "path" : file["dest"],
832 "content": file["content"]
834 if file.get("encoding"):
835 file_info
["encoding"] = file["encoding"]
836 if file.get("permissions"):
837 file_info
["permissions"] = file["permissions"]
838 if file.get("owner"):
839 file_info
["owner"] = file["owner"]
840 userdata_dict
["write_files"].append(file_info
)
841 userdata
= "#cloud-config\n"
842 userdata
+= yaml
.safe_dump(userdata_dict
, indent
=4, default_flow_style
=False)
843 self
.logger
.debug("userdata: %s", userdata
)
844 elif isinstance(cloud_config
, str):
845 userdata
= cloud_config
847 #Create additional volumes in case these are present in disk_list
848 block_device_mapping
= None
849 base_disk_index
= ord('b')
850 if disk_list
!= None:
851 block_device_mapping
= dict()
852 for disk
in disk_list
:
853 if 'image_id' in disk
:
854 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
855 chr(base_disk_index
), imageRef
= disk
['image_id'])
857 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
858 chr(base_disk_index
))
859 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
862 #wait until volumes are with status available
865 while keep_waiting
and elapsed_time
< volume_timeout
:
867 for volume_id
in block_device_mapping
.itervalues():
868 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
874 #if we exceeded the timeout rollback
875 if elapsed_time
>= volume_timeout
:
876 #delete the volumes we just created
877 for volume_id
in block_device_mapping
.itervalues():
878 self
.cinder
.volumes
.delete(volume_id
)
880 #delete ports we just created
881 for net_item
in net_list_vim
:
882 if 'port-id' in net_item
:
883 self
.neutron
.delete_port(net_item
['port-id'])
885 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
886 http_code
=vimconn
.HTTP_Request_Timeout
)
888 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
889 security_groups
=security_groups
,
890 availability_zone
=self
.config
.get('availability_zone'),
891 key_name
=self
.config
.get('keypair'),
893 config_drive
= config_drive
,
894 block_device_mapping
= block_device_mapping
895 ) # , description=description)
896 #print "DONE :-)", server
898 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
899 for floating_network
in external_network
:
901 # wait until vm is active
903 while elapsed_time
< server_timeout
:
904 status
= self
.nova
.servers
.get(server
.id).status
905 if status
== 'ACTIVE':
910 #if we exceeded the timeout rollback
911 if elapsed_time
>= server_timeout
:
912 raise vimconn
.vimconnException('Timeout creating instance ' + name
,
913 http_code
=vimconn
.HTTP_Request_Timeout
)
916 while(assigned
== False):
918 ip
= floating_ips
.pop(0)
919 if not ip
.get("port_id", False) and ip
.get('tenant_id') == server
.tenant_id
:
920 free_floating_ip
= ip
.get("floating_ip_address")
922 fix_ip
= floating_network
.get('ip')
923 server
.add_floating_ip(free_floating_ip
, fix_ip
)
925 except Exception as e
:
926 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
928 #Find the external network
929 external_nets
= list()
930 for net
in self
.neutron
.list_networks()['networks']:
931 if net
['router:external']:
932 external_nets
.append(net
)
934 if len(external_nets
) == 0:
935 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
936 "network is present",
937 http_code
=vimconn
.HTTP_Conflict
)
938 if len(external_nets
) > 1:
939 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
940 "external networks are present",
941 http_code
=vimconn
.HTTP_Conflict
)
943 pool_id
= external_nets
[0].get('id')
944 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
946 #self.logger.debug("Creating floating IP")
947 new_floating_ip
= self
.neutron
.create_floatingip(param
)
948 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
949 fix_ip
= floating_network
.get('ip')
950 server
.add_floating_ip(free_floating_ip
, fix_ip
)
952 except Exception as e
:
953 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot assign floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
954 except Exception as e
:
955 if not floating_network
['exit_on_floating_ip_error']:
956 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
958 self
.delete_vminstance(server
.id)
962 # except nvExceptions.NotFound as e:
963 # error_value=-vimconn.HTTP_Not_Found
964 # error_text= "vm instance %s not found" % vm_id
965 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
966 # delete the volumes we just created
967 if block_device_mapping
!= None:
968 for volume_id
in block_device_mapping
.itervalues():
969 self
.cinder
.volumes
.delete(volume_id
)
971 # delete ports we just created
972 for net_item
in net_list_vim
:
973 if 'port-id' in net_item
:
974 self
.neutron
.delete_port(net_item
['port-id'])
975 self
._format
_exception
(e
)
976 except TypeError as e
:
977 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
979 def get_vminstance(self
,vm_id
):
980 '''Returns the VM instance information from VIM'''
981 #self.logger.debug("Getting VM from VIM")
983 self
._reload
_connection
()
984 server
= self
.nova
.servers
.find(id=vm_id
)
985 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
986 return server
.to_dict()
987 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
988 self
._format
_exception
(e
)
990 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
992 Get a console for the virtual machine
994 vm_id: uuid of the VM
995 console_type, can be:
996 "novnc" (by default), "xvpvnc" for VNC types,
997 "rdp-html5" for RDP types, "spice-html5" for SPICE types
998 Returns dict with the console parameters:
999 protocol: ssh, ftp, http, https, ...
1000 server: usually ip address
1001 port: the http, ssh, ... port
1002 suffix: extra text, e.g. the http path and query string
1004 self
.logger
.debug("Getting VM CONSOLE from VIM")
1006 self
._reload
_connection
()
1007 server
= self
.nova
.servers
.find(id=vm_id
)
1008 if console_type
== None or console_type
== "novnc":
1009 console_dict
= server
.get_vnc_console("novnc")
1010 elif console_type
== "xvpvnc":
1011 console_dict
= server
.get_vnc_console(console_type
)
1012 elif console_type
== "rdp-html5":
1013 console_dict
= server
.get_rdp_console(console_type
)
1014 elif console_type
== "spice-html5":
1015 console_dict
= server
.get_spice_console(console_type
)
1017 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1019 console_dict1
= console_dict
.get("console")
1021 console_url
= console_dict1
.get("url")
1024 protocol_index
= console_url
.find("//")
1025 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1026 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1027 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1028 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1029 console_dict
={"protocol": console_url
[0:protocol_index
],
1030 "server": console_url
[protocol_index
+2:port_index
],
1031 "port": console_url
[port_index
:suffix_index
],
1032 "suffix": console_url
[suffix_index
+1:]
1036 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1038 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1039 self
._format
_exception
(e
)
1041 def delete_vminstance(self
, vm_id
):
1042 '''Removes a VM instance from VIM. Returns the old identifier
1044 #print "osconnector: Getting VM from VIM"
1046 self
._reload
_connection
()
1047 #delete VM ports attached to this networks before the virtual machine
1048 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
1049 for p
in ports
['ports']:
1051 self
.neutron
.delete_port(p
["id"])
1052 except Exception as e
:
1053 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
1055 #commented because detaching the volumes makes the servers.delete not work properly ?!?
1056 #dettach volumes attached
1057 server
= self
.nova
.servers
.get(vm_id
)
1058 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
1059 #for volume in volumes_attached_dict:
1060 # self.cinder.volumes.detach(volume['id'])
1062 self
.nova
.servers
.delete(vm_id
)
1065 #Although having detached them should have them in active status
1066 #we ensure in this loop
1069 while keep_waiting
and elapsed_time
< volume_timeout
:
1070 keep_waiting
= False
1071 for volume
in volumes_attached_dict
:
1072 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
1075 self
.cinder
.volumes
.delete(volume
['id'])
1081 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1082 self
._format
_exception
(e
)
1083 #TODO insert exception vimconn.HTTP_Unauthorized
1084 #if reaching here is because an exception
1086 def refresh_vms_status(self
, vm_list
):
1087 '''Get the status of the virtual machines and their interfaces/ports
1088 Params: the list of VM identifiers
1089 Returns a dictionary with:
1090 vm_id: #VIM id of this Virtual Machine
1091 status: #Mandatory. Text with one of:
1092 # DELETED (not found at vim)
1093 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1094 # OTHER (Vim reported other status not understood)
1095 # ERROR (VIM indicates an ERROR status)
1096 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1097 # CREATING (on building process), ERROR
1098 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1100 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1101 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1103 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1104 mac_address: #Text format XX:XX:XX:XX:XX:XX
1105 vim_net_id: #network id where this interface is connected
1106 vim_interface_id: #interface/port VIM id
1107 ip_address: #null, or text with IPv4, IPv6 address
1108 compute_node: #identification of compute node where PF,VF interface is allocated
1109 pci: #PCI address of the NIC that hosts the PF,VF
1110 vlan: #physical VLAN used for VF
1113 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1114 for vm_id
in vm_list
:
1117 vm_vim
= self
.get_vminstance(vm_id
)
1118 if vm_vim
['status'] in vmStatus2manoFormat
:
1119 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1121 vm
['status'] = "OTHER"
1122 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1124 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1125 except yaml
.representer
.RepresenterError
:
1126 vm
['vim_info'] = str(vm_vim
)
1127 vm
["interfaces"] = []
1128 if vm_vim
.get('fault'):
1129 vm
['error_msg'] = str(vm_vim
['fault'])
1132 self
._reload
_connection
()
1133 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1134 for port
in port_dict
["ports"]:
1137 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1138 except yaml
.representer
.RepresenterError
:
1139 interface
['vim_info'] = str(port
)
1140 interface
["mac_address"] = port
.get("mac_address")
1141 interface
["vim_net_id"] = port
["network_id"]
1142 interface
["vim_interface_id"] = port
["id"]
1143 # check if OS-EXT-SRV-ATTR:host is there,
1144 # in case of non-admin credentials, it will be missing
1145 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1146 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1147 interface
["pci"] = None
1149 # check if binding:profile is there,
1150 # in case of non-admin credentials, it will be missing
1151 if port
.get('binding:profile'):
1152 if port
['binding:profile'].get('pci_slot'):
1153 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1154 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1155 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1156 pci
= port
['binding:profile']['pci_slot']
1157 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1158 interface
["pci"] = pci
1159 interface
["vlan"] = None
1160 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1161 network
= self
.neutron
.show_network(port
["network_id"])
1162 if network
['network'].get('provider:network_type') == 'vlan' and \
1163 port
.get("binding:vnic_type") == "direct":
1164 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1166 #look for floating ip address
1167 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1168 if floating_ip_dict
.get("floatingips"):
1169 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1171 for subnet
in port
["fixed_ips"]:
1172 ips
.append(subnet
["ip_address"])
1173 interface
["ip_address"] = ";".join(ips
)
1174 vm
["interfaces"].append(interface
)
1175 except Exception as e
:
1176 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1177 except vimconn
.vimconnNotFoundException
as e
:
1178 self
.logger
.error("Exception getting vm status: %s", str(e
))
1179 vm
['status'] = "DELETED"
1180 vm
['error_msg'] = str(e
)
1181 except vimconn
.vimconnException
as e
:
1182 self
.logger
.error("Exception getting vm status: %s", str(e
))
1183 vm
['status'] = "VIM_ERROR"
1184 vm
['error_msg'] = str(e
)
1188 def action_vminstance(self
, vm_id
, action_dict
):
1189 '''Send and action over a VM instance from VIM
1190 Returns the vm_id if the action was successfully sent to the VIM'''
1191 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1193 self
._reload
_connection
()
1194 server
= self
.nova
.servers
.find(id=vm_id
)
1195 if "start" in action_dict
:
1196 if action_dict
["start"]=="rebuild":
1199 if server
.status
=="PAUSED":
1201 elif server
.status
=="SUSPENDED":
1203 elif server
.status
=="SHUTOFF":
1205 elif "pause" in action_dict
:
1207 elif "resume" in action_dict
:
1209 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1211 elif "forceOff" in action_dict
:
1213 elif "terminate" in action_dict
:
1215 elif "createImage" in action_dict
:
1216 server
.create_image()
1217 #"path":path_schema,
1218 #"description":description_schema,
1219 #"name":name_schema,
1220 #"metadata":metadata_schema,
1221 #"imageRef": id_schema,
1222 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1223 elif "rebuild" in action_dict
:
1224 server
.rebuild(server
.image
['id'])
1225 elif "reboot" in action_dict
:
1226 server
.reboot() #reboot_type='SOFT'
1227 elif "console" in action_dict
:
1228 console_type
= action_dict
["console"]
1229 if console_type
== None or console_type
== "novnc":
1230 console_dict
= server
.get_vnc_console("novnc")
1231 elif console_type
== "xvpvnc":
1232 console_dict
= server
.get_vnc_console(console_type
)
1233 elif console_type
== "rdp-html5":
1234 console_dict
= server
.get_rdp_console(console_type
)
1235 elif console_type
== "spice-html5":
1236 console_dict
= server
.get_spice_console(console_type
)
1238 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1239 http_code
=vimconn
.HTTP_Bad_Request
)
1241 console_url
= console_dict
["console"]["url"]
1243 protocol_index
= console_url
.find("//")
1244 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1245 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1246 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1247 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1248 console_dict2
={"protocol": console_url
[0:protocol_index
],
1249 "server": console_url
[protocol_index
+2 : port_index
],
1250 "port": int(console_url
[port_index
+1 : suffix_index
]),
1251 "suffix": console_url
[suffix_index
+1:]
1253 return console_dict2
1254 except Exception as e
:
1255 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1258 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1259 self
._format
_exception
(e
)
1260 #TODO insert exception vimconn.HTTP_Unauthorized
1264 def new_external_port(self
, port_data
):
1265 #TODO openstack if needed
1266 '''Adds a external port to VIM'''
1267 '''Returns the port identifier'''
1268 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1270 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1271 #TODO openstack if needed
1272 '''Connects a external port to a network'''
1273 '''Returns status code of the VIM response'''
1274 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1276 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1277 '''Adds a new user to openstack VIM'''
1278 '''Returns the user identifier'''
1279 self
.logger
.debug("osconnector: Adding a new user to VIM")
1281 self
._reload
_connection
()
1282 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1283 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1285 except ksExceptions
.ConnectionError
as e
:
1286 error_value
=-vimconn
.HTTP_Bad_Request
1287 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1288 except ksExceptions
.ClientException
as e
: #TODO remove
1289 error_value
=-vimconn
.HTTP_Bad_Request
1290 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1291 #TODO insert exception vimconn.HTTP_Unauthorized
1292 #if reaching here is because an exception
1294 self
.logger
.debug("new_user " + error_text
)
1295 return error_value
, error_text
1297 def delete_user(self
, user_id
):
1298 '''Delete a user from openstack VIM'''
1299 '''Returns the user identifier'''
1301 print "osconnector: Deleting a user from VIM"
1303 self
._reload
_connection
()
1304 self
.keystone
.users
.delete(user_id
)
1306 except ksExceptions
.ConnectionError
as e
:
1307 error_value
=-vimconn
.HTTP_Bad_Request
1308 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1309 except ksExceptions
.NotFound
as e
:
1310 error_value
=-vimconn
.HTTP_Not_Found
1311 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1312 except ksExceptions
.ClientException
as e
: #TODO remove
1313 error_value
=-vimconn
.HTTP_Bad_Request
1314 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1315 #TODO insert exception vimconn.HTTP_Unauthorized
1316 #if reaching here is because an exception
1318 print "delete_tenant " + error_text
1319 return error_value
, error_text
1321 def get_hosts_info(self
):
1322 '''Get the information of deployed hosts
1323 Returns the hosts content'''
1325 print "osconnector: Getting Host info from VIM"
1328 self
._reload
_connection
()
1329 hypervisors
= self
.nova
.hypervisors
.list()
1330 for hype
in hypervisors
:
1331 h_list
.append( hype
.to_dict() )
1332 return 1, {"hosts":h_list
}
1333 except nvExceptions
.NotFound
as e
:
1334 error_value
=-vimconn
.HTTP_Not_Found
1335 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1336 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1337 error_value
=-vimconn
.HTTP_Bad_Request
1338 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1339 #TODO insert exception vimconn.HTTP_Unauthorized
1340 #if reaching here is because an exception
1342 print "get_hosts_info " + error_text
1343 return error_value
, error_text
1345 def get_hosts(self
, vim_tenant
):
1346 '''Get the hosts and deployed instances
1347 Returns the hosts content'''
1348 r
, hype_dict
= self
.get_hosts_info()
1351 hypervisors
= hype_dict
["hosts"]
1353 servers
= self
.nova
.servers
.list()
1354 for hype
in hypervisors
:
1355 for server
in servers
:
1356 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1358 hype
['vm'].append(server
.id)
1360 hype
['vm'] = [server
.id]
1362 except nvExceptions
.NotFound
as e
:
1363 error_value
=-vimconn
.HTTP_Not_Found
1364 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1365 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1366 error_value
=-vimconn
.HTTP_Bad_Request
1367 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1368 #TODO insert exception vimconn.HTTP_Unauthorized
1369 #if reaching here is because an exception
1371 print "get_hosts " + error_text
1372 return error_value
, error_text