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 subnet
['dns_nameservers'] = ip_profile
['dns_address'].split(";")
326 if 'dhcp_enabled' in ip_profile
:
327 subnet
['enable_dhcp'] = False if ip_profile
['dhcp_enabled']=="false" else True
328 if 'dhcp_start_address' in ip_profile
:
329 subnet
['allocation_pools']=[]
330 subnet
['allocation_pools'].append(dict())
331 subnet
['allocation_pools'][0]['start'] = ip_profile
['dhcp_start_address']
332 if 'dhcp_count' in ip_profile
:
333 #parts = ip_profile['dhcp_start_address'].split('.')
334 #ip_int = (int(parts[0]) << 24) + (int(parts[1]) << 16) + (int(parts[2]) << 8) + int(parts[3])
335 ip_int
= int(netaddr
.IPAddress(ip_profile
['dhcp_start_address']))
336 ip_int
+= ip_profile
['dhcp_count'] - 1
337 ip_str
= str(netaddr
.IPAddress(ip_int
))
338 subnet
['allocation_pools'][0]['end'] = ip_str
339 #self.logger.debug(">>>>>>>>>>>>>>>>>> Subnet: %s", str(subnet))
340 self
.neutron
.create_subnet({"subnet": subnet
} )
341 return new_net
["network"]["id"]
342 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
344 self
.neutron
.delete_network(new_net
['network']['id'])
345 self
._format
_exception
(e
)
347 def get_network_list(self
, filter_dict
={}):
348 '''Obtain tenant networks of VIM
354 admin_state_up: boolean
356 Returns the network list of dictionaries
358 self
.logger
.debug("Getting network from VIM filter: '%s'", str(filter_dict
))
360 self
._reload
_connection
()
361 if self
.osc_api_version
== 'v3.3' and "tenant_id" in filter_dict
:
362 filter_dict
['project_id'] = filter_dict
.pop('tenant_id')
363 net_dict
=self
.neutron
.list_networks(**filter_dict
)
364 net_list
=net_dict
["networks"]
365 self
.__net
_os
2mano
(net_list
)
367 except (neExceptions
.ConnectionFailed
, ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
368 self
._format
_exception
(e
)
370 def get_network(self
, net_id
):
371 '''Obtain details of network from VIM
372 Returns the network information from a network id'''
373 self
.logger
.debug(" Getting tenant network %s from VIM", net_id
)
374 filter_dict
={"id": net_id
}
375 net_list
= self
.get_network_list(filter_dict
)
377 raise vimconn
.vimconnNotFoundException("Network '{}' not found".format(net_id
))
378 elif len(net_list
)>1:
379 raise vimconn
.vimconnConflictException("Found more than one network with this criteria")
382 for subnet_id
in net
.get("subnets", () ):
384 subnet
= self
.neutron
.show_subnet(subnet_id
)
385 except Exception as e
:
386 self
.logger
.error("osconnector.get_network(): Error getting subnet %s %s" % (net_id
, str(e
)))
387 subnet
= {"id": subnet_id
, "fault": str(e
)}
388 subnets
.append(subnet
)
389 net
["subnets"] = subnets
390 net
["encapsulation"] = net
.get('provider:network_type')
391 net
["segmentation_id"] = net
.get('provider:segmentation_id')
394 def delete_network(self
, net_id
):
395 '''Deletes a tenant network from VIM. Returns the old network identifier'''
396 self
.logger
.debug("Deleting network '%s' from VIM", net_id
)
398 self
._reload
_connection
()
399 #delete VM ports attached to this networks before the network
400 ports
= self
.neutron
.list_ports(network_id
=net_id
)
401 for p
in ports
['ports']:
403 self
.neutron
.delete_port(p
["id"])
404 except Exception as e
:
405 self
.logger
.error("Error deleting port %s: %s", p
["id"], str(e
))
406 self
.neutron
.delete_network(net_id
)
408 except (neExceptions
.ConnectionFailed
, neExceptions
.NetworkNotFoundClient
, neExceptions
.NeutronException
,
409 ksExceptions
.ClientException
, neExceptions
.NeutronException
, ConnectionError
) as e
:
410 self
._format
_exception
(e
)
412 def refresh_nets_status(self
, net_list
):
413 '''Get the status of the networks
414 Params: the list of network identifiers
415 Returns a dictionary with:
416 net_id: #VIM id of this network
417 status: #Mandatory. Text with one of:
418 # DELETED (not found at vim)
419 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
420 # OTHER (Vim reported other status not understood)
421 # ERROR (VIM indicates an ERROR status)
422 # ACTIVE, INACTIVE, DOWN (admin down),
423 # BUILD (on building process)
425 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
426 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
430 for net_id
in net_list
:
433 net_vim
= self
.get_network(net_id
)
434 if net_vim
['status'] in netStatus2manoFormat
:
435 net
["status"] = netStatus2manoFormat
[ net_vim
['status'] ]
437 net
["status"] = "OTHER"
438 net
["error_msg"] = "VIM status reported " + net_vim
['status']
440 if net
['status'] == "ACTIVE" and not net_vim
['admin_state_up']:
441 net
['status'] = 'DOWN'
443 net
['vim_info'] = yaml
.safe_dump(net_vim
, default_flow_style
=True, width
=256)
444 except yaml
.representer
.RepresenterError
:
445 net
['vim_info'] = str(net_vim
)
446 if net_vim
.get('fault'): #TODO
447 net
['error_msg'] = str(net_vim
['fault'])
448 except vimconn
.vimconnNotFoundException
as e
:
449 self
.logger
.error("Exception getting net status: %s", str(e
))
450 net
['status'] = "DELETED"
451 net
['error_msg'] = str(e
)
452 except vimconn
.vimconnException
as e
:
453 self
.logger
.error("Exception getting net status: %s", str(e
))
454 net
['status'] = "VIM_ERROR"
455 net
['error_msg'] = str(e
)
456 net_dict
[net_id
] = net
459 def get_flavor(self
, flavor_id
):
460 '''Obtain flavor details from the VIM. Returns the flavor dict details'''
461 self
.logger
.debug("Getting flavor '%s'", flavor_id
)
463 self
._reload
_connection
()
464 flavor
= self
.nova
.flavors
.find(id=flavor_id
)
465 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
466 return flavor
.to_dict()
467 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
468 self
._format
_exception
(e
)
470 def get_flavor_id_from_data(self
, flavor_dict
):
471 """Obtain flavor id that match the flavor description
472 Returns the flavor_id or raises a vimconnNotFoundException
473 flavor_dict: contains the required ram, vcpus, disk
474 If 'use_existing_flavors' is set to True at config, the closer flavor that provides same or more ram, vcpus
475 and disk is returned. Otherwise a flavor with exactly same ram, vcpus and disk is returned or a
476 vimconnNotFoundException is raised
478 exact_match
= False if self
.config
.get('use_existing_flavors') else True
480 self
._reload
_connection
()
481 flavor_candidate_id
= None
482 flavor_candidate_data
= (10000, 10000, 10000)
483 flavor_target
= (flavor_dict
["ram"], flavor_dict
["vcpus"], flavor_dict
["disk"])
485 numas
= flavor_dict
.get("extended", {}).get("numas")
488 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemted")
490 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
492 # numas = extended.get("numas")
493 for flavor
in self
.nova
.flavors
.list():
494 epa
= flavor
.get_keys()
498 flavor_data
= (flavor
.ram
, flavor
.vcpus
, flavor
.disk
)
499 if flavor_data
== flavor_target
:
501 elif not exact_match
and flavor_target
< flavor_data
< flavor_candidate_data
:
502 flavor_candidate_id
= flavor
.id
503 flavor_candidate_data
= flavor_data
504 if not exact_match
and flavor_candidate_id
:
505 return flavor_candidate_id
506 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
507 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
508 self
._format
_exception
(e
)
511 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
512 '''Adds a tenant flavor to openstack VIM
513 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
514 Returns the flavor identifier
516 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
520 name
=flavor_data
['name']
521 while retry
<max_retries
:
524 self
._reload
_connection
()
525 if change_name_if_used
:
528 fl
=self
.nova
.flavors
.list()
530 fl_names
.append(f
.name
)
531 while name
in fl_names
:
533 name
= flavor_data
['name']+"-" + str(name_suffix
)
535 ram
= flavor_data
.get('ram',64)
536 vcpus
= flavor_data
.get('vcpus',1)
539 extended
= flavor_data
.get("extended")
541 numas
=extended
.get("numas")
543 numa_nodes
= len(numas
)
545 return -1, "Can not add flavor with more than one numa"
546 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
547 numa_properties
["hw:mem_page_size"] = "large"
548 numa_properties
["hw:cpu_policy"] = "dedicated"
549 numa_properties
["hw:numa_mempolicy"] = "strict"
551 #overwrite ram and vcpus
552 ram
= numa
['memory']*1024
553 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
554 if 'paired-threads' in numa
:
555 vcpus
= numa
['paired-threads']*2
556 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
557 numa_properties
["hw:cpu_thread_policy"] = "require"
558 numa_properties
["hw:cpu_policy"] = "dedicated"
559 elif 'cores' in numa
:
560 vcpus
= numa
['cores']
561 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
562 numa_properties
["hw:cpu_thread_policy"] = "isolate"
563 numa_properties
["hw:cpu_policy"] = "dedicated"
564 elif 'threads' in numa
:
565 vcpus
= numa
['threads']
566 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
567 numa_properties
["hw:cpu_thread_policy"] = "prefer"
568 numa_properties
["hw:cpu_policy"] = "dedicated"
569 # for interface in numa.get("interfaces",() ):
570 # if interface["dedicated"]=="yes":
571 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
572 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
575 new_flavor
=self
.nova
.flavors
.create(name
,
578 flavor_data
.get('disk',1),
579 is_public
=flavor_data
.get('is_public', True)
583 new_flavor
.set_keys(numa_properties
)
585 except nvExceptions
.Conflict
as e
:
586 if change_name_if_used
and retry
< max_retries
:
588 self
._format
_exception
(e
)
589 #except nvExceptions.BadRequest as e:
590 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
591 self
._format
_exception
(e
)
593 def delete_flavor(self
,flavor_id
):
594 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
597 self
._reload
_connection
()
598 self
.nova
.flavors
.delete(flavor_id
)
600 #except nvExceptions.BadRequest as e:
601 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
602 self
._format
_exception
(e
)
604 def new_image(self
,image_dict
):
606 Adds a tenant image to VIM. imge_dict is a dictionary with:
608 disk_format: qcow2, vhd, vmdk, raw (by default), ...
609 location: path or URI
610 public: "yes" or "no"
611 metadata: metadata of the image
614 #using version 1 of glance client
615 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
618 while retry
<max_retries
:
621 self
._reload
_connection
()
622 #determine format http://docs.openstack.org/developer/glance/formats.html
623 if "disk_format" in image_dict
:
624 disk_format
=image_dict
["disk_format"]
625 else: #autodiscover based on extension
626 if image_dict
['location'][-6:]==".qcow2":
628 elif image_dict
['location'][-4:]==".vhd":
630 elif image_dict
['location'][-5:]==".vmdk":
632 elif image_dict
['location'][-4:]==".vdi":
634 elif image_dict
['location'][-4:]==".iso":
636 elif image_dict
['location'][-4:]==".aki":
638 elif image_dict
['location'][-4:]==".ari":
640 elif image_dict
['location'][-4:]==".ami":
644 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
645 if image_dict
['location'][0:4]=="http":
646 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
647 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
649 with
open(image_dict
['location']) as fimage
:
650 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
651 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
652 #insert metadata. We cannot use 'new_image.properties.setdefault'
653 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
654 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
655 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
656 metadata_to_load
= image_dict
.get('metadata')
658 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
659 new_image_nova
.metadata
.setdefault(k
,v
)
661 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
662 self
._format
_exception
(e
)
663 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
664 if retry
==max_retries
:
666 self
._format
_exception
(e
)
667 except IOError as e
: #can not open the file
668 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
669 http_code
=vimconn
.HTTP_Bad_Request
)
671 def delete_image(self
, image_id
):
672 '''Deletes a tenant image from openstack VIM. Returns the old id
675 self
._reload
_connection
()
676 self
.nova
.images
.delete(image_id
)
678 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
679 self
._format
_exception
(e
)
681 def get_image_id_from_path(self
, path
):
682 '''Get the image id from image path in the VIM database. Returns the image_id'''
684 self
._reload
_connection
()
685 images
= self
.nova
.images
.list()
687 if image
.metadata
.get("location")==path
:
689 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
690 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
691 self
._format
_exception
(e
)
693 def get_image_list(self
, filter_dict
={}):
694 '''Obtain tenant images from VIM
698 checksum: image checksum
699 Returns the image list of dictionaries:
700 [{<the fields at Filter_dict plus some VIM specific>}, ...]
703 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
705 self
._reload
_connection
()
706 filter_dict_os
=filter_dict
.copy()
707 #First we filter by the available filter fields: name, id. The others are removed.
708 filter_dict_os
.pop('checksum',None)
709 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
710 if len(image_list
)==0:
712 #Then we filter by the rest of filter fields: checksum
714 for image
in image_list
:
715 image_class
=self
.glance
.images
.get(image
.id)
716 if 'checksum' not in filter_dict
or image_class
['checksum']==filter_dict
.get('checksum'):
717 filtered_list
.append(image_class
.copy())
719 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
720 self
._format
_exception
(e
)
722 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
723 '''Adds a VM instance to VIM
725 start: indicates if VM must start or boot in pause mode. Ignored
726 image_id,flavor_id: iamge and flavor uuid
727 net_list: list of interfaces, each one is a dictionary with:
729 net_id: network uuid to connect
730 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
731 model: interface model, ignored #TODO
732 mac_address: used for SR-IOV ifaces #TODO for other types
733 use: 'data', 'bridge', 'mgmt'
734 type: 'virtual', 'PF', 'VF', 'VFnotShared'
735 vim_id: filled/added by this function
736 floating_ip: True/False (or it can be None)
737 #TODO ip, security groups
738 Returns the instance identifier
740 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
744 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
745 self
._reload
_connection
()
746 metadata_vpci
={} #For a specific neutron plugin
748 if not net
.get("net_id"): #skip non connected iface
752 "network_id": net
["net_id"],
753 "name": net
.get("name"),
754 "admin_state_up": True
756 if net
["type"]=="virtual":
758 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
759 elif net
["type"]=="VF": # for VF
761 if "VF" not in metadata_vpci
:
762 metadata_vpci
["VF"]=[]
763 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
764 port_dict
["binding:vnic_type"]="direct"
767 if "PF" not in metadata_vpci
:
768 metadata_vpci
["PF"]=[]
769 metadata_vpci
["PF"].append([ net
["vpci"], "" ])
770 port_dict
["binding:vnic_type"]="direct-physical"
771 if not port_dict
["name"]:
772 port_dict
["name"]=name
773 if net
.get("mac_address"):
774 port_dict
["mac_address"]=net
["mac_address"]
775 if net
.get("port_security") == False:
776 port_dict
["port_security_enabled"]=net
["port_security"]
777 new_port
= self
.neutron
.create_port({"port": port_dict
})
778 net
["mac_adress"] = new_port
["port"]["mac_address"]
779 net
["vim_id"] = new_port
["port"]["id"]
780 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
781 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
783 if net
.get('floating_ip', False):
784 net
['exit_on_floating_ip_error'] = True
785 external_network
.append(net
)
786 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
787 net
['exit_on_floating_ip_error'] = False
788 external_network
.append(net
)
791 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
792 if len(metadata
["pci_assignement"]) >255:
793 #limit the metadata size
794 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
795 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
798 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
799 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
801 security_groups
= self
.config
.get('security_groups')
802 if type(security_groups
) is str:
803 security_groups
= ( security_groups
, )
807 if isinstance(cloud_config
, dict):
808 if cloud_config
.get("user-data"):
809 userdata
=cloud_config
["user-data"]
810 if cloud_config
.get("boot-data-drive") != None:
811 config_drive
= cloud_config
["boot-data-drive"]
812 if cloud_config
.get("config-files") or cloud_config
.get("users") or cloud_config
.get("key-pairs"):
814 raise vimconn
.vimconnConflictException("Cloud-config cannot contain both 'userdata' and 'config-files'/'users'/'key-pairs'")
817 if cloud_config
.get("key-pairs"):
818 userdata_dict
["ssh-authorized-keys"] = cloud_config
["key-pairs"]
819 userdata_dict
["users"] = [{"default": None, "ssh-authorized-keys": cloud_config
["key-pairs"] }]
820 if cloud_config
.get("users"):
821 if "users" not in userdata_dict
:
822 userdata_dict
["users"] = [ "default" ]
823 for user
in cloud_config
["users"]:
825 "name" : user
["name"],
826 "sudo": "ALL = (ALL)NOPASSWD:ALL"
828 if "user-info" in user
:
829 user_info
["gecos"] = user
["user-info"]
830 if user
.get("key-pairs"):
831 user_info
["ssh-authorized-keys"] = user
["key-pairs"]
832 userdata_dict
["users"].append(user_info
)
834 if cloud_config
.get("config-files"):
835 userdata_dict
["write_files"] = []
836 for file in cloud_config
["config-files"]:
838 "path" : file["dest"],
839 "content": file["content"]
841 if file.get("encoding"):
842 file_info
["encoding"] = file["encoding"]
843 if file.get("permissions"):
844 file_info
["permissions"] = file["permissions"]
845 if file.get("owner"):
846 file_info
["owner"] = file["owner"]
847 userdata_dict
["write_files"].append(file_info
)
848 userdata
= "#cloud-config\n"
849 userdata
+= yaml
.safe_dump(userdata_dict
, indent
=4, default_flow_style
=False)
850 self
.logger
.debug("userdata: %s", userdata
)
851 elif isinstance(cloud_config
, str):
852 userdata
= cloud_config
854 #Create additional volumes in case these are present in disk_list
855 block_device_mapping
= None
856 base_disk_index
= ord('b')
857 if disk_list
!= None:
858 block_device_mapping
= dict()
859 for disk
in disk_list
:
860 if 'image_id' in disk
:
861 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
862 chr(base_disk_index
), imageRef
= disk
['image_id'])
864 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
865 chr(base_disk_index
))
866 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
869 #wait until volumes are with status available
872 while keep_waiting
and elapsed_time
< volume_timeout
:
874 for volume_id
in block_device_mapping
.itervalues():
875 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
881 #if we exceeded the timeout rollback
882 if elapsed_time
>= volume_timeout
:
883 #delete the volumes we just created
884 for volume_id
in block_device_mapping
.itervalues():
885 self
.cinder
.volumes
.delete(volume_id
)
887 #delete ports we just created
888 for net_item
in net_list_vim
:
889 if 'port-id' in net_item
:
890 self
.neutron
.delete_port(net_item
['port-id'])
892 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
893 http_code
=vimconn
.HTTP_Request_Timeout
)
895 self
.logger
.debug("nova.servers.create({}, {}, {}, nics={}, meta={}, security_groups={}," \
896 "availability_zone={}, key_name={}, userdata={}, config_drive={}, " \
897 "block_device_mapping={})".format(name
, image_id
, flavor_id
, net_list_vim
,
898 metadata
, security_groups
, self
.config
.get('availability_zone'),
899 self
.config
.get('keypair'), userdata
, config_drive
, block_device_mapping
))
900 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
901 security_groups
=security_groups
,
902 availability_zone
=self
.config
.get('availability_zone'),
903 key_name
=self
.config
.get('keypair'),
905 config_drive
= config_drive
,
906 block_device_mapping
= block_device_mapping
907 ) # , description=description)
908 #print "DONE :-)", server
910 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
911 for floating_network
in external_network
:
913 # wait until vm is active
915 while elapsed_time
< server_timeout
:
916 status
= self
.nova
.servers
.get(server
.id).status
917 if status
== 'ACTIVE':
922 #if we exceeded the timeout rollback
923 if elapsed_time
>= server_timeout
:
924 raise vimconn
.vimconnException('Timeout creating instance ' + name
,
925 http_code
=vimconn
.HTTP_Request_Timeout
)
928 while(assigned
== False):
930 ip
= floating_ips
.pop(0)
931 if not ip
.get("port_id", False) and ip
.get('tenant_id') == server
.tenant_id
:
932 free_floating_ip
= ip
.get("floating_ip_address")
934 fix_ip
= floating_network
.get('ip')
935 server
.add_floating_ip(free_floating_ip
, fix_ip
)
937 except Exception as e
:
938 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
940 #Find the external network
941 external_nets
= list()
942 for net
in self
.neutron
.list_networks()['networks']:
943 if net
['router:external']:
944 external_nets
.append(net
)
946 if len(external_nets
) == 0:
947 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
948 "network is present",
949 http_code
=vimconn
.HTTP_Conflict
)
950 if len(external_nets
) > 1:
951 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
952 "external networks are present",
953 http_code
=vimconn
.HTTP_Conflict
)
955 pool_id
= external_nets
[0].get('id')
956 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
958 #self.logger.debug("Creating floating IP")
959 new_floating_ip
= self
.neutron
.create_floatingip(param
)
960 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
961 fix_ip
= floating_network
.get('ip')
962 server
.add_floating_ip(free_floating_ip
, fix_ip
)
964 except Exception as e
:
965 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot assign floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
966 except Exception as e
:
967 if not floating_network
['exit_on_floating_ip_error']:
968 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
970 self
.delete_vminstance(server
.id)
974 # except nvExceptions.NotFound as e:
975 # error_value=-vimconn.HTTP_Not_Found
976 # error_text= "vm instance %s not found" % vm_id
977 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
978 # delete the volumes we just created
979 if block_device_mapping
!= None:
980 for volume_id
in block_device_mapping
.itervalues():
981 self
.cinder
.volumes
.delete(volume_id
)
983 # delete ports we just created
984 for net_item
in net_list_vim
:
985 if 'port-id' in net_item
:
986 self
.neutron
.delete_port(net_item
['port-id'])
987 self
._format
_exception
(e
)
988 except TypeError as e
:
989 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
991 def get_vminstance(self
,vm_id
):
992 '''Returns the VM instance information from VIM'''
993 #self.logger.debug("Getting VM from VIM")
995 self
._reload
_connection
()
996 server
= self
.nova
.servers
.find(id=vm_id
)
997 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
998 return server
.to_dict()
999 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1000 self
._format
_exception
(e
)
1002 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
1004 Get a console for the virtual machine
1006 vm_id: uuid of the VM
1007 console_type, can be:
1008 "novnc" (by default), "xvpvnc" for VNC types,
1009 "rdp-html5" for RDP types, "spice-html5" for SPICE types
1010 Returns dict with the console parameters:
1011 protocol: ssh, ftp, http, https, ...
1012 server: usually ip address
1013 port: the http, ssh, ... port
1014 suffix: extra text, e.g. the http path and query string
1016 self
.logger
.debug("Getting VM CONSOLE from VIM")
1018 self
._reload
_connection
()
1019 server
= self
.nova
.servers
.find(id=vm_id
)
1020 if console_type
== None or console_type
== "novnc":
1021 console_dict
= server
.get_vnc_console("novnc")
1022 elif console_type
== "xvpvnc":
1023 console_dict
= server
.get_vnc_console(console_type
)
1024 elif console_type
== "rdp-html5":
1025 console_dict
= server
.get_rdp_console(console_type
)
1026 elif console_type
== "spice-html5":
1027 console_dict
= server
.get_spice_console(console_type
)
1029 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1031 console_dict1
= console_dict
.get("console")
1033 console_url
= console_dict1
.get("url")
1036 protocol_index
= console_url
.find("//")
1037 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1038 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1039 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1040 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1041 console_dict
={"protocol": console_url
[0:protocol_index
],
1042 "server": console_url
[protocol_index
+2:port_index
],
1043 "port": console_url
[port_index
:suffix_index
],
1044 "suffix": console_url
[suffix_index
+1:]
1048 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1050 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1051 self
._format
_exception
(e
)
1053 def delete_vminstance(self
, vm_id
):
1054 '''Removes a VM instance from VIM. Returns the old identifier
1056 #print "osconnector: Getting VM from VIM"
1058 self
._reload
_connection
()
1059 #delete VM ports attached to this networks before the virtual machine
1060 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
1061 for p
in ports
['ports']:
1063 self
.neutron
.delete_port(p
["id"])
1064 except Exception as e
:
1065 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
1067 #commented because detaching the volumes makes the servers.delete not work properly ?!?
1068 #dettach volumes attached
1069 server
= self
.nova
.servers
.get(vm_id
)
1070 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
1071 #for volume in volumes_attached_dict:
1072 # self.cinder.volumes.detach(volume['id'])
1074 self
.nova
.servers
.delete(vm_id
)
1077 #Although having detached them should have them in active status
1078 #we ensure in this loop
1081 while keep_waiting
and elapsed_time
< volume_timeout
:
1082 keep_waiting
= False
1083 for volume
in volumes_attached_dict
:
1084 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
1087 self
.cinder
.volumes
.delete(volume
['id'])
1093 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1094 self
._format
_exception
(e
)
1095 #TODO insert exception vimconn.HTTP_Unauthorized
1096 #if reaching here is because an exception
1098 def refresh_vms_status(self
, vm_list
):
1099 '''Get the status of the virtual machines and their interfaces/ports
1100 Params: the list of VM identifiers
1101 Returns a dictionary with:
1102 vm_id: #VIM id of this Virtual Machine
1103 status: #Mandatory. Text with one of:
1104 # DELETED (not found at vim)
1105 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1106 # OTHER (Vim reported other status not understood)
1107 # ERROR (VIM indicates an ERROR status)
1108 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1109 # CREATING (on building process), ERROR
1110 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1112 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1113 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1115 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1116 mac_address: #Text format XX:XX:XX:XX:XX:XX
1117 vim_net_id: #network id where this interface is connected
1118 vim_interface_id: #interface/port VIM id
1119 ip_address: #null, or text with IPv4, IPv6 address
1120 compute_node: #identification of compute node where PF,VF interface is allocated
1121 pci: #PCI address of the NIC that hosts the PF,VF
1122 vlan: #physical VLAN used for VF
1125 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1126 for vm_id
in vm_list
:
1129 vm_vim
= self
.get_vminstance(vm_id
)
1130 if vm_vim
['status'] in vmStatus2manoFormat
:
1131 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1133 vm
['status'] = "OTHER"
1134 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1136 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1137 except yaml
.representer
.RepresenterError
:
1138 vm
['vim_info'] = str(vm_vim
)
1139 vm
["interfaces"] = []
1140 if vm_vim
.get('fault'):
1141 vm
['error_msg'] = str(vm_vim
['fault'])
1144 self
._reload
_connection
()
1145 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1146 for port
in port_dict
["ports"]:
1149 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1150 except yaml
.representer
.RepresenterError
:
1151 interface
['vim_info'] = str(port
)
1152 interface
["mac_address"] = port
.get("mac_address")
1153 interface
["vim_net_id"] = port
["network_id"]
1154 interface
["vim_interface_id"] = port
["id"]
1155 # check if OS-EXT-SRV-ATTR:host is there,
1156 # in case of non-admin credentials, it will be missing
1157 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1158 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1159 interface
["pci"] = None
1161 # check if binding:profile is there,
1162 # in case of non-admin credentials, it will be missing
1163 if port
.get('binding:profile'):
1164 if port
['binding:profile'].get('pci_slot'):
1165 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1166 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1167 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1168 pci
= port
['binding:profile']['pci_slot']
1169 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1170 interface
["pci"] = pci
1171 interface
["vlan"] = None
1172 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1173 network
= self
.neutron
.show_network(port
["network_id"])
1174 if network
['network'].get('provider:network_type') == 'vlan' and \
1175 port
.get("binding:vnic_type") == "direct":
1176 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1178 #look for floating ip address
1179 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1180 if floating_ip_dict
.get("floatingips"):
1181 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1183 for subnet
in port
["fixed_ips"]:
1184 ips
.append(subnet
["ip_address"])
1185 interface
["ip_address"] = ";".join(ips
)
1186 vm
["interfaces"].append(interface
)
1187 except Exception as e
:
1188 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1189 except vimconn
.vimconnNotFoundException
as e
:
1190 self
.logger
.error("Exception getting vm status: %s", str(e
))
1191 vm
['status'] = "DELETED"
1192 vm
['error_msg'] = str(e
)
1193 except vimconn
.vimconnException
as e
:
1194 self
.logger
.error("Exception getting vm status: %s", str(e
))
1195 vm
['status'] = "VIM_ERROR"
1196 vm
['error_msg'] = str(e
)
1200 def action_vminstance(self
, vm_id
, action_dict
):
1201 '''Send and action over a VM instance from VIM
1202 Returns the vm_id if the action was successfully sent to the VIM'''
1203 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1205 self
._reload
_connection
()
1206 server
= self
.nova
.servers
.find(id=vm_id
)
1207 if "start" in action_dict
:
1208 if action_dict
["start"]=="rebuild":
1211 if server
.status
=="PAUSED":
1213 elif server
.status
=="SUSPENDED":
1215 elif server
.status
=="SHUTOFF":
1217 elif "pause" in action_dict
:
1219 elif "resume" in action_dict
:
1221 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1223 elif "forceOff" in action_dict
:
1225 elif "terminate" in action_dict
:
1227 elif "createImage" in action_dict
:
1228 server
.create_image()
1229 #"path":path_schema,
1230 #"description":description_schema,
1231 #"name":name_schema,
1232 #"metadata":metadata_schema,
1233 #"imageRef": id_schema,
1234 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1235 elif "rebuild" in action_dict
:
1236 server
.rebuild(server
.image
['id'])
1237 elif "reboot" in action_dict
:
1238 server
.reboot() #reboot_type='SOFT'
1239 elif "console" in action_dict
:
1240 console_type
= action_dict
["console"]
1241 if console_type
== None or console_type
== "novnc":
1242 console_dict
= server
.get_vnc_console("novnc")
1243 elif console_type
== "xvpvnc":
1244 console_dict
= server
.get_vnc_console(console_type
)
1245 elif console_type
== "rdp-html5":
1246 console_dict
= server
.get_rdp_console(console_type
)
1247 elif console_type
== "spice-html5":
1248 console_dict
= server
.get_spice_console(console_type
)
1250 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1251 http_code
=vimconn
.HTTP_Bad_Request
)
1253 console_url
= console_dict
["console"]["url"]
1255 protocol_index
= console_url
.find("//")
1256 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1257 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1258 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1259 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1260 console_dict2
={"protocol": console_url
[0:protocol_index
],
1261 "server": console_url
[protocol_index
+2 : port_index
],
1262 "port": int(console_url
[port_index
+1 : suffix_index
]),
1263 "suffix": console_url
[suffix_index
+1:]
1265 return console_dict2
1266 except Exception as e
:
1267 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1270 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1271 self
._format
_exception
(e
)
1272 #TODO insert exception vimconn.HTTP_Unauthorized
1276 def new_external_port(self
, port_data
):
1277 #TODO openstack if needed
1278 '''Adds a external port to VIM'''
1279 '''Returns the port identifier'''
1280 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1282 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1283 #TODO openstack if needed
1284 '''Connects a external port to a network'''
1285 '''Returns status code of the VIM response'''
1286 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1288 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1289 '''Adds a new user to openstack VIM'''
1290 '''Returns the user identifier'''
1291 self
.logger
.debug("osconnector: Adding a new user to VIM")
1293 self
._reload
_connection
()
1294 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1295 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1297 except ksExceptions
.ConnectionError
as e
:
1298 error_value
=-vimconn
.HTTP_Bad_Request
1299 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1300 except ksExceptions
.ClientException
as e
: #TODO remove
1301 error_value
=-vimconn
.HTTP_Bad_Request
1302 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1303 #TODO insert exception vimconn.HTTP_Unauthorized
1304 #if reaching here is because an exception
1306 self
.logger
.debug("new_user " + error_text
)
1307 return error_value
, error_text
1309 def delete_user(self
, user_id
):
1310 '''Delete a user from openstack VIM'''
1311 '''Returns the user identifier'''
1313 print "osconnector: Deleting a user from VIM"
1315 self
._reload
_connection
()
1316 self
.keystone
.users
.delete(user_id
)
1318 except ksExceptions
.ConnectionError
as e
:
1319 error_value
=-vimconn
.HTTP_Bad_Request
1320 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1321 except ksExceptions
.NotFound
as e
:
1322 error_value
=-vimconn
.HTTP_Not_Found
1323 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1324 except ksExceptions
.ClientException
as e
: #TODO remove
1325 error_value
=-vimconn
.HTTP_Bad_Request
1326 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1327 #TODO insert exception vimconn.HTTP_Unauthorized
1328 #if reaching here is because an exception
1330 print "delete_tenant " + error_text
1331 return error_value
, error_text
1333 def get_hosts_info(self
):
1334 '''Get the information of deployed hosts
1335 Returns the hosts content'''
1337 print "osconnector: Getting Host info from VIM"
1340 self
._reload
_connection
()
1341 hypervisors
= self
.nova
.hypervisors
.list()
1342 for hype
in hypervisors
:
1343 h_list
.append( hype
.to_dict() )
1344 return 1, {"hosts":h_list
}
1345 except nvExceptions
.NotFound
as e
:
1346 error_value
=-vimconn
.HTTP_Not_Found
1347 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1348 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1349 error_value
=-vimconn
.HTTP_Bad_Request
1350 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1351 #TODO insert exception vimconn.HTTP_Unauthorized
1352 #if reaching here is because an exception
1354 print "get_hosts_info " + error_text
1355 return error_value
, error_text
1357 def get_hosts(self
, vim_tenant
):
1358 '''Get the hosts and deployed instances
1359 Returns the hosts content'''
1360 r
, hype_dict
= self
.get_hosts_info()
1363 hypervisors
= hype_dict
["hosts"]
1365 servers
= self
.nova
.servers
.list()
1366 for hype
in hypervisors
:
1367 for server
in servers
:
1368 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1370 hype
['vm'].append(server
.id)
1372 hype
['vm'] = [server
.id]
1374 except nvExceptions
.NotFound
as e
:
1375 error_value
=-vimconn
.HTTP_Not_Found
1376 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1377 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1378 error_value
=-vimconn
.HTTP_Bad_Request
1379 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1380 #TODO insert exception vimconn.HTTP_Unauthorized
1381 #if reaching here is because an exception
1383 print "get_hosts " + error_text
1384 return error_value
, error_text