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
475 self
._reload
_connection
()
477 numas
= flavor_dict
.get("extended",{}).get("numas")
480 raise vimconn
.vimconnNotFoundException("Flavor with EPA still not implemted")
482 # raise vimconn.vimconnNotFoundException("Cannot find any flavor with more than one numa")
484 # numas = extended.get("numas")
485 for flavor
in self
.nova
.flavors
.list():
486 epa
= flavor
.get_keys()
490 if flavor
.ram
!= flavor_dict
["ram"]:
492 if flavor
.vcpus
!= flavor_dict
["vcpus"]:
494 if flavor
.disk
!= flavor_dict
["disk"]:
497 raise vimconn
.vimconnNotFoundException("Cannot find any flavor matching '{}'".format(str(flavor_dict
)))
498 except (nvExceptions
.NotFound
, nvExceptions
.ClientException
, ksExceptions
.ClientException
, ConnectionError
) as e
:
499 self
._format
_exception
(e
)
502 def new_flavor(self
, flavor_data
, change_name_if_used
=True):
503 '''Adds a tenant flavor to openstack VIM
504 if change_name_if_used is True, it will change name in case of conflict, because it is not supported name repetition
505 Returns the flavor identifier
507 self
.logger
.debug("Adding flavor '%s'", str(flavor_data
))
511 name
=flavor_data
['name']
512 while retry
<max_retries
:
515 self
._reload
_connection
()
516 if change_name_if_used
:
519 fl
=self
.nova
.flavors
.list()
521 fl_names
.append(f
.name
)
522 while name
in fl_names
:
524 name
= flavor_data
['name']+"-" + str(name_suffix
)
526 ram
= flavor_data
.get('ram',64)
527 vcpus
= flavor_data
.get('vcpus',1)
530 extended
= flavor_data
.get("extended")
532 numas
=extended
.get("numas")
534 numa_nodes
= len(numas
)
536 return -1, "Can not add flavor with more than one numa"
537 numa_properties
= {"hw:numa_nodes":str(numa_nodes
)}
538 numa_properties
["hw:mem_page_size"] = "large"
539 numa_properties
["hw:cpu_policy"] = "dedicated"
540 numa_properties
["hw:numa_mempolicy"] = "strict"
542 #overwrite ram and vcpus
543 ram
= numa
['memory']*1024
544 #See for reference: https://specs.openstack.org/openstack/nova-specs/specs/mitaka/implemented/virt-driver-cpu-thread-pinning.html
545 if 'paired-threads' in numa
:
546 vcpus
= numa
['paired-threads']*2
547 #cpu_thread_policy "require" implies that the compute node must have an STM architecture
548 numa_properties
["hw:cpu_thread_policy"] = "require"
549 numa_properties
["hw:cpu_policy"] = "dedicated"
550 elif 'cores' in numa
:
551 vcpus
= numa
['cores']
552 # cpu_thread_policy "prefer" implies that the host must not have an SMT architecture, or a non-SMT architecture will be emulated
553 numa_properties
["hw:cpu_thread_policy"] = "isolate"
554 numa_properties
["hw:cpu_policy"] = "dedicated"
555 elif 'threads' in numa
:
556 vcpus
= numa
['threads']
557 # cpu_thread_policy "prefer" implies that the host may or may not have an SMT architecture
558 numa_properties
["hw:cpu_thread_policy"] = "prefer"
559 numa_properties
["hw:cpu_policy"] = "dedicated"
560 # for interface in numa.get("interfaces",() ):
561 # if interface["dedicated"]=="yes":
562 # raise vimconn.vimconnException("Passthrough interfaces are not supported for the openstack connector", http_code=vimconn.HTTP_Service_Unavailable)
563 # #TODO, add the key 'pci_passthrough:alias"="<label at config>:<number ifaces>"' when a way to connect it is available
566 new_flavor
=self
.nova
.flavors
.create(name
,
569 flavor_data
.get('disk',1),
570 is_public
=flavor_data
.get('is_public', True)
574 new_flavor
.set_keys(numa_properties
)
576 except nvExceptions
.Conflict
as e
:
577 if change_name_if_used
and retry
< max_retries
:
579 self
._format
_exception
(e
)
580 #except nvExceptions.BadRequest as e:
581 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
582 self
._format
_exception
(e
)
584 def delete_flavor(self
,flavor_id
):
585 '''Deletes a tenant flavor from openstack VIM. Returns the old flavor_id
588 self
._reload
_connection
()
589 self
.nova
.flavors
.delete(flavor_id
)
591 #except nvExceptions.BadRequest as e:
592 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
593 self
._format
_exception
(e
)
595 def new_image(self
,image_dict
):
597 Adds a tenant image to VIM. imge_dict is a dictionary with:
599 disk_format: qcow2, vhd, vmdk, raw (by default), ...
600 location: path or URI
601 public: "yes" or "no"
602 metadata: metadata of the image
605 #using version 1 of glance client
606 glancev1
= gl1Client
.Client('1',self
.glance_endpoint
, token
=self
.keystone
.auth_token
, **self
.k_creds
) #TODO check k_creds vs n_creds
609 while retry
<max_retries
:
612 self
._reload
_connection
()
613 #determine format http://docs.openstack.org/developer/glance/formats.html
614 if "disk_format" in image_dict
:
615 disk_format
=image_dict
["disk_format"]
616 else: #autodiscover based on extension
617 if image_dict
['location'][-6:]==".qcow2":
619 elif image_dict
['location'][-4:]==".vhd":
621 elif image_dict
['location'][-5:]==".vmdk":
623 elif image_dict
['location'][-4:]==".vdi":
625 elif image_dict
['location'][-4:]==".iso":
627 elif image_dict
['location'][-4:]==".aki":
629 elif image_dict
['location'][-4:]==".ari":
631 elif image_dict
['location'][-4:]==".ami":
635 self
.logger
.debug("new_image: '%s' loading from '%s'", image_dict
['name'], image_dict
['location'])
636 if image_dict
['location'][0:4]=="http":
637 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
638 container_format
="bare", location
=image_dict
['location'], disk_format
=disk_format
)
640 with
open(image_dict
['location']) as fimage
:
641 new_image
= glancev1
.images
.create(name
=image_dict
['name'], is_public
=image_dict
.get('public',"yes")=="yes",
642 container_format
="bare", data
=fimage
, disk_format
=disk_format
)
643 #insert metadata. We cannot use 'new_image.properties.setdefault'
644 #because nova and glance are "INDEPENDENT" and we are using nova for reading metadata
645 new_image_nova
=self
.nova
.images
.find(id=new_image
.id)
646 new_image_nova
.metadata
.setdefault('location',image_dict
['location'])
647 metadata_to_load
= image_dict
.get('metadata')
649 for k
,v
in yaml
.load(metadata_to_load
).iteritems():
650 new_image_nova
.metadata
.setdefault(k
,v
)
652 except (nvExceptions
.Conflict
, ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
653 self
._format
_exception
(e
)
654 except (HTTPException
, gl1Exceptions
.HTTPException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
655 if retry
==max_retries
:
657 self
._format
_exception
(e
)
658 except IOError as e
: #can not open the file
659 raise vimconn
.vimconnConnectionException(type(e
).__name
__ + ": " + str(e
)+ " for " + image_dict
['location'],
660 http_code
=vimconn
.HTTP_Bad_Request
)
662 def delete_image(self
, image_id
):
663 '''Deletes a tenant image from openstack VIM. Returns the old id
666 self
._reload
_connection
()
667 self
.nova
.images
.delete(image_id
)
669 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
: #TODO remove
670 self
._format
_exception
(e
)
672 def get_image_id_from_path(self
, path
):
673 '''Get the image id from image path in the VIM database. Returns the image_id'''
675 self
._reload
_connection
()
676 images
= self
.nova
.images
.list()
678 if image
.metadata
.get("location")==path
:
680 raise vimconn
.vimconnNotFoundException("image with location '{}' not found".format( path
))
681 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
682 self
._format
_exception
(e
)
684 def get_image_list(self
, filter_dict
={}):
685 '''Obtain tenant images from VIM
689 checksum: image checksum
690 Returns the image list of dictionaries:
691 [{<the fields at Filter_dict plus some VIM specific>}, ...]
694 self
.logger
.debug("Getting image list from VIM filter: '%s'", str(filter_dict
))
696 self
._reload
_connection
()
697 filter_dict_os
=filter_dict
.copy()
698 #First we filter by the available filter fields: name, id. The others are removed.
699 filter_dict_os
.pop('checksum',None)
700 image_list
=self
.nova
.images
.findall(**filter_dict_os
)
701 if len(image_list
)==0:
703 #Then we filter by the rest of filter fields: checksum
705 for image
in image_list
:
706 image_class
=self
.glance
.images
.get(image
.id)
707 if 'checksum' not in filter_dict
or image_class
['checksum']==filter_dict
.get('checksum'):
708 filtered_list
.append(image_class
.copy())
710 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, gl1Exceptions
.CommunicationError
, ConnectionError
) as e
:
711 self
._format
_exception
(e
)
713 def new_vminstance(self
,name
,description
,start
,image_id
,flavor_id
,net_list
,cloud_config
=None,disk_list
=None):
714 '''Adds a VM instance to VIM
716 start: indicates if VM must start or boot in pause mode. Ignored
717 image_id,flavor_id: iamge and flavor uuid
718 net_list: list of interfaces, each one is a dictionary with:
720 net_id: network uuid to connect
721 vpci: virtual vcpi to assign, ignored because openstack lack #TODO
722 model: interface model, ignored #TODO
723 mac_address: used for SR-IOV ifaces #TODO for other types
724 use: 'data', 'bridge', 'mgmt'
725 type: 'virtual', 'PF', 'VF', 'VFnotShared'
726 vim_id: filled/added by this function
727 floating_ip: True/False (or it can be None)
728 #TODO ip, security groups
729 Returns the instance identifier
731 self
.logger
.debug("new_vminstance input: image='%s' flavor='%s' nics='%s'",image_id
, flavor_id
,str(net_list
))
735 external_network
=[] #list of external networks to be connected to instance, later on used to create floating_ip
736 self
._reload
_connection
()
737 metadata_vpci
={} #For a specific neutron plugin
739 if not net
.get("net_id"): #skip non connected iface
743 "network_id": net
["net_id"],
744 "name": net
.get("name"),
745 "admin_state_up": True
747 if net
["type"]=="virtual":
749 metadata_vpci
[ net
["net_id"] ] = [[ net
["vpci"], "" ]]
750 elif net
["type"]=="VF": # for VF
752 if "VF" not in metadata_vpci
:
753 metadata_vpci
["VF"]=[]
754 metadata_vpci
["VF"].append([ net
["vpci"], "" ])
755 port_dict
["binding:vnic_type"]="direct"
758 if "PF" not in metadata_vpci
:
759 metadata_vpci
["PF"]=[]
760 metadata_vpci
["PF"].append([ net
["vpci"], "" ])
761 port_dict
["binding:vnic_type"]="direct-physical"
762 if not port_dict
["name"]:
763 port_dict
["name"]=name
764 if net
.get("mac_address"):
765 port_dict
["mac_address"]=net
["mac_address"]
766 if net
.get("port_security") == False:
767 port_dict
["port_security_enabled"]=net
["port_security"]
768 new_port
= self
.neutron
.create_port({"port": port_dict
})
769 net
["mac_adress"] = new_port
["port"]["mac_address"]
770 net
["vim_id"] = new_port
["port"]["id"]
771 net
["ip"] = new_port
["port"].get("fixed_ips", [{}])[0].get("ip_address")
772 net_list_vim
.append({"port-id": new_port
["port"]["id"]})
774 if net
.get('floating_ip', False):
775 net
['exit_on_floating_ip_error'] = True
776 external_network
.append(net
)
777 elif net
['use'] == 'mgmt' and self
.config
.get('use_floating_ip'):
778 net
['exit_on_floating_ip_error'] = False
779 external_network
.append(net
)
782 metadata
= {"pci_assignement": json
.dumps(metadata_vpci
)}
783 if len(metadata
["pci_assignement"]) >255:
784 #limit the metadata size
785 #metadata["pci_assignement"] = metadata["pci_assignement"][0:255]
786 self
.logger
.warn("Metadata deleted since it exceeds the expected length (255) ")
789 self
.logger
.debug("name '%s' image_id '%s'flavor_id '%s' net_list_vim '%s' description '%s' metadata %s",
790 name
, image_id
, flavor_id
, str(net_list_vim
), description
, str(metadata
))
792 security_groups
= self
.config
.get('security_groups')
793 if type(security_groups
) is str:
794 security_groups
= ( security_groups
, )
798 if isinstance(cloud_config
, dict):
799 if cloud_config
.get("user-data"):
800 userdata
=cloud_config
["user-data"]
801 if cloud_config
.get("boot-data-drive") != None:
802 config_drive
= cloud_config
["boot-data-drive"]
803 if cloud_config
.get("config-files") or cloud_config
.get("users") or cloud_config
.get("key-pairs"):
805 raise vimconn
.vimconnConflictException("Cloud-config cannot contain both 'userdata' and 'config-files'/'users'/'key-pairs'")
808 if cloud_config
.get("key-pairs"):
809 userdata_dict
["ssh-authorized-keys"] = cloud_config
["key-pairs"]
810 userdata_dict
["users"] = [{"default": None, "ssh-authorized-keys": cloud_config
["key-pairs"] }]
811 if cloud_config
.get("users"):
812 if "users" not in userdata_dict
:
813 userdata_dict
["users"] = [ "default" ]
814 for user
in cloud_config
["users"]:
816 "name" : user
["name"],
817 "sudo": "ALL = (ALL)NOPASSWD:ALL"
819 if "user-info" in user
:
820 user_info
["gecos"] = user
["user-info"]
821 if user
.get("key-pairs"):
822 user_info
["ssh-authorized-keys"] = user
["key-pairs"]
823 userdata_dict
["users"].append(user_info
)
825 if cloud_config
.get("config-files"):
826 userdata_dict
["write_files"] = []
827 for file in cloud_config
["config-files"]:
829 "path" : file["dest"],
830 "content": file["content"]
832 if file.get("encoding"):
833 file_info
["encoding"] = file["encoding"]
834 if file.get("permissions"):
835 file_info
["permissions"] = file["permissions"]
836 if file.get("owner"):
837 file_info
["owner"] = file["owner"]
838 userdata_dict
["write_files"].append(file_info
)
839 userdata
= "#cloud-config\n"
840 userdata
+= yaml
.safe_dump(userdata_dict
, indent
=4, default_flow_style
=False)
841 self
.logger
.debug("userdata: %s", userdata
)
842 elif isinstance(cloud_config
, str):
843 userdata
= cloud_config
845 #Create additional volumes in case these are present in disk_list
846 block_device_mapping
= None
847 base_disk_index
= ord('b')
848 if disk_list
!= None:
849 block_device_mapping
= dict()
850 for disk
in disk_list
:
851 if 'image_id' in disk
:
852 volume
= self
.cinder
.volumes
.create(size
= disk
['size'],name
= name
+ '_vd' +
853 chr(base_disk_index
), imageRef
= disk
['image_id'])
855 volume
= self
.cinder
.volumes
.create(size
=disk
['size'], name
=name
+ '_vd' +
856 chr(base_disk_index
))
857 block_device_mapping
['_vd' + chr(base_disk_index
)] = volume
.id
860 #wait until volumes are with status available
863 while keep_waiting
and elapsed_time
< volume_timeout
:
865 for volume_id
in block_device_mapping
.itervalues():
866 if self
.cinder
.volumes
.get(volume_id
).status
!= 'available':
872 #if we exceeded the timeout rollback
873 if elapsed_time
>= volume_timeout
:
874 #delete the volumes we just created
875 for volume_id
in block_device_mapping
.itervalues():
876 self
.cinder
.volumes
.delete(volume_id
)
878 #delete ports we just created
879 for net_item
in net_list_vim
:
880 if 'port-id' in net_item
:
881 self
.neutron
.delete_port(net_item
['port-id'])
883 raise vimconn
.vimconnException('Timeout creating volumes for instance ' + name
,
884 http_code
=vimconn
.HTTP_Request_Timeout
)
886 server
= self
.nova
.servers
.create(name
, image_id
, flavor_id
, nics
=net_list_vim
, meta
=metadata
,
887 security_groups
=security_groups
,
888 availability_zone
=self
.config
.get('availability_zone'),
889 key_name
=self
.config
.get('keypair'),
891 config_drive
= config_drive
,
892 block_device_mapping
= block_device_mapping
893 ) # , description=description)
894 #print "DONE :-)", server
896 floating_ips
= self
.neutron
.list_floatingips().get("floatingips", ())
897 for floating_network
in external_network
:
899 # wait until vm is active
901 while elapsed_time
< server_timeout
:
902 status
= self
.nova
.servers
.get(server
.id).status
903 if status
== 'ACTIVE':
908 #if we exceeded the timeout rollback
909 if elapsed_time
>= server_timeout
:
910 raise vimconn
.vimconnException('Timeout creating instance ' + name
,
911 http_code
=vimconn
.HTTP_Request_Timeout
)
914 while(assigned
== False):
916 ip
= floating_ips
.pop(0)
917 if not ip
.get("port_id", False) and ip
.get('tenant_id') == server
.tenant_id
:
918 free_floating_ip
= ip
.get("floating_ip_address")
920 fix_ip
= floating_network
.get('ip')
921 server
.add_floating_ip(free_floating_ip
, fix_ip
)
923 except Exception as e
:
924 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot create floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
926 #Find the external network
927 external_nets
= list()
928 for net
in self
.neutron
.list_networks()['networks']:
929 if net
['router:external']:
930 external_nets
.append(net
)
932 if len(external_nets
) == 0:
933 raise vimconn
.vimconnException("Cannot create floating_ip automatically since no external "
934 "network is present",
935 http_code
=vimconn
.HTTP_Conflict
)
936 if len(external_nets
) > 1:
937 raise vimconn
.vimconnException("Cannot create floating_ip automatically since multiple "
938 "external networks are present",
939 http_code
=vimconn
.HTTP_Conflict
)
941 pool_id
= external_nets
[0].get('id')
942 param
= {'floatingip': {'floating_network_id': pool_id
, 'tenant_id': server
.tenant_id
}}
944 #self.logger.debug("Creating floating IP")
945 new_floating_ip
= self
.neutron
.create_floatingip(param
)
946 free_floating_ip
= new_floating_ip
['floatingip']['floating_ip_address']
947 fix_ip
= floating_network
.get('ip')
948 server
.add_floating_ip(free_floating_ip
, fix_ip
)
950 except Exception as e
:
951 raise vimconn
.vimconnException(type(e
).__name
__ + ": Cannot assign floating_ip "+ str(e
), http_code
=vimconn
.HTTP_Conflict
)
952 except Exception as e
:
953 if not floating_network
['exit_on_floating_ip_error']:
954 self
.logger
.warn("Cannot create floating_ip. %s", str(e
))
956 self
.delete_vminstance(server
.id)
960 # except nvExceptions.NotFound as e:
961 # error_value=-vimconn.HTTP_Not_Found
962 # error_text= "vm instance %s not found" % vm_id
963 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
964 # delete the volumes we just created
965 if block_device_mapping
!= None:
966 for volume_id
in block_device_mapping
.itervalues():
967 self
.cinder
.volumes
.delete(volume_id
)
969 # delete ports we just created
970 for net_item
in net_list_vim
:
971 if 'port-id' in net_item
:
972 self
.neutron
.delete_port(net_item
['port-id'])
973 self
._format
_exception
(e
)
974 except TypeError as e
:
975 raise vimconn
.vimconnException(type(e
).__name
__ + ": "+ str(e
), http_code
=vimconn
.HTTP_Bad_Request
)
977 def get_vminstance(self
,vm_id
):
978 '''Returns the VM instance information from VIM'''
979 #self.logger.debug("Getting VM from VIM")
981 self
._reload
_connection
()
982 server
= self
.nova
.servers
.find(id=vm_id
)
983 #TODO parse input and translate to VIM format (openmano_schemas.new_vminstance_response_schema)
984 return server
.to_dict()
985 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
986 self
._format
_exception
(e
)
988 def get_vminstance_console(self
,vm_id
, console_type
="vnc"):
990 Get a console for the virtual machine
992 vm_id: uuid of the VM
993 console_type, can be:
994 "novnc" (by default), "xvpvnc" for VNC types,
995 "rdp-html5" for RDP types, "spice-html5" for SPICE types
996 Returns dict with the console parameters:
997 protocol: ssh, ftp, http, https, ...
998 server: usually ip address
999 port: the http, ssh, ... port
1000 suffix: extra text, e.g. the http path and query string
1002 self
.logger
.debug("Getting VM CONSOLE from VIM")
1004 self
._reload
_connection
()
1005 server
= self
.nova
.servers
.find(id=vm_id
)
1006 if console_type
== None or console_type
== "novnc":
1007 console_dict
= server
.get_vnc_console("novnc")
1008 elif console_type
== "xvpvnc":
1009 console_dict
= server
.get_vnc_console(console_type
)
1010 elif console_type
== "rdp-html5":
1011 console_dict
= server
.get_rdp_console(console_type
)
1012 elif console_type
== "spice-html5":
1013 console_dict
= server
.get_spice_console(console_type
)
1015 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
), http_code
=vimconn
.HTTP_Bad_Request
)
1017 console_dict1
= console_dict
.get("console")
1019 console_url
= console_dict1
.get("url")
1022 protocol_index
= console_url
.find("//")
1023 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1024 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1025 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1026 return -vimconn
.HTTP_Internal_Server_Error
, "Unexpected response from VIM"
1027 console_dict
={"protocol": console_url
[0:protocol_index
],
1028 "server": console_url
[protocol_index
+2:port_index
],
1029 "port": console_url
[port_index
:suffix_index
],
1030 "suffix": console_url
[suffix_index
+1:]
1034 raise vimconn
.vimconnUnexpectedResponse("Unexpected response from VIM")
1036 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.BadRequest
, ConnectionError
) as e
:
1037 self
._format
_exception
(e
)
1039 def delete_vminstance(self
, vm_id
):
1040 '''Removes a VM instance from VIM. Returns the old identifier
1042 #print "osconnector: Getting VM from VIM"
1044 self
._reload
_connection
()
1045 #delete VM ports attached to this networks before the virtual machine
1046 ports
= self
.neutron
.list_ports(device_id
=vm_id
)
1047 for p
in ports
['ports']:
1049 self
.neutron
.delete_port(p
["id"])
1050 except Exception as e
:
1051 self
.logger
.error("Error deleting port: " + type(e
).__name
__ + ": "+ str(e
))
1053 #commented because detaching the volumes makes the servers.delete not work properly ?!?
1054 #dettach volumes attached
1055 server
= self
.nova
.servers
.get(vm_id
)
1056 volumes_attached_dict
= server
._info
['os-extended-volumes:volumes_attached']
1057 #for volume in volumes_attached_dict:
1058 # self.cinder.volumes.detach(volume['id'])
1060 self
.nova
.servers
.delete(vm_id
)
1063 #Although having detached them should have them in active status
1064 #we ensure in this loop
1067 while keep_waiting
and elapsed_time
< volume_timeout
:
1068 keep_waiting
= False
1069 for volume
in volumes_attached_dict
:
1070 if self
.cinder
.volumes
.get(volume
['id']).status
!= 'available':
1073 self
.cinder
.volumes
.delete(volume
['id'])
1079 except (nvExceptions
.NotFound
, ksExceptions
.ClientException
, nvExceptions
.ClientException
, ConnectionError
) as e
:
1080 self
._format
_exception
(e
)
1081 #TODO insert exception vimconn.HTTP_Unauthorized
1082 #if reaching here is because an exception
1084 def refresh_vms_status(self
, vm_list
):
1085 '''Get the status of the virtual machines and their interfaces/ports
1086 Params: the list of VM identifiers
1087 Returns a dictionary with:
1088 vm_id: #VIM id of this Virtual Machine
1089 status: #Mandatory. Text with one of:
1090 # DELETED (not found at vim)
1091 # VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
1092 # OTHER (Vim reported other status not understood)
1093 # ERROR (VIM indicates an ERROR status)
1094 # ACTIVE, PAUSED, SUSPENDED, INACTIVE (not running),
1095 # CREATING (on building process), ERROR
1096 # ACTIVE:NoMgmtIP (Active but any of its interface has an IP address
1098 error_msg: #Text with VIM error message, if any. Or the VIM connection ERROR
1099 vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1101 - vim_info: #Text with plain information obtained from vim (yaml.safe_dump)
1102 mac_address: #Text format XX:XX:XX:XX:XX:XX
1103 vim_net_id: #network id where this interface is connected
1104 vim_interface_id: #interface/port VIM id
1105 ip_address: #null, or text with IPv4, IPv6 address
1106 compute_node: #identification of compute node where PF,VF interface is allocated
1107 pci: #PCI address of the NIC that hosts the PF,VF
1108 vlan: #physical VLAN used for VF
1111 self
.logger
.debug("refresh_vms status: Getting tenant VM instance information from VIM")
1112 for vm_id
in vm_list
:
1115 vm_vim
= self
.get_vminstance(vm_id
)
1116 if vm_vim
['status'] in vmStatus2manoFormat
:
1117 vm
['status'] = vmStatus2manoFormat
[ vm_vim
['status'] ]
1119 vm
['status'] = "OTHER"
1120 vm
['error_msg'] = "VIM status reported " + vm_vim
['status']
1122 vm
['vim_info'] = yaml
.safe_dump(vm_vim
, default_flow_style
=True, width
=256)
1123 except yaml
.representer
.RepresenterError
:
1124 vm
['vim_info'] = str(vm_vim
)
1125 vm
["interfaces"] = []
1126 if vm_vim
.get('fault'):
1127 vm
['error_msg'] = str(vm_vim
['fault'])
1130 self
._reload
_connection
()
1131 port_dict
=self
.neutron
.list_ports(device_id
=vm_id
)
1132 for port
in port_dict
["ports"]:
1135 interface
['vim_info'] = yaml
.safe_dump(port
, default_flow_style
=True, width
=256)
1136 except yaml
.representer
.RepresenterError
:
1137 interface
['vim_info'] = str(port
)
1138 interface
["mac_address"] = port
.get("mac_address")
1139 interface
["vim_net_id"] = port
["network_id"]
1140 interface
["vim_interface_id"] = port
["id"]
1141 # check if OS-EXT-SRV-ATTR:host is there,
1142 # in case of non-admin credentials, it will be missing
1143 if vm_vim
.get('OS-EXT-SRV-ATTR:host'):
1144 interface
["compute_node"] = vm_vim
['OS-EXT-SRV-ATTR:host']
1145 interface
["pci"] = None
1147 # check if binding:profile is there,
1148 # in case of non-admin credentials, it will be missing
1149 if port
.get('binding:profile'):
1150 if port
['binding:profile'].get('pci_slot'):
1151 # TODO: At the moment sr-iov pci addresses are converted to PF pci addresses by setting the slot to 0x00
1152 # TODO: This is just a workaround valid for niantinc. Find a better way to do so
1153 # CHANGE DDDD:BB:SS.F to DDDD:BB:00.(F%2) assuming there are 2 ports per nic
1154 pci
= port
['binding:profile']['pci_slot']
1155 # interface["pci"] = pci[:-4] + "00." + str(int(pci[-1]) % 2)
1156 interface
["pci"] = pci
1157 interface
["vlan"] = None
1158 #if network is of type vlan and port is of type direct (sr-iov) then set vlan id
1159 network
= self
.neutron
.show_network(port
["network_id"])
1160 if network
['network'].get('provider:network_type') == 'vlan' and \
1161 port
.get("binding:vnic_type") == "direct":
1162 interface
["vlan"] = network
['network'].get('provider:segmentation_id')
1164 #look for floating ip address
1165 floating_ip_dict
= self
.neutron
.list_floatingips(port_id
=port
["id"])
1166 if floating_ip_dict
.get("floatingips"):
1167 ips
.append(floating_ip_dict
["floatingips"][0].get("floating_ip_address") )
1169 for subnet
in port
["fixed_ips"]:
1170 ips
.append(subnet
["ip_address"])
1171 interface
["ip_address"] = ";".join(ips
)
1172 vm
["interfaces"].append(interface
)
1173 except Exception as e
:
1174 self
.logger
.error("Error getting vm interface information " + type(e
).__name
__ + ": "+ str(e
))
1175 except vimconn
.vimconnNotFoundException
as e
:
1176 self
.logger
.error("Exception getting vm status: %s", str(e
))
1177 vm
['status'] = "DELETED"
1178 vm
['error_msg'] = str(e
)
1179 except vimconn
.vimconnException
as e
:
1180 self
.logger
.error("Exception getting vm status: %s", str(e
))
1181 vm
['status'] = "VIM_ERROR"
1182 vm
['error_msg'] = str(e
)
1186 def action_vminstance(self
, vm_id
, action_dict
):
1187 '''Send and action over a VM instance from VIM
1188 Returns the vm_id if the action was successfully sent to the VIM'''
1189 self
.logger
.debug("Action over VM '%s': %s", vm_id
, str(action_dict
))
1191 self
._reload
_connection
()
1192 server
= self
.nova
.servers
.find(id=vm_id
)
1193 if "start" in action_dict
:
1194 if action_dict
["start"]=="rebuild":
1197 if server
.status
=="PAUSED":
1199 elif server
.status
=="SUSPENDED":
1201 elif server
.status
=="SHUTOFF":
1203 elif "pause" in action_dict
:
1205 elif "resume" in action_dict
:
1207 elif "shutoff" in action_dict
or "shutdown" in action_dict
:
1209 elif "forceOff" in action_dict
:
1211 elif "terminate" in action_dict
:
1213 elif "createImage" in action_dict
:
1214 server
.create_image()
1215 #"path":path_schema,
1216 #"description":description_schema,
1217 #"name":name_schema,
1218 #"metadata":metadata_schema,
1219 #"imageRef": id_schema,
1220 #"disk": {"oneOf":[{"type": "null"}, {"type":"string"}] },
1221 elif "rebuild" in action_dict
:
1222 server
.rebuild(server
.image
['id'])
1223 elif "reboot" in action_dict
:
1224 server
.reboot() #reboot_type='SOFT'
1225 elif "console" in action_dict
:
1226 console_type
= action_dict
["console"]
1227 if console_type
== None or console_type
== "novnc":
1228 console_dict
= server
.get_vnc_console("novnc")
1229 elif console_type
== "xvpvnc":
1230 console_dict
= server
.get_vnc_console(console_type
)
1231 elif console_type
== "rdp-html5":
1232 console_dict
= server
.get_rdp_console(console_type
)
1233 elif console_type
== "spice-html5":
1234 console_dict
= server
.get_spice_console(console_type
)
1236 raise vimconn
.vimconnException("console type '{}' not allowed".format(console_type
),
1237 http_code
=vimconn
.HTTP_Bad_Request
)
1239 console_url
= console_dict
["console"]["url"]
1241 protocol_index
= console_url
.find("//")
1242 suffix_index
= console_url
[protocol_index
+2:].find("/") + protocol_index
+2
1243 port_index
= console_url
[protocol_index
+2:suffix_index
].find(":") + protocol_index
+2
1244 if protocol_index
< 0 or port_index
<0 or suffix_index
<0:
1245 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1246 console_dict2
={"protocol": console_url
[0:protocol_index
],
1247 "server": console_url
[protocol_index
+2 : port_index
],
1248 "port": int(console_url
[port_index
+1 : suffix_index
]),
1249 "suffix": console_url
[suffix_index
+1:]
1251 return console_dict2
1252 except Exception as e
:
1253 raise vimconn
.vimconnException("Unexpected response from VIM " + str(console_dict
))
1256 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
, nvExceptions
.NotFound
, ConnectionError
) as e
:
1257 self
._format
_exception
(e
)
1258 #TODO insert exception vimconn.HTTP_Unauthorized
1262 def new_external_port(self
, port_data
):
1263 #TODO openstack if needed
1264 '''Adds a external port to VIM'''
1265 '''Returns the port identifier'''
1266 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.new_external_port() not implemented"
1268 def connect_port_network(self
, port_id
, network_id
, admin
=False):
1269 #TODO openstack if needed
1270 '''Connects a external port to a network'''
1271 '''Returns status code of the VIM response'''
1272 return -vimconn
.HTTP_Internal_Server_Error
, "osconnector.connect_port_network() not implemented"
1274 def new_user(self
, user_name
, user_passwd
, tenant_id
=None):
1275 '''Adds a new user to openstack VIM'''
1276 '''Returns the user identifier'''
1277 self
.logger
.debug("osconnector: Adding a new user to VIM")
1279 self
._reload
_connection
()
1280 user
=self
.keystone
.users
.create(user_name
, user_passwd
, tenant_id
=tenant_id
)
1281 #self.keystone.tenants.add_user(self.k_creds["username"], #role)
1283 except ksExceptions
.ConnectionError
as e
:
1284 error_value
=-vimconn
.HTTP_Bad_Request
1285 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1286 except ksExceptions
.ClientException
as e
: #TODO remove
1287 error_value
=-vimconn
.HTTP_Bad_Request
1288 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1289 #TODO insert exception vimconn.HTTP_Unauthorized
1290 #if reaching here is because an exception
1292 self
.logger
.debug("new_user " + error_text
)
1293 return error_value
, error_text
1295 def delete_user(self
, user_id
):
1296 '''Delete a user from openstack VIM'''
1297 '''Returns the user identifier'''
1299 print "osconnector: Deleting a user from VIM"
1301 self
._reload
_connection
()
1302 self
.keystone
.users
.delete(user_id
)
1304 except ksExceptions
.ConnectionError
as e
:
1305 error_value
=-vimconn
.HTTP_Bad_Request
1306 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1307 except ksExceptions
.NotFound
as e
:
1308 error_value
=-vimconn
.HTTP_Not_Found
1309 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1310 except ksExceptions
.ClientException
as e
: #TODO remove
1311 error_value
=-vimconn
.HTTP_Bad_Request
1312 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1313 #TODO insert exception vimconn.HTTP_Unauthorized
1314 #if reaching here is because an exception
1316 print "delete_tenant " + error_text
1317 return error_value
, error_text
1319 def get_hosts_info(self
):
1320 '''Get the information of deployed hosts
1321 Returns the hosts content'''
1323 print "osconnector: Getting Host info from VIM"
1326 self
._reload
_connection
()
1327 hypervisors
= self
.nova
.hypervisors
.list()
1328 for hype
in hypervisors
:
1329 h_list
.append( hype
.to_dict() )
1330 return 1, {"hosts":h_list
}
1331 except nvExceptions
.NotFound
as e
:
1332 error_value
=-vimconn
.HTTP_Not_Found
1333 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1334 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1335 error_value
=-vimconn
.HTTP_Bad_Request
1336 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1337 #TODO insert exception vimconn.HTTP_Unauthorized
1338 #if reaching here is because an exception
1340 print "get_hosts_info " + error_text
1341 return error_value
, error_text
1343 def get_hosts(self
, vim_tenant
):
1344 '''Get the hosts and deployed instances
1345 Returns the hosts content'''
1346 r
, hype_dict
= self
.get_hosts_info()
1349 hypervisors
= hype_dict
["hosts"]
1351 servers
= self
.nova
.servers
.list()
1352 for hype
in hypervisors
:
1353 for server
in servers
:
1354 if server
.to_dict()['OS-EXT-SRV-ATTR:hypervisor_hostname']==hype
['hypervisor_hostname']:
1356 hype
['vm'].append(server
.id)
1358 hype
['vm'] = [server
.id]
1360 except nvExceptions
.NotFound
as e
:
1361 error_value
=-vimconn
.HTTP_Not_Found
1362 error_text
= (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1363 except (ksExceptions
.ClientException
, nvExceptions
.ClientException
) as e
:
1364 error_value
=-vimconn
.HTTP_Bad_Request
1365 error_text
= type(e
).__name
__ + ": "+ (str(e
) if len(e
.args
)==0 else str(e
.args
[0]))
1366 #TODO insert exception vimconn.HTTP_Unauthorized
1367 #if reaching here is because an exception
1369 print "get_hosts " + error_text
1370 return error_value
, error_text